octa::ceach,reach,creach

octa/array.h

@@ -25,6 +25,8 @@ struct Array {
     using ConstPointer = const T *;
     using Range = octa::PointerRange<T>;
     using ConstRange = octa::PointerRange<const T>;
+    using ReverseRange = octa::ReverseRange<Range>;
+    using ConstReverseRange = octa::ReverseRange<ConstRange>;
 
     T &operator[](Size i) { return p_buf[i]; }
     const T &operator[](Size i) const { return p_buf[i]; }
@@ -57,6 +59,19 @@ struct Array {
     ConstRange each() const {
         return ConstRange(p_buf, p_buf + N);
     }
+    ConstRange ceach() const {
+        return ConstRange(p_buf, p_buf + N);
+    }
+
+    ReverseRange reach() {
+        return each().reach();
+    }
+    ConstReverseRange reach() const {
+        return each().reach();
+    }
+    ConstReverseRange creach() const {
+        return ceach().reach();
+    }
 
     void swap(Array &v) {
         octa::swap_ranges(each(), v.each());

octa/initializer_list.h

@@ -43,6 +43,25 @@ octa::PointerRange<const T> each(std::initializer_list<T> init) {
     return octa::PointerRange<const T>(init.begin(), init.end());
 }
 
+template<typename T>
+octa::PointerRange<const T> ceach(std::initializer_list<T> init) {
+    return octa::PointerRange<const T>(init.begin(), init.end());
+}
+
+template<typename T>
+octa::ReverseRange<octa::PointerRange<const T>>
+reach(std::initializer_list<T> init) {
+    return octa::ReverseRange<octa::PointerRange<const T>>(init.begin(),
+        init.end());
+}
+
+template<typename T>
+octa::ReverseRange<octa::PointerRange<const T>>
+ceach(std::initializer_list<T> init) {
+    return octa::ReverseRange<octa::PointerRange<const T>>(init.begin(),
+        init.end());
+}
+
 }
 
 #endif

octa/range.h

@@ -284,6 +284,8 @@ namespace detail {
     }
 }
 
+template<typename> struct ReverseRange;
+
 template<typename B, typename C, typename V, typename R = V &,
          typename S = octa::Size, typename D = octa::Ptrdiff
 > struct InputRange {
@@ -320,11 +322,45 @@ template<typename B, typename C, typename V, typename R = V &,
         return B(*((B *)this));
     }
 
+    ReverseRange<B> reach() const {
+        return ReverseRange<B>(each());
+    }
+
     RangeHalf<B> half() const {
         return RangeHalf<B>(*((B *)this));
     }
 };
 
+template<typename T>
+auto each(T &r) -> decltype(r.each()) {
+    return r.each();
+}
+
+template<typename T>
+auto each(const T &r) -> decltype(r.each()) {
+    return r.each();
+}
+
+template<typename T>
+auto ceach(const T &r) -> decltype(r.each()) {
+    return r.each();
+}
+
+template<typename T>
+auto reach(T &r) -> decltype(r.reach()) {
+    return r.reach();
+}
+
+template<typename T>
+auto reach(const T &r) -> decltype(r.reach()) {
+    return r.reach();
+}
+
+template<typename T>
+auto creach(const T &r) -> decltype(r.reach()) {
+    return r.reach();
+}
+
 template<typename V, typename R = V &, typename S = octa::Size,
          typename D = octa::Ptrdiff
 > struct OutputRange {
@@ -412,11 +448,6 @@ public:
     }
 };
 
-template<typename T>
-ReverseRange<T> make_reverse_range(const T &it) {
-    return ReverseRange<T>(it);
-}
-
 template<typename T>
 struct MoveRange: InputRange<MoveRange<T>,
     RangeCategory<T>, RangeValue<T>, RangeValue<T> &&, RangeSize<T>,
@@ -644,6 +675,16 @@ private:
     T *p_beg, *p_end;
 };
 
+template<typename T, octa::Size N>
+PointerRange<T> each(T (&array)[N]) {
+    return PointerRange<T>(array, N);
+}
+
+template<typename T, octa::Size N>
+ReverseRange<PointerRange<T>> reach(T (&array)[N]) {
+    return ReverseRange<PointerRange<T>>(PointerRange<T>(array, N));
+}
+
 template<typename T, typename S>
 struct EnumeratedValue {
     S index;
@@ -858,21 +899,6 @@ ChunksRange<T> chunks(const T &it, RangeSize<T> chs) {
     return ChunksRange<T>(it, chs);
 }
 
-template<typename T>
-auto each(T &r) -> decltype(r.each()) {
-    return r.each();
-}
-
-template<typename T>
-auto each(const T &r) -> decltype(r.each()) {
-    return r.each();
-}
-
-template<typename T, octa::Size N>
-PointerRange<T> each(T (&array)[N]) {
-    return PointerRange<T>(array, N);
-}
-
 // range of
 template<typename T> using RangeOf = decltype(octa::each(octa::declval<T>()));
 

octa/string.h

@@ -149,6 +149,8 @@ public:
     using ConstPointer = const T *;
     using Range = octa::StringRangeBase<T>;
     using ConstRange = octa::StringRangeBase<const T>;
+    using ReverseRange = octa::ReverseRange<Range>;
+    using ConstReverseRange = octa::ReverseRange<ConstRange>;
     using Allocator = A;
 
     StringBase(const A &a = A()): p_buf(1, '\0', a) {}
@@ -294,6 +296,19 @@ public:
     ConstRange each() const {
         return ConstRange(p_buf.data(), size());
     }
+    ConstRange ceach() const {
+        return ConstRange(p_buf.data(), size());
+    }
+
+    ReverseRange reach() {
+        return each().reach();
+    }
+    ConstReverseRange reach() const {
+        return each().reach();
+    }
+    ConstReverseRange creach() const {
+        return ceach().reach();
+    }
 
     void swap(StringBase &v) {
         p_buf.swap(v);

octa/vector.h

@@ -127,6 +127,8 @@ public:
     using ConstPointer = const T *;
     using Range = octa::PointerRange<T>;
     using ConstRange = octa::PointerRange<const T>;
+    using ReverseRange = octa::ReverseRange<Range>;
+    using ConstReverseRange = octa::ReverseRange<ConstRange>;
     using Allocator = A;
 
     Vector(const A &a = A()): p_buf(nullptr, a), p_len(0), p_cap(0) {}
@@ -411,6 +413,19 @@ public:
     ConstRange each() const {
         return ConstRange(p_buf.p_ptr, p_buf.p_ptr + p_len);
     }
+    ConstRange ceach() const {
+        return ConstRange(p_buf.p_ptr, p_buf.p_ptr + p_len);
+    }
+
+    ReverseRange reach() {
+        return each().reach();
+    }
+    ConstReverseRange reach() const {
+        return each().reach();
+    }
+    ConstReverseRange creach() const {
+        return ceach().reach();
+    }
 
     void swap(Vector &v) {
         octa::swap(p_len, v.p_len);