Removed iterabler, added sized_iterable, added mutable to functions

Author: Kaaserne

examples/algorithm.cpp

@@ -318,9 +318,9 @@ int main() {
         auto distance = lz::distance(v.begin(), pos);
         std::cout << *pos << " with distance " << distance << '\n'; // 2 with distance 1
         ++pos;
-        auto iterable = lz::to_iterable(pos, v.end());
-        pos = lz::adjacent_find(iterable);
-        std::cout << (pos == iterable.end()) << "\n\n"; // true
+        lz::sized_iterable<decltype(v.begin())> iterable(pos, v.end());
+        auto new_pos = lz::adjacent_find(iterable);
+        std::cout << (new_pos == iterable.end()) << "\n\n"; // true
     }
     {
         std::cout << "Count if\n";

examples/basic_iterable.cpp

@@ -1,36 +1,54 @@
 #include <Lz/basic_iterable.hpp>
 #include <Lz/c_string.hpp>
+#include <vector>
 
 int main() {
     // - Iterable as template parameter
     // - Iterable as function argument
     // - Iterable has a .size() method because arr has a size
     int arr[] = { 1, 2, 3, 4, 5 };
-    lz::basic_iterable<int[5]> iterable_iterable = lz::to_iterable(arr);
+    lz::basic_iterable<int[5]> iterable_iterable(arr);
     std::cout << iterable_iterable.size() << '\n'; // Output: 5
 
     // - Iterator as template parameter
     // - Iterable as function argument
     // - Iterable has size() method because std::begin(arr) and std::end(arr) are random access iterators
-    lz::basic_iterable<int*> iterator_iterable = lz::to_iterable(arr);
+    lz::basic_iterable<int*> iterator_iterable(arr);
     std::cout << iterator_iterable.size() << '\n'; // Output: 5
 
     // - Iterable as template parameter
     // - Iterator as function argument
     // - Iterable has size() method because std::begin(arr) and std::end(arr) are random access iterators
-    lz::basic_iterable<int[5]> iterable_iterator = lz::to_iterable(std::begin(arr), std::end(arr));
+    lz::basic_iterable<int[5]> iterable_iterator(std::begin(arr), std::end(arr));
     std::cout << iterable_iterator.size() << '\n'; // Output: 5
 
     // - Iterator as template parameter
     // - Iterator as function argument
     // - Iterable has size() method because std::begin(arr) and std::end(arr) are random access iterators
-    lz::basic_iterable<int*> iterator_iterator = lz::to_iterable(std::begin(arr), std::end(arr));
+    lz::basic_iterable<int*> iterator_iterator(std::begin(arr), std::end(arr));
     std::cout << iterator_iterator.size() << '\n'; // Output: 5
 
     // You can also work with sentinels:
     auto cstr = lz::c_string("Hello, world!");
     using it = decltype(cstr.begin());
     using sentinel = decltype(cstr.end());
-    lz::basic_iterable<it, sentinel> iterable = lz::to_iterable(cstr.begin(), cstr.end());
+    lz::basic_iterable<it, sentinel> iterable(cstr.begin(), cstr.end());
+    std::cout << "c_string iterable does not contain a size() method\n";
     // iterable does not contain a size() method because cstr does not have a size and is also not random access
+
+    // This also creates a sized iterable
+    using it = decltype(cstr.begin());
+    using sentinel = decltype(cstr.end());
+    // We need to specify that it is a sized iterable
+    lz::sized_iterable<it, sentinel> sized_cstr_iterable(cstr.begin(), 5);
+    std::cout << sized_cstr_iterable.size() << '\n'; // Output: 5
+    // iterable now contains "Hello"
+
+    // The following would get an error because cstr is not random access and there's no way to get the size
+    // lz::sized_iterable<it, sentinel> sized_cstr_iterable(cstr.begin(), cstr.end());
+
+    // With STL containers you can use the following:
+    std::vector<int> vec = { 1, 2, 3, 4, 5 };
+    lz::basic_iterable<std::vector<int>::iterator> vec_iterable(vec.begin(), vec.end());
+    std::cout << vec_iterable.size() << '\n'; // Output: 5
 }

examples/c_string.cpp

@@ -5,6 +5,7 @@
 int main() {
     const char* my_str = "Hello, World!";
 
+#ifdef LZ_HAS_CXX_17
     for (const char& c : lz::c_string(my_str)) {
         std::cout << c;
         // or use fmt::print("{}\n", c);
@@ -19,4 +20,19 @@ int main() {
     }
     // Output: Hello, World!
     std::cout << '\n';
+#else
+    lz::for_each(lz::c_string(my_str), [](const char& c) {
+        std::cout << c;
+        // or use fmt::print("{}\n", c);
+    });
+    // Output: Hello, World!
+
+    std::cout << '\n';
+    const char my_str_iterable[] = "Hello, World!";
+    lz::for_each(my_str_iterable | lz::c_string, [](const char& c) {
+        std::cout << c;
+        // or use fmt::print("{}\n", c);
+    });
+// Output: Hello, World!
+#endif
 }

examples/chunk_if.cpp

@@ -5,6 +5,7 @@ int main() {
 	std::string s = "hello world; this is a message;";
 	auto chunked = lz::chunk_if(s, [](const char c) { return c == ';'; });
 
+#ifdef LZ_HAS_CXX_17
     for (auto chunk : chunked) {
         for (char& c : chunk) {
             std::cout << c;
@@ -58,4 +59,59 @@ int main() {
         // or use fmt::print("\n");
         std::cout << '\n';
     }
-}
+#else
+    using string_iterable = lz::basic_iterable<std::string::const_iterator>;
+    lz::for_each(chunked, [](string_iterable chunk) {
+        for (char c : chunk) {
+            std::cout << c;
+            // or use fmt::print("{}", c);
+        }
+        std::cout << '\n';
+    });
+    // Output:
+    // hello world
+    //  this is a message
+
+    lz::for_each(s | lz::chunk_if([](const char c) { return c == ';'; }), [](string_iterable chunk) {
+        for (char c : chunk) {
+            std::cout << c;
+            // or use fmt::print("{}", c);
+        }
+        std::cout << '\n';
+    });
+    // Output:
+    // hello world
+    //  this is a message
+
+    // With lz::string[_view]
+    lz::for_each(s | lz::sv_chunk_if([](const char c) { return c == ';'; }), [](const lz::string_view chunk) {
+        std::cout.write(chunk.data(), chunk.size());
+        std::cout << '\n';
+    });
+    // Output:
+    // hello world
+    //  this is a message
+
+    lz::for_each(s | lz::s_chunk_if([](const char c) { return c == ';'; }), [](const std::string& chunk) {
+        std::cout << chunk << '\n';
+        // or use fmt::print("{}\n", chunk);
+    });
+    // Output:
+    // hello world
+    //  this is a message
+
+    // with custom types
+    lz::for_each(s | lz::t_chunk_if<std::vector<char>>([](const char c) { return c == ';'; }),
+                 [](const std::vector<char>& vec_chunk) {
+                     for (char c : vec_chunk) {
+                         std::cout << c;
+                         // or use fmt::print("{}", c);
+                     }
+                     std::cout << '\n';
+                 });
+    // Output:
+    // hello world
+    //  this is a message
+
+#endif
+}

examples/custom_iterator.cpp

@@ -204,34 +204,34 @@ int main() {
 
     // ---------------- Custom iterator example ----------------
     std::cout << "Custom forward iterator example, going forward.\n";
-    auto view = lz::to_iterable(custom_fwd_iterator{ 0 }, custom_fwd_iterator{ 10 });
+    lz::basic_iterable<custom_fwd_iterator> view(custom_fwd_iterator{ 0 }, custom_fwd_iterator{ 10 });
     for (/* const */ int& i : view) {
         std::cout << i << '\n';
     }
     std::cout << '\n';
 
     std::cout << "Custom bidirectional iterator example, going backward.\n";
-    auto view2 = lz::to_iterable(custom_bidi_iterator{ 0 }, custom_bidi_iterator{ 10 });
-    for (/* const */ int& i : lz::reverse(view2)) {
+    lz::basic_iterable<custom_bidi_iterator> view1(custom_bidi_iterator{ 0 }, custom_bidi_iterator{ 10 });
+    for (/* const */ int& i : lz::reverse(view1)) {
         std::cout << i << '\n';
     }
     std::cout << '\n';
 
     std::cout << "Custom random access iterator example, going forward.\n";
-    auto view3 = lz::to_iterable(custom_ra_iterator{ 0 }, custom_ra_iterator{ 10 });
-    for (/* const */ int& i : view3) {
+    lz::basic_iterable<custom_ra_iterator> view2(custom_ra_iterator{ 0 }, custom_ra_iterator{ 10 });
+    for (/* const */ int& i : view2) {
         std::cout << i << '\n';
     }
     std::cout << '\n';
 
     std::cout << "Custom random access iterator example, going backward.\n";
-    for (/* [const] */ int& i : lz::reverse(view3)) {
+    for (/* [const] */ int& i : lz::reverse(view2)) {
         std::cout << i << '\n';
     }
     std::cout << '\n';
 
     std::cout << "Custom random access iterator example, going forward with step 2.\n";
-    auto it_start = view3.begin();
+    auto it_start = view2.begin();
     std::cout << "*it_start = " << *it_start << '\n';
     std::cout << "*(it_start + 2) = " << *(it_start + 2) << '\n';
 }

examples/exclude.cpp

@@ -10,6 +10,7 @@ int main() {
     std::sort(to_except.begin(), to_except.end()); // Always sort values to except before creating except object
     const auto except = lz::except(values, to_except);
 
+#ifdef LZ_HAS_CXX_17
     for (int& i : except) {
         std::cout << i << ' ';
         // or use fmt::print("{} ", i);
@@ -25,4 +26,20 @@ int main() {
     std::cout << '\n';
     // Output:
     // 1 5
+#else
+    lz::for_each(except, [](int i) {
+        std::cout << i << ' ';
+        // or use fmt::print("{} ", i);
+    });
+    std::cout << '\n';
+    // Output:
+    // 1 5
+
+    lz::for_each(values | lz::except(to_except), [](int i) {
+        std::cout << i << ' ';
+        // or use fmt::print("{} ", i);
+    });
+    // Output:
+    // 1 5
+#endif
 }

examples/exclusive_scan.cpp

@@ -8,6 +8,7 @@ int main() {
     // operator+ is required or add a custom operator+ in its third parameter
     auto scan = lz::exclusive_scan(array, 0);
 
+#ifdef LZ_HAS_CXX_17
     for (int& i : scan) {
         std::cout << i << ' ';
         // Or use fmt::print("{} ", i);
@@ -43,4 +44,41 @@ int main() {
     // 0 + 3 + 5 + 2 + 3 + 4 (17)
     // 0 + 3 + 5 + 2 + 3 + 4 + 2 (19)
     // 0 + 3 + 5 + 2 + 3 + 4 + 2 + 3 (22)
-}
+#else
+    lz::for_each(scan, [](int i) {
+        std::cout << i << ' ';
+        // Or use fmt::print("{} ", i);
+    });
+    // prints 0 3 8 10 13 17 19 22
+
+    // essentially it's:
+    // 0 (0)
+    // 0 + 3 (3)
+    // 0 + 3 + 5 (8)
+    // 0 + 3 + 5 + 2 (10)
+    // 0 + 3 + 5 + 2 + 3 (13)
+    // 0 + 3 + 5 + 2 + 3 + 4 (17)
+    // 0 + 3 + 5 + 2 + 3 + 4 + 2 (19)
+    // 0 + 3 + 5 + 2 + 3 + 4 + 2 + 3 (22)
+
+    std::cout << '\n';
+    // The 0 here is important. Cannot be left empty otherwise it will lead to compilation errors because the initial value cannot
+    // be deduced.
+    // operator+ is required or add a custom operator+ in its second parameter
+    lz::for_each(array | lz::exclusive_scan(0), [](int i) {
+        std::cout << i << ' ';
+        // Or use fmt::print("{} ", i);
+    });
+// prints 0 3 8 10 13 17 19 22
+
+// essentially it's:
+// 0 (0)
+// 0 + 3 (3)
+// 0 + 3 + 5 (8)
+// 0 + 3 + 5 + 2 (10)
+// 0 + 3 + 5 + 2 + 3 (13)
+// 0 + 3 + 5 + 2 + 3 + 4 (17)
+// 0 + 3 + 5 + 2 + 3 + 4 + 2 (19)
+// 0 + 3 + 5 + 2 + 3 + 4 + 2 + 3 (22)
+#endif
+}

examples/generate.cpp

@@ -14,9 +14,17 @@ int main() {
         },
         amount);
 
+#ifdef LZ_HAS_CXX_17
     for (std::size_t i : gen) {
         std::cout << i << ' ';
         // Or use fmt::print("{} ", i);
     }
-    // Output: 0 1 2 3
+// Output: 0 1 2 3
+#else
+    lz::for_each(gen, [](std::size_t i) {
+        std::cout << i << ' ';
+        // Or use fmt::print("{} ", i);
+    });
+// Output: 0 1 2 3
+#endif
 }

examples/generate_while.cpp

@@ -10,10 +10,18 @@ int main() {
         return std::make_pair(copy != 4, copy);
     });
 
+#ifdef LZ_HAS_CXX_17
     // Iterator returns the same type as the function pair second type. In this case, int.
     for (int i : generator) {
         std::cout << i << ' ';
         // Or use fmt::print("{} ", i);
     }
     // Output: 0 1 2 3
+#else
+    lz::for_each(generator, [](int i) {
+        std::cout << i << ' ';
+        // Or use fmt::print("{} ", i);
+    });
+    // Output: 0 1 2 3
+#endif
 }

examples/inclusive_scan.cpp

@@ -8,6 +8,7 @@ int main() {
 
     auto scan = lz::inclusive_scan(array);
 
+#ifdef LZ_HAS_CXX_17
     for (int& i : scan) {
         std::cout << i << ' ';
         // Or use fmt::print("{} ", i);
@@ -39,4 +40,37 @@ int main() {
     // 0 + 3 + 5 + 2 + 3 + 4 = 17
     // 0 + 3 + 5 + 2 + 3 + 4 + 2 = 19
     // 0 + 3 + 5 + 2 + 3 + 4 + 2 + 3 = 22
-}
+#else
+    lz::for_each(scan, [](int i) {
+        std::cout << i << ' ';
+        // Or use fmt::print("{} ", i);
+    });
+    // prints 3 8 10 13 17 19 22
+
+    // essentially it's:
+    // 0 + 3 = 3
+    // 0 + 3 + 5 = 8
+    // 0 + 3 + 5 + 2 = 10
+    // 0 + 3 + 5 + 2 + 3 = 13
+    // 0 + 3 + 5 + 2 + 3 + 4 = 17
+    // 0 + 3 + 5 + 2 + 3 + 4 + 2 = 19
+    // 0 + 3 + 5 + 2 + 3 + 4 + 2 + 3 = 22
+
+    std::cout << '\n';
+    // The 0 here is important. Cannot be left empty otherwise it will lead to compilation errors because the initial value cannot
+    // be deduced.
+    // operator+ is required or add a custom operator+ in its second parameter
+    lz::for_each(array | lz::inclusive_scan(0), [](int i) {
+        std::cout << i << ' ';
+        // Or use fmt::print("{} ", i);
+    });
+    // essentially it's:
+    // 0 + 3 = 3
+    // 0 + 3 + 5 = 8
+    // 0 + 3 + 5 + 2 = 10
+    // 0 + 3 + 5 + 2 + 3 = 13
+    // 0 + 3 + 5 + 2 + 3 + 4 = 17
+    // 0 + 3 + 5 + 2 + 3 + 4 + 2 = 19
+    // 0 + 3 + 5 + 2 + 3 + 4 + 2 + 3 = 22
+#endif
+}