as and retro for ranges (#307)

* add `as` for ranges

* add support for ranges

Author: 9il

source/mir/ndslice/topology.d

@@ -2124,9 +2124,9 @@ auto stride(T)(T withAsSlice, ptrdiff_t factor)
 /++
 Reverses order of iteration for all dimensions.
 Params:
-    slice = Unpacked slice.
+    slice = slice, range, or array.
 Returns:
-    Slice with reversed order of iteration for all dimensions.
+    Slice/range with reversed order of iteration for all dimensions.
 See_also: $(SUBREF dynamic, reversed), $(SUBREF dynamic, allReversed).
 +/
 auto retro
@@ -2184,6 +2184,80 @@ auto retro(T)(T withAsSlice)
     return retro(withAsSlice.asSlice);
 }
 
+
+/// ditto
+auto retro(Range)(Range r)
+    if (!hasAsSlice!Range && !isSlice!Range && !is(Range : T[], T))
+{
+    import std.traits: Unqual;
+
+    static if (is(Unqual!Range == Range))
+    {
+        import core.lifetime: move;
+        static if (is(Range : RetroRange!R, R))
+        {
+            return move(r._source);
+        }
+        else
+        {
+            return RetroRange!Range(move(r));
+        }
+    }
+    else
+    {
+        return .retro!(Unqual!Range)(r);
+    }
+}
+
+/// ditto
+struct RetroRange(Range)
+{
+    import mir.primitives: hasLength;
+
+    ///
+    Range _source;
+
+    private enum hasAccessByRef = __traits(compiles, &_source.front);
+
+    @property 
+    {
+        bool empty()() const { return _source.empty; }
+        static if (hasLength!Range)
+            auto length()() const { return _source.length; }
+        auto ref front()() { return _source.back; }
+        auto ref back()() { return _source.front; }
+        static if (__traits(hasMember, Range, "save"))
+            auto save()() { return RetroRange(_source.save); }
+        alias opDollar = length;
+
+        static if (!hasAccessByRef)
+        {
+            import std.traits: ForeachType;
+
+            void front()(ForeachType!R val)
+            {
+                import mir.functional: forward;
+                _source.back = forward!val;
+            }
+
+            void back()(ForeachType!R val)
+            {
+                import mir.functional: forward;
+                _source.front = forward!val;
+            }
+        }
+    }
+
+    void popFront()() { _source.popBack(); }
+    void popBack()() { _source.popFront(); }
+
+    static if (is(typeof(_source.moveBack())))
+    auto moveFront()() { return _source.moveBack(); }
+
+    static if (is(typeof(_source.moveFront())))
+    auto moveBack()() { return _source.moveFront(); }
+}
+
 ///
 @safe pure nothrow @nogc version(mir_test) unittest
 {
@@ -2198,6 +2272,16 @@ auto retro(T)(T withAsSlice)
     static assert(is(typeof(slice.universal.retro) == typeof(slice.universal)));
 }
 
+/// Ranges
+@safe pure nothrow @nogc version(mir_test) unittest
+{
+    import mir.algorithm.iteration: equal;
+    import std.range: std_iota = iota;
+
+    assert(std_iota(4).retro.equal(iota(4).retro));
+    static assert(is(typeof(std_iota(4).retro.retro) == typeof(std_iota(4))));
+}
+
 /++
 Bitwise slice over an integral slice.
 Params:
@@ -3308,6 +3392,20 @@ template as(T)
     {
         return as(withAsSlice.asSlice);
     }
+
+    /// ditto
+    auto as(Range)(Range r)
+        if (!hasAsSlice!Range && !isSlice!Range && !is(Range : T[], T))
+    {
+        static if (is(ForeachType!Range == T))
+            return r;
+        else
+        {
+            import core.lifetime: move;
+            import mir.conv: to;
+            return map!(to!T)(r.move);
+        }
+    }
 }
 
 ///
@@ -3341,6 +3439,13 @@ template as(T)
     Slice!(const(double)*, 2) const_matrix = matrix.as!(const double);
 }
 
+/// Ranges
+@safe pure nothrow version(mir_test) unittest
+{
+    import mir.algorithm.iteration: filter, equal;
+    assert(5.iota.filter!"a % 2".as!double.map!"a / 2".equal([0.5, 1.5]));
+}
+
 /++
 Takes a field `source` and a slice `indexes`, and creates a view of source as if its elements were reordered according to indexes.
 `indexes` may include only a subset of the elements of `source` and may also repeat elements.