@safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range, std.stdio;    import std.typecons : tuple;     ulong counter = 0;    double fun(int x)    {        ++counter;        // http://en.wikipedia.org/wiki/Quartic_function        return ( (x + 4.0) * (x + 1.0) * (x - 1.0) * (x - 3.0) ) / 14.0 + 0.5;    }    // Without cache, with array (greedy)    auto result1 = iota(-4, 5).map!(a =>tuple(a, fun(a)))()                             .filter!(a => a[1] < 0)()                             .map!(a => a[0])()                             .array();     // the values of x that have a negative y are:    assert(equal(result1, [-3, -2, 2]));     // Check how many times fun was evaluated.    // As many times as the number of items in both source and result.    assert(counter == iota(-4, 5).length + result1.length);     counter = 0;    // Without array, with cache (lazy)    auto result2 = iota(-4, 5).map!(a =>tuple(a, fun(a)))()                             .cache()                             .filter!(a => a[1] < 0)()                             .map!(a => a[0])();     // the values of x that have a negative y are:    assert(equal(result2, [-3, -2, 2]));     // Check how many times fun was evaluated.    // Only as many times as the number of items in source.    assert(counter == iota(-4, 5).length);} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range;    int i = 0;     auto r = iota(0, 4).tee!((a){i = a;}, No.pipeOnPop);    auto r1 = r.take(3).cache();    auto r2 = r.cache().take(3);     assert(equal(r1, [0, 1, 2]));    assert(i == 2); //The last "seen" element was 2. The data in cache has been cleared.     assert(equal(r2, [0, 1, 2]));    assert(i == 3); //cache has accessed 3. It is still stored internally by cache.} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range, std.stdio;    import std.typecons : tuple;     ulong counter = 0;    double fun(int x)    {        ++counter;        // http://en.wikipedia.org/wiki/Quartic_function        return ( (x + 4.0) * (x + 1.0) * (x - 1.0) * (x - 3.0) ) / 14.0 + 0.5;    }    // With lazyCache, front won't be evaluated until requested    counter = 0;    auto result = iota(-4, 5).map!(a => tuple(a, fun(a)))()                            .lazyCache();    // At this point, no elements have been evaluated yet    assert(counter == 0);    // Now access the first element    auto firstElement = result.front;    // Only now the first element is evaluated    assert(counter == 1);    // Process the result lazily    auto filtered = result.filter!(a => a[1] < 0)()                         .map!(a => a[0])();    // Values are calculated as we iterate    assert(equal(filtered, [-3, -2, 2]));    // Only elements we actually accessed were evaluated    assert(counter == iota(-4, 5).length);} @safe @nogc unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range : chain, only;    auto squares =        chain(only(1, 2, 3, 4), only(5, 6)).map!(a => a * a);    assert(equal(squares, only(1, 4, 9, 16, 25, 36)));} @safe unittest{    import std.algorithm.iteration;     auto sums = [2, 4, 6, 8];    auto products = [1, 4, 9, 16];     size_t i = 0;    foreach (result; [ 1, 2, 3, 4 ].map!("a + a", "a * a"))    {        assert(result[0] == sums[i]);        assert(result[1] == products[i]);        ++i;    }} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.conv : to;     alias stringize = map!(to!string);    assert(equal(stringize([ 1, 2, 3, 4 ]), [ "1", "2", "3", "4" ]));} @safe unittest{    import std.algorithm.iteration;     import std.range : iota;    import std.typecons : No;     int[] arr;    iota(5).each!(n => arr ~= n);    assert(arr == [0, 1, 2, 3, 4]);     // stop iterating early    iota(5).each!((n) { arr ~= n; return No.each; });    assert(arr == [0, 1, 2, 3, 4, 0]);     // If the range supports it, the value can be mutated in place    arr.each!((ref n) => n++);    assert(arr == [1, 2, 3, 4, 5, 1]);     arr.each!"a++";    assert(arr == [2, 3, 4, 5, 6, 2]);     auto m = arr.map!(n => n);    // by-ref lambdas are not allowed for non-ref ranges    static assert(!__traits(compiles, m.each!((ref n) => n++)));     // The default predicate consumes the range    (&m).each();    assert(m.empty);} @safe unittest{    import std.algorithm.iteration;     auto arr = new size_t[4];     arr.each!"a=i"();    assert(arr == [0, 1, 2, 3]);     arr.each!((i, ref e) => e = i * 2);    assert(arr == [0, 2, 4, 6]);} @system unittest{    import std.algorithm.iteration;     static class S    {        int x;        int opApply(scope int delegate(ref int _x) dg) { return dg(x); }    }     auto s = new S;    s.each!"a++";    assert(s.x == 1);} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.math.operations : isClose;    import std.range;     int[] arr = [ 1, 2, 3, 4, 5 ];     // Filter below 3    auto small = filter!(a => a < 3)(arr);    assert(equal(small, [ 1, 2 ]));     // Filter again, but with Uniform Function Call Syntax (UFCS)    auto sum = arr.filter!(a => a < 3);    assert(equal(sum, [ 1, 2 ]));     // In combination with chain() to span multiple ranges    int[] a = [ 3, -2, 400 ];    int[] b = [ 100, -101, 102 ];    auto r = chain(a, b).filter!(a => a > 0);    assert(equal(r, [ 3, 400, 100, 102 ]));     // Mixing convertible types is fair game, too    double[] c = [ 2.5, 3.0 ];    auto r1 = chain(c, a, b).filter!(a => cast(int) a != a);    assert(isClose(r1, [ 2.5 ]));} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range;     int[] arr = [ 1, 2, 3, 4, 5 ];    auto small = filterBidirectional!("a < 3")(arr);    static assert(isBidirectionalRange!(typeof(small)));    assert(small.back == 2);    assert(equal(small, [ 1, 2 ]));    assert(equal(retro(small), [ 2, 1 ]));    // In combination with chain() to span multiple ranges    int[] a = [ 3, -2, 400 ];    int[] b = [ 100, -101, 102 ];    auto r = filterBidirectional!("a > 0")(chain(a, b));    assert(r.back == 102);} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.typecons : tuple, Tuple;     int[] arr = [ 1, 2, 2, 2, 2, 3, 4, 4, 4, 5 ];    assert(equal(group(arr), [ tuple(1, 1u), tuple(2, 4u), tuple(3, 1u),        tuple(4, 3u), tuple(5, 1u) ][]));} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.sorting : sort;    import std.array : assocArray;     uint[string] result;    auto range = ["a", "b", "a", "c", "b", "c", "c", "d", "e"];    result = range.sort!((a, b) => a < b)        .group        .assocArray;     assert(result == ["a": 2U, "b": 2U, "c": 3U, "d": 1U, "e": 1U]);} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;     // Grouping by particular attribute of each element:    auto data = [        [1, 1],        [1, 2],        [2, 2],        [2, 3]    ];     auto r1 = data.chunkBy!((a,b) => a[0] == b[0]);    assert(r1.equal!equal([        [[1, 1], [1, 2]],        [[2, 2], [2, 3]]    ]));     auto r2 = data.chunkBy!((a,b) => a[1] == b[1]);    assert(r2.equal!equal([        [[1, 1]],        [[1, 2], [2, 2]],        [[2, 3]]    ]));} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range.primitives;    import std.typecons : tuple;     // Grouping by particular attribute of each element:    auto range =    [        [1, 1],        [1, 1],        [1, 2],        [2, 2],        [2, 3],        [2, 3],        [3, 3]    ];     auto byX = chunkBy!(a => a[0])(range);    auto expected1 =    [        tuple(1, [[1, 1], [1, 1], [1, 2]]),        tuple(2, [[2, 2], [2, 3], [2, 3]]),        tuple(3, [[3, 3]])    ];    foreach (e; byX)    {        assert(!expected1.empty);        assert(e[0] == expected1.front[0]);        assert(e[1].equal(expected1.front[1]));        expected1.popFront();    }     auto byY = chunkBy!(a => a[1])(range);    auto expected2 =    [        tuple(1, [[1, 1], [1, 1]]),        tuple(2, [[1, 2], [2, 2]]),        tuple(3, [[2, 3], [2, 3], [3, 3]])    ];    foreach (e; byY)    {        assert(!expected2.empty);        assert(e[0] == expected2.front[0]);        assert(e[1].equal(expected2.front[1]));        expected2.popFront();    }} nothrow pure @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range : dropExactly;    auto source = [4, 3, 2, 11, 0, -3, -3, 5, 3, 0];     auto result1 = source.splitWhen!((a,b) => a <= b);    assert(result1.save.equal!equal([        [4, 3, 2],        [11, 0, -3],        [-3],        [5, 3, 0]    ]));     //splitWhen, like chunkBy, is currently a reference range (this may change    //in future). Remember to call `save` when appropriate.    auto result2 = result1.dropExactly(2);    assert(result1.save.equal!equal([        [-3],        [5, 3, 0]    ]));} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.conv : text;     assert(["abc", "def"].joiner.equal("abcdef"));    assert(["Mary", "has", "a", "little", "lamb"]        .joiner("...")        .equal("Mary...has...a...little...lamb"));    assert(["", "abc"].joiner("xyz").equal("xyzabc"));    assert([""].joiner("xyz").equal(""));    assert(["", ""].joiner("xyz").equal("xyz"));} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range : repeat;     assert([""].joiner.equal(""));    assert(["", ""].joiner.equal(""));    assert(["", "abc"].joiner.equal("abc"));    assert(["abc", ""].joiner.equal("abc"));    assert(["abc", "def"].joiner.equal("abcdef"));    assert(["Mary", "has", "a", "little", "lamb"].joiner.equal("Maryhasalittlelamb"));    assert("abc".repeat(3).joiner.equal("abcabcabc"));} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    auto a = [ [1, 2, 3], [42, 43] ];    auto j = joiner(a);    j.front = 44;    assert(a == [ [44, 2, 3], [42, 43] ]);    assert(equal(j, [44, 2, 3, 42, 43]));} @safe pure unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range : chain, cycle, iota, only, retro, take, zip;    import std.format : format;     static immutable number = "12345678";    static immutable delimiter = ",";    auto formatted = number.retro        .zip(3.iota.cycle.take(number.length))        .map!(z => chain(z[0].only, z[1] == 2 ? delimiter : null))        .joiner        .retro;    static immutable expected = "12,345,678";    assert(formatted.equal(expected));} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : equal;    import std.range : retro;     auto a = [[1, 2, 3], [4, 5]];    auto j = a.joiner;    j.back = 44;    assert(a == [[1, 2, 3], [4, 44]]);    assert(equal(j.retro, [44, 4, 3, 2, 1]));} @safe unittest{    import std.algorithm.iteration;     import std.algorithm.comparison : max, min;    import std.math.operations : isClose;    import std.range;     int[] arr = [ 1, 2, 3, 4, 5 ];    // Sum all elements    auto sum = reduce!((a,b) => a + b)(0, arr);    assert(sum == 15);     // Sum again, using a string predicate with "a" and "b"    sum = reduce!"a + b"(0, arr);    assert(sum == 15);     // Compute the maximum of all elements    auto largest = reduce!(max)(arr);    assert(largest == 5);     // Max again, but with Uniform Function Call Syntax (UFCS)    largest = arr.reduce!(max);    assert(largest == 5);     // Compute the number of odd elements    auto odds = reduce!((a,b) => a + (b & 1))(0, arr);    assert(odds == 3);     // Compute the sum of squares    auto ssquares = reduce!((a,b) => a + b * b)(0, arr);    assert(ssquares == 55);     // Chain multiple ranges into seed    int[] a = [ 3, 4 ];    int[] b = [ 100 ];    auto r = reduce!("a + b")(chain(a, b));    assert(r == 107);     // Mixing convertible types is fair game, too    double[] c = [ 2.5, 3.0 ];    auto r1 = reduce!("a + b")(chain(a, b, c));    assert(isClose(r1, 112.5));     // To minimize nesting of parentheses, Uniform Function Call Syntax can be used    auto r2 = chain(a, b, c).reduce!("a + b");    assert(isClose(r2, 112.5));}

Lines 1–500 of 1038. Load more