adopt for DIP1000

9il · 9il · commit 89b84442f650 · 2022-06-18T17:02:45.000+04:00
diff --git a/source/mir/algorithm/iteration.d b/source/mir/algorithm/iteration.d
@@ -703,9 +703,9 @@ S reduceImpl(alias fun, S, Slices...)(S seed, Slices slices)
     do
     {
         static if (DimensionCount!(Slices[0]) == 1)
-            seed = fun(seed, frontOf!slices);
+            mixin(`seed = fun(seed,` ~ frontOf!(Slices.length) ~ `);`);
         else
-            seed = .reduceImpl!fun(seed, frontOf!slices);
+            mixin(`seed = .reduceImpl!fun(seed,` ~ frontOf!(Slices.length) ~ `);`);
         foreach_reverse(ref slice; slices)
             slice.popFront;
     }
@@ -960,7 +960,7 @@ void eachImpl(alias fun, Slices...)(Slices slices)
     do
     {
         static if (DimensionCount!(Slices[0]) == 1)
-            fun(frontOf!slices);
+            mixin(`fun(`~ frontOf!(Slices.length) ~ `);`);
         else
             .eachImpl!fun(frontOf2!slices);
         foreach_reverse(i; Iota!(Slices.length))
@@ -988,7 +988,7 @@ void chequerEachImpl(alias fun, Slices...)(Chequer color, Slices slices)
     {
         do
         {
-            .chequerEachImpl!fun(color, frontOf!slices);
+            mixin(`.chequerEachImpl!fun(color,` ~ frontOf!(Slices.length) ~ `);`);
             color = cast(Chequer)!color;
             foreach_reverse(i; Iota!(Slices.length))
                 slices[i].popFront;
@@ -1029,7 +1029,7 @@ template eachOnBorder(alias fun)
             alias N = DimensionCount!(Slices[0]);
             static if (N == 1)
             {
-                fun(frontOf!slices);
+                mixin(`fun(`~ frontOf!(Slices.length) ~ `);`);
                 if (slices[0].length > 1)
                     fun(backOf!slices);
             }
@@ -1874,15 +1874,15 @@ bool findImpl(alias fun, size_t N, Slices...)(scope ref size_t[N] backwardIndex,
         {
             static if (DimensionCount!(Slices[0]) == 1)
             {
-                if (fun(frontOf!slices))
+                if (mixin(`fun(`~ frontOf!(Slices.length) ~ `)`))
                 {
                     backwardIndex[0] = slices[0].length;
                     return true;
                 }
             }
             else
             {
-                if (findImpl!fun(backwardIndex[1 .. $], frontOf!slices))
+                if (mixin(`findImpl!fun(backwardIndex[1 .. $],` ~ frontOf!(Slices.length) ~ `)`))
                 {
                     backwardIndex[0] = slices[0].length;
                     return true;
@@ -2018,7 +2018,7 @@ template find(alias pred)
     Constraints:
         All slices must have the same shape.
     +/
-    @optmath Select!(DimensionCount!(Slices[0]) > 1, size_t[DimensionCount!(Slices[0])], size_t) find(Slices...)(auto ref Slices slices)
+    @optmath Select!(DimensionCount!(Slices[0]) > 1, size_t[DimensionCount!(Slices[0])], size_t) find(Slices...)(Slices slices)
         if (Slices.length && allSatisfy!(hasShape, Slices))
     {
         static if (Slices.length > 1)
@@ -2125,9 +2125,10 @@ version(mir_test) unittest
     assert(bi == [1, 1]);
     assert(sl.backward(bi) == 5);
 
+    import mir.test;
     // sl was changed
-    assert(sl == [[8, 8, 8],
-                  [8, 8, 5]]);
+    sl.should == [[8, 8, 8],
+                  [8, 8, 5]];
 }
 
 @safe pure nothrow
@@ -2160,7 +2161,7 @@ size_t anyImpl(alias fun, Slices...)(Slices slices)
         {
             static if (DimensionCount!(Slices[0]) == 1)
             {
-                if (fun(frontOf!slices))
+                if (mixin(`fun(`~ frontOf!(Slices.length) ~ `)`))
                     return true;
             }
             else
@@ -2320,7 +2321,7 @@ size_t allImpl(alias fun, Slices...)(Slices slices)
         {
             static if (DimensionCount!(Slices[0]) == 1)
             {
-                if (!fun(frontOf!slices))
+                if (!mixin(`fun(`~ frontOf!(Slices.length) ~ `)`))
                     return false;
             }
             else
@@ -2634,7 +2635,7 @@ template equal(alias pred = "a == b")
                     }
                     if (empty)
                         return true;
-                    if (!pred(frontOf!slices))
+                    if (!mixin(`pred(`~ frontOf!(Slices.length) ~ `)`))
                         goto False;
                     foreach (ref slice; slices)
                         slice.popFront;
@@ -2848,7 +2849,7 @@ size_t countImpl(alias fun, Slices...)(Slices slices)
     {
         static if (DimensionCount!(Slices[0]) == 1)
         {
-            if(fun(frontOf!slices))
+            if(mixin(`fun(`~ frontOf!(Slices.length) ~ `)`))
                 ret++;
         }
         else
diff --git a/source/mir/interpolate/polynomial.d b/source/mir/interpolate/polynomial.d
@@ -70,7 +70,7 @@ version(mir_test)
 /++
 Constructs barycentric lagrange interpolant.
 +/
-Lagrange!(T, maxDerivative) lagrange(uint maxDerivative = 0, T, X)(scope const X[] x, scope const T[] y)
+Lagrange!(T, maxDerivative) lagrange(uint maxDerivative = 0, T, X)(scope const X[] x, scope const T[] y) @trusted
     if (maxDerivative < 16)
 {
     import mir.ndslice.allocation: rcslice;
diff --git a/source/mir/ndslice/concatenation.d b/source/mir/ndslice/concatenation.d
@@ -286,7 +286,7 @@ struct Concatenation(size_t dim, Slices...)
     }
 
     /// Shape of the concatenation.
-    size_t[N] shape()() const @property
+    size_t[N] shape()() scope const @property
     {
         typeof(return) ret;
         foreach(i; Iota!N)
@@ -295,7 +295,7 @@ struct Concatenation(size_t dim, Slices...)
     }
 
     /// Multidimensional input range primitives
-    bool empty(size_t d = 0)() const @property
+    bool empty(size_t d = 0)() scope const @property
     {
         static if (d == dim)
         {
@@ -311,7 +311,7 @@ struct Concatenation(size_t dim, Slices...)
     }
 
     /// ditto
-    void popFront(size_t d = 0)()
+    void popFront(size_t d = 0)() scope
     {
         static if (d == dim)
         {
diff --git a/source/mir/ndslice/internal.d b/source/mir/ndslice/internal.d
@@ -359,18 +359,18 @@ package(mir) template strideOf(args...)
     }
 }
 
-package(mir) template frontOf(args...)
+package(mir) template frontOf(size_t n)
 {
-    static if (args.length == 0)
-        enum frontOf = args;
-    else
-    {
-        @optmath @property auto ref frontOfMod()()
+    enum frontOf = () {
+        string ret;
+        static foreach (i; 0 .. n)
         {
-            return args[0].front;
+            if (i)
+                ret ~= `, `;
+            ret ~= "slices[" ~ i.stringof ~ `].front`;
         }
-        alias frontOf = AliasSeq!(frontOfMod, frontOf!(args[1..$]));
-    }
+        return ret;
+    } ();
 }
 
 package(mir) template frontOf2(args...)
diff --git a/source/mir/ndslice/slice.d b/source/mir/ndslice/slice.d
@@ -2375,7 +2375,7 @@ public:
     Note:
         Does not allocate neither new slice nor a closure.
     +/
-    auto opUnary(string op)() return scope
+    auto opUnary(string op)()
         if (op == "*" || op == "~" || op == "-" || op == "+")
     {
         import mir.ndslice.topology: map;
diff --git a/source/mir/series.d b/source/mir/series.d
@@ -2188,18 +2188,45 @@ Merges multiple (time) series into one.
 Makes exactly one memory allocation for two series union
 and two memory allocation for three and more series union.
 
-Params:
-    seriesTuple = variadic static array of composed of series, each series must be sorted.
 Returns: sorted GC-allocated series.
 See_also $(LREF Series.opBinary) $(LREF makeUnionSeries)
 */
-auto unionSeries(IndexIterator, Iterator, size_t N, SliceKind kind, size_t C)(Series!(IndexIterator, Iterator, N, kind)[C] seriesTuple...)
-    if (C > 1)
+auto unionSeries(IndexIterator, Iterator, size_t N, SliceKind kind)(
+    Series!(IndexIterator, Iterator, N, kind) a,
+    Series!(IndexIterator, Iterator, N, kind) b,
+    ) @safe
+{
+    import core.lifetime: move;
+    Series!(IndexIterator, Iterator, N, kind)[2] ar = [move(a), move(b)];
+    return unionSeriesImplPrivate!false(move(ar));
+}
+
+/// ditto
+auto unionSeries(IndexIterator, Iterator, size_t N, SliceKind kind)(
+    Series!(IndexIterator, Iterator, N, kind) a,
+    Series!(IndexIterator, Iterator, N, kind) b,
+    Series!(IndexIterator, Iterator, N, kind) c,
+    ) @safe
 {
     import core.lifetime: move;
-    return unionSeriesImplPrivate!false(move(seriesTuple));
+    Series!(IndexIterator, Iterator, N, kind)[3] ar = [move(a), move(b), move(c)];
+    return unionSeriesImplPrivate!false(move(ar));
 }
 
+/// ditto
+auto unionSeries(IndexIterator, Iterator, size_t N, SliceKind kind)(
+    Series!(IndexIterator, Iterator, N, kind) a,
+    Series!(IndexIterator, Iterator, N, kind) b,
+    Series!(IndexIterator, Iterator, N, kind) c,
+    Series!(IndexIterator, Iterator, N, kind) d,
+    ) @safe
+{
+    import core.lifetime: move;
+    Series!(IndexIterator, Iterator, N, kind)[4] ar = [move(a), move(b), move(c), move(d)];
+    return unionSeriesImplPrivate!false(move(ar));
+}
+
+
 ///
 @safe pure nothrow version(mir_test) unittest
 {
@@ -2322,15 +2349,42 @@ auto makeUnionSeries(IndexIterator, Iterator, size_t N, SliceKind kind, size_t C
 /**
 Merges multiple (time) series into one.
 
-Params:
-    seriesTuple = variadic static array of composed of series.
 Returns: sorted manually allocated series.
 See_also $(LREF unionSeries)
 */
-auto rcUnionSeries(IndexIterator, Iterator, size_t N, SliceKind kind, size_t C)(Series!(IndexIterator, Iterator, N, kind)[C] seriesTuple...)
-    if (C > 1)
+auto rcUnionSeries(IndexIterator, Iterator, size_t N, SliceKind kind)(
+    Series!(IndexIterator, Iterator, N, kind) a,
+    Series!(IndexIterator, Iterator, N, kind) b,
+    ) @safe
 {
-    return unionSeriesImplPrivate!true(seriesTuple);
+    import core.lifetime: move;
+    Series!(IndexIterator, Iterator, N, kind)[2] ar = [move(a), move(b)];
+    return unionSeriesImplPrivate!true(move(ar));
+}
+
+///ditto
+auto rcUnionSeries(IndexIterator, Iterator, size_t N, SliceKind kind)(
+    Series!(IndexIterator, Iterator, N, kind) a,
+    Series!(IndexIterator, Iterator, N, kind) b,
+    Series!(IndexIterator, Iterator, N, kind) c,
+    ) @safe
+{
+    import core.lifetime: move;
+    Series!(IndexIterator, Iterator, N, kind)[3] ar = [move(a), move(b), move(c)];
+    return unionSeriesImplPrivate!true(move(ar));
+}
+
+///ditto
+auto rcUnionSeries(IndexIterator, Iterator, size_t N, SliceKind kind)(
+    Series!(IndexIterator, Iterator, N, kind) a,
+    Series!(IndexIterator, Iterator, N, kind) b,
+    Series!(IndexIterator, Iterator, N, kind) c,
+    Series!(IndexIterator, Iterator, N, kind) d,
+    ) @safe
+{
+    import core.lifetime: move;
+    Series!(IndexIterator, Iterator, N, kind)[4] ar = [move(a), move(b), move(c), move(d)];
+    return unionSeriesImplPrivate!true(move(ar));
 }
 
 ///
@@ -2374,9 +2428,9 @@ Params:
 pragma(inline, false)
 auto unionSeriesImpl(I, E,
     IndexIterator, Iterator, size_t N, SliceKind kind, UI, UE)(
-    Series!(IndexIterator, Iterator, N, kind)[] seriesTuple,
+    scope Series!(IndexIterator, Iterator, N, kind)[] seriesTuple,
     Series!(UI*, UE*, N) uninitSeries,
-    )
+    ) @trusted
 {
     import mir.conv: emplaceRef;
     import mir.algorithm.setops: multiwayUnion;
@@ -2403,7 +2457,7 @@ auto unionSeriesImpl(I, E,
     }
 }
 
-private auto unionSeriesImplPrivate(bool rc, IndexIterator, Iterator, size_t N, SliceKind kind, size_t C, Allocator...)(Series!(IndexIterator, Iterator, N, kind)[C] seriesTuple, ref Allocator allocator)
+private auto unionSeriesImplPrivate(bool rc, IndexIterator, Iterator, size_t N, SliceKind kind, size_t C, Allocator...)(Series!(IndexIterator, Iterator, N, kind)[C] seriesTuple, ref Allocator allocator) @safe
     if (C > 1 && Allocator.length <= 1)
 {
     import mir.algorithm.setops: unionLength;
diff --git a/source/mir/stdio.d b/source/mir/stdio.d
@@ -111,7 +111,7 @@ struct File
     /++
     Throws: $(LREF FileException)
     +/
-    void rawWrite(scope const(void)[] data)
+    void rawWrite(scope const(void)[] data) scope
         in (__ctfe || fp !is null)
     {
         if (__ctfe)
@@ -124,7 +124,7 @@ struct File
     /++
     Throws: $(LREF FileException)
     +/
-    void flush()
+    void flush() scope
         in (__ctfe || fp !is null)
     {
         if (__ctfe)
@@ -151,7 +151,7 @@ struct AssumeNothrowFile
     /++
     Throws: $(LREF FileError)
     +/
-    void rawWrite(scope const(void)[] data)
+    void rawWrite(scope const(void)[] data) scope
         in (__ctfe || fp !is null)
     {
         if (__ctfe)
@@ -164,7 +164,7 @@ struct AssumeNothrowFile
     /++
     Throws: $(LREF FileError)
     +/
-    void flush()
+    void flush() scope
         in (__ctfe || fp !is null)
     {
         if (__ctfe)
@@ -179,15 +179,15 @@ struct AssumeNothrowFile
 mixin template FileMembers()
 {
     ///
-    void put(C)(const C data)
+    void put(C)(const C data) scope
         if (is(C == char) || is(C == wchar) | is(C == dchar))
     {
         C[1] array = [data];
         this.rawWrite(array);
     }
 
     ///
-    void put(C)(scope const(C)[] data)
+    void put(C)(scope const(C)[] data) scope
         if (is(C == char) || is(C == wchar) | is(C == dchar))
     {
         this.rawWrite(data);
@@ -218,15 +218,15 @@ mixin template FileMembers()
     }
 
     /// Writes values in a text form
-    void writeln(string separator = "", Args...)(auto ref const Args args)
+    void writeln(string separator = "", Args...)(auto ref const Args args) scope
         if (Args.length > 0)
     {
         write(args);
         this << endl;
     }
 
     /// ditto
-    void write(string separator = "", Args...)(auto ref const Args args)
+    void write(string separator = "", Args...)(auto ref const Args args) scope
         if (Args.length > 0)
     {
         pragma(inline, false);

Original file line number	Diff line number	Diff line change
`@@ -703,9 +703,9 @@ S reduceImpl(alias fun, S, Slices...)(S seed, Slices slices)`
`703`	`703`	`do`
`704`	`704`	`{`
`705`	`705`	`static if (DimensionCount!(Slices[0]) == 1)`
`706`		`- seed = fun(seed, frontOf!slices);`
	`706`	+ mixin(`seed = fun(seed,` ~ frontOf!(Slices.length) ~ `);`);
`707`	`707`	`else`
`708`		`- seed = .reduceImpl!fun(seed, frontOf!slices);`
	`708`	+ mixin(`seed = .reduceImpl!fun(seed,` ~ frontOf!(Slices.length) ~ `);`);
`709`	`709`	`foreach_reverse(ref slice; slices)`
`710`	`710`	`slice.popFront;`
`711`	`711`	`}`
`@@ -960,7 +960,7 @@ void eachImpl(alias fun, Slices...)(Slices slices)`
`960`	`960`	`do`
`961`	`961`	`{`
`962`	`962`	`static if (DimensionCount!(Slices[0]) == 1)`
`963`		`- fun(frontOf!slices);`
	`963`	+ mixin(`fun(`~ frontOf!(Slices.length) ~ `);`);
`964`	`964`	`else`
`965`	`965`	`.eachImpl!fun(frontOf2!slices);`
`966`	`966`	`foreach_reverse(i; Iota!(Slices.length))`
`@@ -988,7 +988,7 @@ void chequerEachImpl(alias fun, Slices...)(Chequer color, Slices slices)`
`988`	`988`	`{`
`989`	`989`	`do`
`990`	`990`	`{`
`991`		`- .chequerEachImpl!fun(color, frontOf!slices);`
	`991`	+ mixin(`.chequerEachImpl!fun(color,` ~ frontOf!(Slices.length) ~ `);`);
`992`	`992`	`color = cast(Chequer)!color;`
`993`	`993`	`foreach_reverse(i; Iota!(Slices.length))`
`994`	`994`	`slices[i].popFront;`
`@@ -1029,7 +1029,7 @@ template eachOnBorder(alias fun)`
`1029`	`1029`	`alias N = DimensionCount!(Slices[0]);`
`1030`	`1030`	`static if (N == 1)`
`1031`	`1031`	`{`
`1032`		`- fun(frontOf!slices);`
	`1032`	+ mixin(`fun(`~ frontOf!(Slices.length) ~ `);`);
`1033`	`1033`	`if (slices[0].length > 1)`
`1034`	`1034`	`fun(backOf!slices);`
`1035`	`1035`	`}`
`@@ -1874,15 +1874,15 @@ bool findImpl(alias fun, size_t N, Slices...)(scope ref size_t[N] backwardIndex,`
`1874`	`1874`	`{`
`1875`	`1875`	`static if (DimensionCount!(Slices[0]) == 1)`
`1876`	`1876`	`{`
`1877`		`- if (fun(frontOf!slices))`
	`1877`	+ if (mixin(`fun(`~ frontOf!(Slices.length) ~ `)`))
`1878`	`1878`	`{`
`1879`	`1879`	`backwardIndex[0] = slices[0].length;`
`1880`	`1880`	`return true;`
`1881`	`1881`	`}`
`1882`	`1882`	`}`
`1883`	`1883`	`else`
`1884`	`1884`	`{`
`1885`		`- if (findImpl!fun(backwardIndex[1 .. $], frontOf!slices))`
	`1885`	+ if (mixin(`findImpl!fun(backwardIndex[1 .. $],` ~ frontOf!(Slices.length) ~ `)`))
`1886`	`1886`	`{`
`1887`	`1887`	`backwardIndex[0] = slices[0].length;`
`1888`	`1888`	`return true;`
`@@ -2018,7 +2018,7 @@ template find(alias pred)`
`2018`	`2018`	`Constraints:`
`2019`	`2019`	`All slices must have the same shape.`
`2020`	`2020`	`+/`
`2021`		`- @optmath Select!(DimensionCount!(Slices[0]) > 1, size_t[DimensionCount!(Slices[0])], size_t) find(Slices...)(auto ref Slices slices)`
	`2021`	`+ @optmath Select!(DimensionCount!(Slices[0]) > 1, size_t[DimensionCount!(Slices[0])], size_t) find(Slices...)(Slices slices)`
`2022`	`2022`	`if (Slices.length && allSatisfy!(hasShape, Slices))`
`2023`	`2023`	`{`
`2024`	`2024`	`static if (Slices.length > 1)`
`@@ -2125,9 +2125,10 @@ version(mir_test) unittest`
`2125`	`2125`	`assert(bi == [1, 1]);`
`2126`	`2126`	`assert(sl.backward(bi) == 5);`
`2127`	`2127`
	`2128`	`+ import mir.test;`
`2128`	`2129`	`// sl was changed`
`2129`		`- assert(sl == [[8, 8, 8],`
`2130`		`- [8, 8, 5]]);`
	`2130`	`+ sl.should == [[8, 8, 8],`
	`2131`	`+ [8, 8, 5]];`
`2131`	`2132`	`}`
`2132`	`2133`
`2133`	`2134`	`@safe pure nothrow`
`@@ -2160,7 +2161,7 @@ size_t anyImpl(alias fun, Slices...)(Slices slices)`
`2160`	`2161`	`{`
`2161`	`2162`	`static if (DimensionCount!(Slices[0]) == 1)`
`2162`	`2163`	`{`
`2163`		`- if (fun(frontOf!slices))`
	`2164`	+ if (mixin(`fun(`~ frontOf!(Slices.length) ~ `)`))
`2164`	`2165`	`return true;`
`2165`	`2166`	`}`
`2166`	`2167`	`else`
`@@ -2320,7 +2321,7 @@ size_t allImpl(alias fun, Slices...)(Slices slices)`
`2320`	`2321`	`{`
`2321`	`2322`	`static if (DimensionCount!(Slices[0]) == 1)`
`2322`	`2323`	`{`
`2323`		`- if (!fun(frontOf!slices))`
	`2324`	+ if (!mixin(`fun(`~ frontOf!(Slices.length) ~ `)`))
`2324`	`2325`	`return false;`
`2325`	`2326`	`}`
`2326`	`2327`	`else`
`@@ -2634,7 +2635,7 @@ template equal(alias pred = "a == b")`
`2634`	`2635`	`}`
`2635`	`2636`	`if (empty)`
`2636`	`2637`	`return true;`
`2637`		`- if (!pred(frontOf!slices))`
	`2638`	+ if (!mixin(`pred(`~ frontOf!(Slices.length) ~ `)`))
`2638`	`2639`	`goto False;`
`2639`	`2640`	`foreach (ref slice; slices)`
`2640`	`2641`	`slice.popFront;`
`@@ -2848,7 +2849,7 @@ size_t countImpl(alias fun, Slices...)(Slices slices)`
`2848`	`2849`	`{`
`2849`	`2850`	`static if (DimensionCount!(Slices[0]) == 1)`
`2850`	`2851`	`{`
`2851`		`- if(fun(frontOf!slices))`
	`2852`	+ if(mixin(`fun(`~ frontOf!(Slices.length) ~ `)`))
`2852`	`2853`	`ret++;`
`2853`	`2854`	`}`
`2854`	`2855`	`else`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ version(mir_test)`
`70`	`70`	`/++`
`71`	`71`	`Constructs barycentric lagrange interpolant.`
`72`	`72`	`+/`
`73`		`-Lagrange!(T, maxDerivative) lagrange(uint maxDerivative = 0, T, X)(scope const X[] x, scope const T[] y)`
	`73`	`+Lagrange!(T, maxDerivative) lagrange(uint maxDerivative = 0, T, X)(scope const X[] x, scope const T[] y) @trusted`
`74`	`74`	`if (maxDerivative < 16)`
`75`	`75`	`{`
`76`	`76`	`import mir.ndslice.allocation: rcslice;`
Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,7 @@ struct Concatenation(size_t dim, Slices...)`
`286`	`286`	`}`
`287`	`287`
`288`	`288`	`/// Shape of the concatenation.`
`289`		`- size_t[N] shape()() const @property`
	`289`	`+ size_t[N] shape()() scope const @property`
`290`	`290`	`{`
`291`	`291`	`typeof(return) ret;`
`292`	`292`	`foreach(i; Iota!N)`
`@@ -295,7 +295,7 @@ struct Concatenation(size_t dim, Slices...)`
`295`	`295`	`}`
`296`	`296`
`297`	`297`	`/// Multidimensional input range primitives`
`298`		`- bool empty(size_t d = 0)() const @property`
	`298`	`+ bool empty(size_t d = 0)() scope const @property`
`299`	`299`	`{`
`300`	`300`	`static if (d == dim)`
`301`	`301`	`{`
`@@ -311,7 +311,7 @@ struct Concatenation(size_t dim, Slices...)`
`311`	`311`	`}`
`312`	`312`
`313`	`313`	`/// ditto`
`314`		`- void popFront(size_t d = 0)()`
	`314`	`+ void popFront(size_t d = 0)() scope`
`315`	`315`	`{`
`316`	`316`	`static if (d == dim)`
`317`	`317`	`{`
Original file line number	Diff line number	Diff line change
`@@ -359,18 +359,18 @@ package(mir) template strideOf(args...)`
`359`	`359`	`}`
`360`	`360`	`}`
`361`	`361`
`362`		`-package(mir) template frontOf(args...)`
	`362`	`+package(mir) template frontOf(size_t n)`
`363`	`363`	`{`
`364`		`- static if (args.length == 0)`
`365`		`- enum frontOf = args;`
`366`		`- else`
`367`		`- {`
`368`		`- @optmath @property auto ref frontOfMod()()`
	`364`	`+ enum frontOf = () {`
	`365`	`+ string ret;`
	`366`	`+ static foreach (i; 0 .. n)`
`369`	`367`	`{`
`370`		`- return args[0].front;`
	`368`	`+ if (i)`
	`369`	+ ret ~= `, `;
	`370`	+ ret ~= "slices[" ~ i.stringof ~ `].front`;
`371`	`371`	`}`
`372`		`- alias frontOf = AliasSeq!(frontOfMod, frontOf!(args[1..$]));`
`373`		`- }`
	`372`	`+ return ret;`
	`373`	`+ } ();`
`374`	`374`	`}`
`375`	`375`
`376`	`376`	`package(mir) template frontOf2(args...)`
Original file line number	Diff line number	Diff line change
`@@ -2375,7 +2375,7 @@ public:`
`2375`	`2375`	`Note:`
`2376`	`2376`	`Does not allocate neither new slice nor a closure.`
`2377`	`2377`	`+/`
`2378`		`- auto opUnary(string op)() return scope`
	`2378`	`+ auto opUnary(string op)()`
`2379`	`2379`	`if (op == "*" \|\| op == "~" \|\| op == "-" \|\| op == "+")`
`2380`	`2380`	`{`
`2381`	`2381`	`import mir.ndslice.topology: map;`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ struct File`
`111`	`111`	`/++`
`112`	`112`	`Throws: $(LREF FileException)`
`113`	`113`	`+/`
`114`		`- void rawWrite(scope const(void)[] data)`
	`114`	`+ void rawWrite(scope const(void)[] data) scope`
`115`	`115`	`in (__ctfe \|\| fp !is null)`
`116`	`116`	`{`
`117`	`117`	`if (__ctfe)`
`@@ -124,7 +124,7 @@ struct File`
`124`	`124`	`/++`
`125`	`125`	`Throws: $(LREF FileException)`
`126`	`126`	`+/`
`127`		`- void flush()`
	`127`	`+ void flush() scope`
`128`	`128`	`in (__ctfe \|\| fp !is null)`
`129`	`129`	`{`
`130`	`130`	`if (__ctfe)`
`@@ -151,7 +151,7 @@ struct AssumeNothrowFile`
`151`	`151`	`/++`
`152`	`152`	`Throws: $(LREF FileError)`
`153`	`153`	`+/`
`154`		`- void rawWrite(scope const(void)[] data)`
	`154`	`+ void rawWrite(scope const(void)[] data) scope`
`155`	`155`	`in (__ctfe \|\| fp !is null)`
`156`	`156`	`{`
`157`	`157`	`if (__ctfe)`
`@@ -164,7 +164,7 @@ struct AssumeNothrowFile`
`164`	`164`	`/++`
`165`	`165`	`Throws: $(LREF FileError)`
`166`	`166`	`+/`
`167`		`- void flush()`
	`167`	`+ void flush() scope`
`168`	`168`	`in (__ctfe \|\| fp !is null)`
`169`	`169`	`{`
`170`	`170`	`if (__ctfe)`
`@@ -179,15 +179,15 @@ struct AssumeNothrowFile`
`179`	`179`	`mixin template FileMembers()`
`180`	`180`	`{`
`181`	`181`	`///`
`182`		`- void put(C)(const C data)`
	`182`	`+ void put(C)(const C data) scope`
`183`	`183`	`if (is(C == char) \|\| is(C == wchar) \| is(C == dchar))`
`184`	`184`	`{`
`185`	`185`	`C[1] array = [data];`
`186`	`186`	`this.rawWrite(array);`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`///`
`190`		`- void put(C)(scope const(C)[] data)`
	`190`	`+ void put(C)(scope const(C)[] data) scope`
`191`	`191`	`if (is(C == char) \|\| is(C == wchar) \| is(C == dchar))`
`192`	`192`	`{`
`193`	`193`	`this.rawWrite(data);`
`@@ -218,15 +218,15 @@ mixin template FileMembers()`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`/// Writes values in a text form`
`221`		`- void writeln(string separator = "", Args...)(auto ref const Args args)`
	`221`	`+ void writeln(string separator = "", Args...)(auto ref const Args args) scope`
`222`	`222`	`if (Args.length > 0)`
`223`	`223`	`{`
`224`	`224`	`write(args);`
`225`	`225`	`this << endl;`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`/// ditto`
`229`		`- void write(string separator = "", Args...)(auto ref const Args args)`
	`229`	`+ void write(string separator = "", Args...)(auto ref const Args args) scope`
`230`	`230`	`if (Args.length > 0)`
`231`	`231`	`{`
`232`	`232`	`pragma(inline, false);`