std::random_device rd;
std::std::mt19937 gen(rd());
std::uniform_int_distribution dist(0, 32);

for (int i = 0; i < n; i++) {
 std::cout << dist(gen); // prints a random number n times, between [0, 32]
}

// If standalone:
std::cout << lz::random(0, 32, n);

// If with fmt:
fmt::print("{}", lz::random(0, 32, n));

std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution dist(0, 32);
std::vector<int> random_numbers;
std::generate(random_numbers.begin(), random_numbers.end(), [&dist, &gen]{ return dist(gen); });

std::vector<int> random_numbers = lz::random(0, 32, n) | lz::to<std::vector>();

auto random = lz::random(0, 32, n);
// Calls lz::find
auto pos = lz::find(random, 6) != random.end();

auto common = lz::common_random(0, 32, n);
// Calls std::find
auto pos = lz::find(common, 6) != common.end();
// or (exactly the same as above)
auto pos = std::find(common.begin(), common.end(), 6) != common.end();

#include <Lz/map.hpp>
#include <vector>

int main() {
  std::array<int, 4> arr = {1, 2, 3, 4};
  auto result = lz::map(arr, [](int i) { return i + 1; }) 
                       | lz::to<std::vector>(); // == {2, 3, 4, 5}
  // or
  auto result = arr | lz::map([](int i) { return i + 1; })
                    | lz::to<std::vector>(); // == {2, 3, 4, 5}

  // Some iterables will return sentinels, for instance (specific rules about when sentinels are returned can be found in the documentation):
  std::vector<int> vec = {1, 2, 3, 4};
  auto forward = lz::c_string("Hello World"); // .end() returns default_sentinel
  auto inf_loop = lz::loop(vec); // .end() returns default_sentinel
  auto random = lz::random(0, 32, 4); // .end() returns default_sentinel

  // Some iterables are sized, if the input iterable is also sized:
  auto sized = lz::map(vec, [](int i) { return i + 1; });
  auto size = sized.size(); // == 4
  // forward.size(); // error: forward is not sized, instead use (O(n) time): lz::eager_size(forward)

  // Some iterables require the size of iterables. If the input iterable is not sized,
  // the sequence will be traversed to get the size using lz::eager_size. The iterable will be documented
  // appropriately if this requires a sized iterable. Example:
  auto zipper1 = lz::zip(lz::c_string("ab"), lz::c_string("cd")); // Calling .end() will take O(n) time
  auto zipper2 = lz::zip(sized, sized); // Takes O(1) time

  // You can cache the size if you need to (more about when to do that in the appropriate iterable documentation):
  auto cached_sizes = lz::zip(lz::c_string("ab") | lz::cache_size, lz::c_string("cd") | lz::cache_size); // Takes O(n) time
  // However cached_sizes.end() will now take O(1) time
}

#include <Lz/lz.hpp>

struct non_lz_iterable {
  int* _begin{};
  int* _end{};

  non_lz_iterable(int* begin, int* end) : _begin{ begin }, _end{ end } {
  }

  int* begin() {
    return _begin;
  }
  int* end() {
    return _end;
  }
};

int main() {
  std::vector<int> vec = {1, 2, 3, 4};
  // mapped will hold a reference to vec
  auto mapped = lz::map(vec, [](int i) { return i + 1; });
  // filtered does NOT hold a reference to mapped, but mapped still holds a reference to vec
  auto filtered = lz::filter(mapped, [](int i) { return i % 2 == 0; });

  auto random = lz::random(0, 32, 4);
  // str will *not* hold a reference to random, because random is a lazy iterable and is trivial to copy
  auto str = lz::map(random, [](int i) { return std::to_string(i); });

  lz::ref_or_view<std::vector<int>> ref(vec); // Holds a reference to vec

  using random_iterable = decltype(random);
  lz::ref_or_view<random_iterable> ref2(random); // Does NOT hold a reference to random

  non_lz_iterable non_lz(vec.data(), vec.data() + vec.size());
  lz::ref_or_view<non_lz_iterable> ref(non_lz); // Holds a reference of non_lz! Watch out for this!

  // Instead, if you don't want this behaviour, you can use lz::copied_iterable:
  lz::copied_iterable<non_lz_iterable> copied(non_lz); // Holds a copy of non_lz = cheap to copy
  // Or use the helper function:
  copied = lz::as_copied_iterable(non_lz); // Holds a copy of non_lz = cheap to copy
}

#include <Lz/c_string.hpp>
#include <Lz/algorithm.hpp>

int main() {
  auto iterable_with_sentinel = lz::c_string("Hello World");
  // Possible in C++17 and higher
  for (auto i : iterable_with_sentinel) {
    std::cout << i; // prints "Hello World"
  }

  // Possible in C++11 - 14
  lz::for_each(iterable_with_sentinel, [](char i) { std::cout << i; }); // prints "Hello World"
}

#include <Lz/stream.hpp>
#include <Lz/filter.hpp>
#include <vector>

int main() {
  std::vector<int> vec = {1, 2, 3, 4};
  auto filtered = vec | lz::filter([](int i) { return i % 2 == 0; }); // == {2, 4}

  // To a stream
  std::cout << filtered; // prints "2 4" (only works for lz iterables)
  lz::format(filtered, std::cout, ", ", "{:02d}"); // prints "02, 04" (only with {fmt} installed or C++20's <format>)
  lz::format(filtered, std::cout, ", "); // prints "2, 4"
  fmt::print("{}", fmt::join(filtered, ", ")); // prints "2, 4" (only with {fmt} installed)

  filtered | lz::format(std::cout, ", "); // prints "2, 4"
  filtered | lz::format; // prints "2, 4"
  filtered | lz::format(std::cout, ", ", "{:02d}"); // prints "02, 04" (only with {fmt} installed or C++20's <format>)
}

// Important, preprocessor macro 'LZ_STANDALONE' has to be defined already
// or
// #define LZ_STANDALONE
#include <Lz/map.hpp>
#include <vector>

int main() {
  std::array<int, 4> arr = {1, 2, 3, 4};
  auto result = lz::map(arr, [](int i) { return i + 1; }) | lz::to<std::vector>(); // == {2, 3, 4, 5}
  // or
  auto result = lz::to<std::vector>(arr | lz::map([](int i) { return i + 1; })); // == {2, 3, 4, 5}
}

#define FMT_HEADER_ONLY

#include <Lz/map.hpp>
#include <vector>

int main() {
  std::array<int, 4> arr = {1, 2, 3, 4};
  auto result = lz::map(arr, [](int i) { return i + 1; }) | lz::to<std::vector>(); // == {2, 3, 4, 5}
  // or
  auto result = lz::to<std::vector>(arr | lz::map([](int i) { return i + 1; })); // == {2, 3, 4, 5}
}