Lines Matching refs:equal
363 import std.algorithm.comparison : equal;
366 assert(equal(retro(a[]), b[]));
373 import std.algorithm.comparison : equal;
384 assert(equal(r, witness)); in test()
395 assert(equal(r, [3, 2, 1]));
461 import std.algorithm.comparison : equal;
465 assert(equal(r, excepted[]));
688 import std.algorithm.comparison : equal;
691 assert(equal(stride(a, 3), [ 1, 4, 7, 10 ][]));
697 import std.algorithm.comparison : equal;
701 assert(equal(testArr[].stride(2), result));
724 import std.algorithm.comparison : equal;
731 assert(equal(stride(input, n), witness)); in test()
743 assert(equal(s1[1 .. 4], [2, 3, 4]));
745 assert(equal(s1[1 .. 5], [2, 3, 4, 5]));
753 assert(equal(s2[0 .. 2], [1,3]));
755 assert(equal(s2[1 .. 5], [3, 5, 7, 9]));
765 assert(equal(col, [1, 1, 1]));
766 assert(equal(retro(col), [1, 1, 1]));
789 assert(equal(myStride, [1, 5, 9]));
860 import std.algorithm.comparison : equal;
864 assert(equal(s, [1L, 4L, 7L]));
1211 import std.algorithm.comparison : equal;
1219 assert(equal(s, [1, 2, 3, 4, 5, 6, 7][]));
1228 import std.algorithm.comparison : equal;
1238 assert(s.equal([1, 2, 3, 4, 5, 6, 7, 8, 9]));
1239 assert(arr1.equal([1, 2, 3]));
1240 assert(arr2.equal([4, 5, 6]));
1241 assert(arr3.equal([7, 8, 9]));
1278 import std.algorithm.comparison : equal;
1295 assert(equal(s, witness));
1301 assert(equal(chain(arr1), witness));
1318 assert(equal(chain(iota(0, 3), iota(0, 3)), [0, 1, 2, 0, 1, 2]));
1388 import std.algorithm.comparison : equal;
1391 assert(equal(r.save, "foobar"));
1392 assert(equal(r, "foobar"));
1422 import std.algorithm.comparison : equal;
1444 assert(result.equal(only(1, 2, 4)));
1447 assert(result.equal(only(6, 7, 8, 9)));
1697 import std.algorithm.comparison : equal;
1700 assert(equal(r.save, "foo"));
1701 assert(equal(r, "foo"));
1855 import std.algorithm.comparison : equal;
1870 assert(equal(t, only(1, 2, 3, 4)));
1876 assert(equal(s, only(8, 6)));
1882 assert(equal(s, only(8, 9)));
1887 assert(equal(s, only(2, 3)));
1895 assert(equal(s, only(1, 2, 5)));
1897 assert(equal(s, only(1, 2, 3)));
1917 assert(s[0 .. 3].equal(only(8, 9, 8)));
2084 import std.algorithm.comparison : equal;
2089 assert(equal(r, [ 1, 10, 2, 20, 3, 30, 40 ]));
2098 import std.algorithm.comparison : equal;
2114 assert(interleave([1, 2, 3], 0).equal([1, 0, 2, 0, 3]));
2119 import std.algorithm.comparison : equal;
2122 assert(equal(r.save, "fboaor"));
2123 assert(equal(r.save, "fboaor"));
2159 import std.algorithm.comparison : equal;
2161 assert(equal(radial(a), [ 3, 4, 2, 5, 1 ]));
2163 assert(equal(radial(a), [ 2, 3, 1, 4 ]));
2168 assert(equal(radial(a, 1), [ 1, 2, 0, 3, 4, 5 ]));
2172 assert(equal(radial(a, 4), [ 4, 5, 3, 2, 1, 0 ]));
2177 import std.algorithm.comparison : equal;
2184 enforce(equal(radial(input), witness),
2196 assert(equal(radial(a, 1), [ 2, 3, 1, 4, 5 ]));
2197 assert(equal(radial(a, 0), [ 1, 2, 3, 4, 5 ])); // only right subrange
2198 assert(equal(radial(a, a.length), [ 5, 4, 3, 2, 1 ])); // only left subrange
2211 assert(equal(radial(dummy, 4), [5, 6, 4, 7, 3, 8, 2, 9, 1, 10]));
2219 import std.algorithm.comparison : equal;
2223 assert(equal(r, [3L, 4L, 2L, 5L, 1L]));
2467 import std.algorithm.comparison : equal;
2473 assert(equal(s, [ 1, 2, 3, 4, 5 ][]));
2483 import std.algorithm.comparison : equal;
2488 assert(equal(t, [ 1, 2, 3 ]));
2493 import std.algorithm.comparison : equal;
2500 assert(equal(s, [ 1, 2, 3, 4, 5 ][]));
2501 assert(equal(retro(s), [ 5, 4, 3, 2, 1 ][]));
2512 assert(assumeWontThrow(equal(takeMyStr, "This is")));
2515 assert(assumeWontThrow(equal(takeMyStrAgain, "This")));
2518 assert(assumeWontThrow(equal(takeMyStrAgain, "This is")));
2547 assert(equal(t, [1,2,3,4,5]));
2560 import std.algorithm.comparison : equal;
2564 .equal(iota(start, stop)));
2612 import std.algorithm.comparison : equal;
2615 assert(r.take(2).equal(repeat(1, 2)));
2712 import std.algorithm.comparison : equal;
2717 assert(equal(b, [1, 2, 3]));
2726 import std.algorithm.comparison : equal;
2731 assert(equal(b, [1, 2, 3]));
2733 assert(equal(c, [1, 2]));
2739 assert(equal(e, [3, 4, 5]));
2744 assert(equal(takeExactly(e, 3), [3, 4, 5]));
2749 import std.algorithm.comparison : equal;
2794 assert(equal(t, [1, 2, 3, 4]));
2803 assert(equal(t, [9, 2, 3, 4]));
2811 import std.algorithm.comparison : equal;
2817 assert(equal(t, [1, 2, 3, 4, 5]));
2818 assert(equal(t, te));
2825 import std.algorithm.comparison : equal;
2831 assert(r.take(6).takeExactly(2).equal([1, 2]));
2832 assert(r.takeExactly(6).takeExactly(2).equal([1, 2]));
2833 assert(r.takeExactly(6).take(2).equal([1, 2]));
3249 + of `range` is less than or equal to `_n`, `range` is returned
3307 import std.algorithm.comparison : equal;
3315 .equal("two\nthree")
3322 import std.algorithm.comparison : equal;
3333 assert(R.init.tail(5).equal(cheatsheet));
3334 static assert(R.init.tail(5).equal(cheatsheet));
3337 assert(R.init.tail(10).equal(R.init));
3338 assert(R.init.tail(11).equal(R.init));
3391 import std.algorithm.comparison : equal;
3396 assert("hello world".take(6).drop(3).equal("lo "));
3410 import std.algorithm.comparison : equal;
3415 assert("hello world".drop(4).dropBack(4).equal("o w"));
3420 import std.algorithm.comparison : equal;
3426 assert(a[].equal(a[].take(2)));
3431 import std.algorithm.comparison : equal;
3435 assert(equal(drop(filter!"true"([0, 2, 1, 5, 0, 3]), 3), [5, 0, 3]));
3440 import std.algorithm.comparison : equal;
3446 assert(a[].equal(iota(0, 7)));
3490 import std.algorithm.comparison : equal;
3502 assert(bd.dropExactly(2).equal([3]));
3503 assert(bd.dropBackExactly(2).equal([1]));
3533 import std.algorithm.comparison : equal;
3538 assert(dl[].dropOne().dropBackOne().equal([1, 2, 3]));
3550 assert(bd.dropOne().equal([2, 3]));
3551 assert(bd.dropBackOne().equal([1, 2]));
3632 import std.algorithm.comparison : equal;
3634 assert(5.repeat().take(4).equal([5, 5, 5, 5]));
3639 import std.algorithm.comparison : equal;
3650 assert(r.take(4).equal([ 5, 5, 5, 5 ]));
3651 assert(r[0 .. 4].equal([ 5, 5, 5, 5 ]));
3667 import std.algorithm.comparison : equal;
3669 assert(5.repeat(4).equal([5, 5, 5, 5]));
3682 import std.algorithm.comparison : equal;
3687 assert(equal(cartesianProduct(A,B),
3731 import std.algorithm.comparison : equal;
3736 assert(equal(powersOfTwo, iota(1, 11).map!"2^^a"()));
3742 import std.algorithm.comparison : equal;
3751 assert(equal(generate(infiniteIota(1, 4)).take(10), [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]));
3815 import std.algorithm.comparison : equal;
3822 assert(equal(generate!StaticOpCall().take(10), repeat(5).take(10)));
3827 import std.algorithm.comparison : equal;
3835 assert(equal(generate(op).take(10), repeat(5).take(10)));
3854 import std.algorithm.comparison : equal;
3855 assert(equal(arr[], iota(12, 32, 2)));
4157 import std.algorithm.comparison : equal;
4164 assert(cycle([1, 2]).take(5).equal([ 1, 2, 1, 2, 1 ]));
4184 import std.algorithm.comparison : equal;
4205 assert(equal(t, [1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10]));
4233 assert(equal(slice, [6, 7, 8, 9, 10, 1, 2, 3, 4, 5]));
4237 assert(equal(take(infSlice, 5), [8, 9, 10, 1, 2]));
4246 import std.algorithm.comparison : equal;
4252 assert(equal(take(cycle(a), 5), [ 1, 2, 3, 1, 2 ][]));
4288 import std.algorithm.comparison : equal;
4292 assert(equal(cleD[5 .. 10], arr[]));
4302 assert(equal(cleD[5 .. 10], arr[]));
4308 import std.algorithm.comparison : equal;
4312 assert(equal(cleS[5 .. 10], arr[]));
4322 assert(equal(cleS[5 .. 10], arr[]));
4328 import std.algorithm.comparison : equal;
4333 assert(equal(cleS[5 .. 10], 0.repeat(5)));
4340 import std.algorithm.comparison : equal;
4344 assert(equal(cycle(a).take(10), [0, 1, 2, 0, 1, 2, 0, 1, 2, 0]));
4364 import std.algorithm.comparison : equal;
4367 assert(equal(r.save, "foof"));
4368 assert(equal(r.save, "foof"));
4807 import std.algorithm.comparison : equal;
4813 assert(part1.equal(only(1, 3)));
4880 import std.algorithm.comparison : equal;
4889 assert(shortest.equal([
4896 assert(longest.equal([
5205 import std.algorithm.comparison : equal;
5262 assert(equal(map!"a[0]"(zShortest), [1, 2]));
5263 assert(equal(map!"a[1]"(zShortest), [1, 2]));
5314 assert(equal(map!"a[0]"(r), [1,2,3,4,5,6,7,8,9,10]));
5315 assert(equal(map!"a[1]"(r), [1,2,3,4,5,6,7,8,9,10]));
5351 import std.algorithm.comparison : equal;
5357 assert(equal(z, [tuple(1L,4)]));
5361 assert(equal(z2, [tuple(7, 0L)]));
5951 import std.algorithm.comparison : equal;
5956 assert(fib.take(10).equal([1, 1, 2, 3, 5, 8, 13, 21, 34, 55]));
5960 assert(take(fac, 10).equal([
5970 assert(take(tri, 10).equal([0, 1, 3, 6, 10, 15, 21, 28, 36, 45]));
5987 import std.algorithm.comparison : equal;
5993 assert(equal(take(fib, 10), witness));
5996 assert( equal(take(fact, 10), [1, 1, 2, 2*3, 2*3*4, 2*3*4*5, 2*3*4*5*6,
6003 assert(equal(take(r, 5), witness));
6157 import std.algorithm.comparison : equal;
6166 assert(equal(odds[0 .. 5], only(1, 3, 5, 7, 9)));
6167 assert(equal(odds[3 .. 7], only(7, 9, 11, 13)));
6171 assert(equal(odds_less5[0 .. 3], only(11, 13, 15)));
6172 assert(equal(odds_less5[0 .. 10], odds[5 .. 15]));
6176 assert(equal(odds.take(3), only(21, 23, 25)));
6545 import std.algorithm.comparison : equal;
6549 assert(equal(r, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
6550 assert(equal(r, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
6556 assert(equal(r, [0, 3, 6, 9]));
6606 import std.algorithm.comparison : equal;
6616 assert(equal(r, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9][]));
6619 assert(equal(rSlice, [2, 3, 4, 5, 6, 7]));
6630 assert(equal(rSlice, [0, 1, 2, 3]));
6635 assert(equal(rr, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9][]));
6638 assert(equal(r, [0, -1, -2, -3, -4, -5, -6, -7, -8, -9][]));
6640 assert(equal(rSlice, [-3, -4, -5, -6, -7, -8]));
6643 assert(equal(r, [0, -3][]));
6645 assert(equal(rSlice, [-3]));
6648 assert(equal(r, [0, -3, -6][]));
6652 assert(equal(rSlice, [-3, -6]));
6660 assert(equal(r, [0, 3, 6, 9][]));
6663 assert(equal(rSlice, [3, 6]));
6715 assert(equal(iota_of_longs_with_steps, [50L, 60L, 70L, 80L, 90L, 100L]));
6865 import std.algorithm.comparison : equal;
6886 assert(i1.equal([1, 2, 3]));
6890 assert(i2.equal([3, 4, 0, 1 ]));
6922 import std.algorithm.comparison : equal;
6928 assert(r1.equal([1, 3]));
6934 assert(r2.equal([1, 3]));
7160 import std.algorithm.comparison : equal;
7165 assert(equal(ror, [ 1, 3 ][]));
7170 import std.algorithm.comparison : equal;
7192 assert(equal(ft, [1, 2, 3, 4]));
7195 assert(equal(ft[0 .. 2], [1, 2]));
7196 assert(equal(ft[1 .. 3], [2, 3]));
7238 import std.algorithm.comparison : equal;
7243 assert(equal(ft, [0, 4]));
7490 import std.algorithm.comparison : equal;
7495 assert(equal(ror, [ 2, 4 ]));
7501 import std.algorithm.comparison : equal;
7505 assert(equal!equal(z, [[1, 4], [2, 5], [3, 6]]));
7649 import std.algorithm.comparison : equal;
7652 assert(r.transposed.equal!equal([
7662 import std.algorithm.comparison : equal;
7670 assert(y.front.equal([1,4]));
7671 assert(y[0].equal([1,4]));
7673 assert(y[1].equal([2,5]));
7677 assert(yy.front.equal([1,4]));
7678 assert(yy[0].equal([1,4]));
7680 assert(yy[1].equal([2,5]));
7684 assert(z.front.equal([1,4]));
7685 assert(z[0].equal([1,4]));
7718 import std.algorithm.comparison : equal;
7724 assert(equal!"a.equal(b)"(xp, [
7750 import std.algorithm.comparison : equal;
7758 assert(equal!"a.equal(b)"(t1, [[123]]));
7971 import std.algorithm.comparison : equal;
7975 assert(equal(ind, [5, 4, 2, 3, 1, 5]));
7976 assert(equal(retro(ind), [5, 1, 3, 2, 4, 5]));
8292 import std.algorithm.comparison : equal;
8301 assert(equal(retro(array(chunks)), array(retro(chunks))));
8307 import std.algorithm.comparison : equal;
8317 assert(chunked.front.equal([1, 2]));
8320 assert(chunked.front.equal([3, 4]));
8325 import std.algorithm.comparison : equal;
8330 assert(r.equal!equal([
8339 assert(r2.equal!equal([
8346 assert(r3.front.equal([1, 2]));
8350 assert(r3.front.equal([5]));
8370 import std.algorithm.comparison : equal;
8383 assert(chunks1[0 .. 1].equal([[0, 0]]));
8384 assert(chunks1[0 .. 2].equal([[0, 0], [1, 1]]));
8385 assert(chunks1[4 .. 5].equal([[4]]));
8386 assert(chunks2[4 .. 5].equal([[4, 4]]));
8388 assert(chunks1[0 .. 0].equal((int[][]).init));
8389 assert(chunks1[5 .. 5].equal((int[][]).init));
8390 assert(chunks2[5 .. 5].equal((int[][]).init));
8393 assert(chunks1[$ .. $].equal((int[][]).init)); //Quick
8394 assert(chunks2[$ .. $].equal((int[][]).init)); //Quick
8395 assert(chunks1[$ - 1 .. $].equal([[4]])); //Semiquick
8396 assert(chunks2[$ - 1 .. $].equal([[4, 4]])); //Semiquick
8397 assert(chunks1[$ .. 5].equal((int[][]).init)); //Semiquick
8398 assert(chunks2[$ .. 5].equal((int[][]).init)); //Semiquick
8400 assert(chunks1[$ / 2 .. $ - 1].equal([[2, 2], [3, 3]])); //Slow
8405 import std.algorithm.comparison : equal;
8410 assert(equal!"equal(a, b)"(r, [[1, 2], [3, 4], [5]]));
8414 assert(equal!`equal(a, b)`(fibsByPairs.take(2), [[ 1, 1], [ 2, 3]]));
8419 assert(equal!`equal(a, b)`(oddsByPairs.take(2), [[ 1, 3], [ 5, 7]]));
8423 assert(equal!`equal(a, b)`(oddsByPairs[3 .. 5], [[13, 15], [17, 19]]));
8424 assert(equal!`equal(a, b)`(oddsByPairs[3 .. $].take(2), [[13, 15], [17, 19]]));
8578 import std.algorithm.comparison : equal;
8588 import std.algorithm.comparison : equal;
8595 assert(equal(retro(array(chunks)), array(retro(chunks))));
8610 import std.algorithm.comparison : equal;
8616 assert(equal(chunks, [[], [], []]));
8618 assert(equal(chunks, [[1], [2], [3], [], []]));
8657 import std.algorithm.comparison : equal;
8659 assert([0, 1, 2, 3].slide(2).equal!equal(
8663 assert(5.iota.slide(3).equal!equal(
8671 import std.algorithm.comparison : equal;
8673 assert(6.iota.slide(1, 2).equal!equal(
8677 assert(6.iota.slide(2, 4).equal!equal(
8681 assert(iota(7).slide(2, 2).equal!equal(
8685 assert(iota(12).slide(2, 4).equal!equal(
8693 import std.algorithm.comparison : equal;
8696 assert(3.iota.slide!(Yes.withPartial)(4).equal!equal(
8714 import std.algorithm.comparison : equal;
8716 assert(5.iota.slide!(Yes.withPartial)(3, 4).equal!equal([[0, 1, 2], [4]]));
8717 assert(6.iota.slide!(Yes.withPartial)(3, 4).equal!equal([[0, 1, 2], [4, 5]]));
8718 assert(7.iota.slide!(Yes.withPartial)(3, 4).equal!equal([[0, 1, 2], [4, 5, 6]]));
8720 assert(5.iota.slide!(No.withPartial)(3, 4).equal!equal([[0, 1, 2]]));
8721 assert(6.iota.slide!(No.withPartial)(3, 4).equal!equal([[0, 1, 2]]));
8722 assert(7.iota.slide!(No.withPartial)(3, 4).equal!equal([[0, 1, 2], [4, 5, 6]]));
9252 import std.algorithm.comparison : equal;
9255 assert(4.iota.slide!(Yes.withPartial)(1).equal!equal(res1));
9258 assert(4.iota.slide!(Yes.withPartial)(2).equal!equal(res2));
9265 import std.algorithm.comparison : equal;
9274 assert(iota(2).slide!(Yes.withPartial)(2).front.equal([0, 1]));
9275 assert(iota(3).slide!(Yes.withPartial)(2).equal!equal([[0, 1],[1, 2]]));
9276 assert(iota(3).slide!(Yes.withPartial)(3).equal!equal([[0, 1, 2]]));
9278 assert(iota(3).slide!(Yes.withPartial)(4).equal!equal([[0, 1, 2]]));
9279 assert(iota(1, 4).slide!(Yes.withPartial)(1).equal!equal([[1], [2], [3]]));
9280 assert(iota(1, 4).slide!(Yes.withPartial)(3).equal!equal([[1, 2, 3]]));
9286 import std.algorithm.comparison : equal;
9309 assert(6.iota.slide!Partial(e[0].expand).equal!equal(e[1]));
9321 assert(6.iota.slide!(Yes.withPartial)(e[0].expand).equal!equal(e[1]));
9322 assert(6.iota.slide!(No.withPartial)(e[0].expand).equal!equal(e[1].dropBackOne));
9329 import std.algorithm.comparison : equal;
9340 assert(e.save.equal!equal([[1, 2], [2, 3], [3, 4]]));
9341 assert(e.save.equal!equal([[1, 2], [2, 3], [3, 4]]));
9366 import std.algorithm.comparison : equal;
9368 assert("ä.ö.ü.".slide!(Yes.withPartial)(3, 2).equal!equal(["ä.ö", "ö.ü", "ü."]));
9369 assert("ä.ö.ü.".slide!(No.withPartial)(3, 2).equal!equal(["ä.ö", "ö.ü"]));
9371 "��������������������".slide!(Yes.withPartial)(2, 4).equal!equal(["����", "����", "����"]);
9372 "��������������������".slide!(No.withPartial)(2, 4).equal!equal(["����", "����", "����"]);
9373 …"��������������������".slide!(Yes.withPartial)(3, 3).equal!equal(["������", "������", "������", "�…
9374 "��������������������".slide!(No.withPartial)(3, 3).equal!equal(["������", "������", "������"]);
9413 import std.algorithm.comparison : equal;
9434 assert(r[i .. j].equal(arr[i .. j]));
9436 assert(r[i .. $].equal(arr[i .. $]));
9440 assert(r[$/2 .. $].equal(arr[$/2 .. $]));
9455 import std.algorithm.comparison : equal;
9461 assert(fibs.slide!Partial(2).take(2).equal!equal([[1, 1], [1, 2]]));
9462 assert(fibs.slide!Partial(2, 3).take(2).equal!equal([[1, 1], [3, 5]]));
9467 assert(oddsByPairs.take(2).equal!equal([[ 1, 3], [ 3, 5]]));
9468 assert(oddsByPairs[1].equal([3, 5]));
9469 assert(oddsByPairs[4].equal([9, 11]));
9472 assert(oddsByPairs[3 .. 5].equal!equal([[7, 9], [9, 11]]));
9473 assert(oddsByPairs[3 .. $].take(2).equal!equal([[7, 9], [9, 11]]));
9476 assert(oddsWithGaps.take(3).equal!equal([[1, 3], [9, 11], [17, 19]]));
9477 assert(oddsWithGaps[2].equal([17, 19]));
9478 assert(oddsWithGaps[1 .. 3].equal!equal([[9, 11], [17, 19]]));
9479 assert(oddsWithGaps[1 .. $].take(2).equal!equal([[9, 11], [17, 19]]));
9486 import std.algorithm.comparison : equal;
9498 assert(rRetro.equal(rArr));
9499 assert(rRetro.array.retro.equal(r));
9507 import std.algorithm.comparison : equal;
9517 assert(r.slide!Partial(1).equal!equal(
9520 assert(r.slide!Partial(2).equal!equal(
9523 assert(r.slide!Partial(3).equal!equal(
9527 assert(r.slide!Partial(6).equal!equal(
9534 assert(r.slide!(Yes.withPartial)(15).equal!equal(iota(1, 11).only));
9544 import std.algorithm.comparison : equal;
9566 assert(Range().take(e[0]).slide!Partial(e[1].expand).equal!equal(e[2]));
9585 assert(r.take(e[0]).slide!(Yes.withPartial)(e[1].expand).equal!equal(e[2]));
9586 assert(r.take(e[0]).slide!(No.withPartial)(e[1].expand).equal!equal(e[2].dropBackOne));
9593 import std.algorithm.comparison : equal;
9615 assert(r.slide!Partial(e[0], e[1]).retro.equal!equal(e[2]));
9624 assert(sliderRetro.retro.equal!equal(slider));
9630 assert(r.slide!(Yes.withPartial)(15).retro.equal!equal(iota(1, 11).only));
9637 import std.algorithm.comparison : equal;
9696 assert(r.slide!Partial(2)[0].equal([0, 1]));
9697 assert(r.slide!Partial(2)[1].equal([1, 2]));
9701 assert(s[0 .. 2].equal!equal([[0, 1], [1, 2]]));
9703 assert(s[0 .. 2].equal!equal([[0, 1], [1, 2]]));
9705 assert(r.slide!Partial(3)[1 .. 3].equal!equal([[1, 2, 3], [2, 3, 4]]));
9714 assert(r.slide!(No.withPartial)(6).equal!equal(
9720 assert(r.slide!Partial(4)[0 .. $].equal(r.slide!Partial(4)));
9721 … assert(r.slide!Partial(2)[$/2 .. $].equal!equal([[4, 5], [5, 6], [6, 7], [7, 8], [8, 9]]));
9724 assert(r.slide!Partial(3).retro.equal!equal(
9733 assert(infIndex.slide!Partial(2)[0].equal([0, 1]));
9734 assert(infIndex.slide!Partial(2)[1].equal([1, 2]));
9737 assert(infDollar.slide!Partial(2)[1 .. $].front.equal([1, 2]));
9738 assert(infDollar.slide!Partial(4)[0 .. $].front.equal([0, 1, 2, 3]));
9739 assert(infDollar.slide!Partial(4)[2 .. $].front.equal([2, 3, 4, 5]));
9746 import std.algorithm.comparison : equal;
9748 assert([1].map!(x => x).slide(2).equal!equal([[1]]));
9975 import std.algorithm.comparison : equal;
9980 assert(equal(only('♡'), "♡"));
9983 assert(only("one", "two", "three").joiner(" ").equal("one two three"));
9990 .equal("T.D.P.L"));
10006 import std.algorithm.comparison : equal;
10020 assert(emptyRange.equal(emptyRange[]));
10021 assert(emptyRange.equal(emptyRange.save));
10022 assert(emptyRange[0 .. 0].equal(emptyRange));
10028 import std.algorithm.comparison : equal;
10038 assert(equal(a, a[]));
10039 assert(equal(a, a[0 .. 1]));
10040 assert(equal(a[0 .. 0], e));
10041 assert(equal(a[1 .. 1], e));
10045 assert(equal(a, b));
10067 assert(equal(imm, imm[]));
10068 assert(equal(imm, imm[0 .. 1]));
10069 assert(equal(imm[0 .. 0], imme));
10070 assert(equal(imm[1 .. 1], imme));
10077 import std.algorithm.comparison : equal;
10101 assert(saved.equal(only(1, 2, 3)));
10102 assert(saved.equal(saved[]));
10103 assert(saved[0 .. 1].equal(only(1)));
10104 assert(saved[0 .. 2].equal(only(1, 2)));
10105 assert(saved[0 .. 3].equal(saved));
10106 assert(saved[1 .. 3].equal(only(2, 3)));
10107 assert(saved[2 .. 3].equal(only(3)));
10129 assert(values[0 .. $].equal(values[0 .. values.length]));
10130 assert(values.joiner(" ").equal(joinedRange.front));
10134 assert(saved.retro.equal(only(3, 2, 1)));
10525 import std.algorithm.comparison : equal;
10532 assert(enumerated.equal(values[].zip(values)));
10539 assert(offsetEnumerated.equal(subset.zip(subset)));
10705 import std.algorithm.comparison : equal;
10709 assert(p1.equal([4, 5, 6, 7, 8, 9]));
10712 assert(p2.equal([0, 1, 2, 3]));
11035 import std.algorithm.comparison : equal;
11038 assert(equal(p, [ 0, 1, 2, 3 ]));
11078 import std.algorithm.comparison : equal;
11081 assert(equal(p, [4, 4, 5, 6]));
11141 import std.algorithm.comparison : equal;
11144 assert(equal(r, [ 3, 3, 3 ]));
11202 import std.algorithm.comparison : equal;
11205 assert(equal(r[0], [ 1, 2 ]));
11206 assert(equal(r[1], [ 3, 3, 3 ]));
11207 assert(equal(r[2], [ 4, 4, 5, 6 ]));
11299 import std.algorithm.comparison : equal;
11310 assert(equal(lessThanTwo, [S(1)]));
11327 import std.algorithm.comparison : equal;
11331 assert(equal(r[0], [ 10, 20 ]));
11332 assert(equal(r[1], [ 30, 30, 30 ]));
11333 assert(equal(r[2], [ 40, 40, 50, 60 ]));
11336 assert(equal(r[0], [ 10, 20, 30, 30, 30 ]));
11338 assert(equal(r[2], [ 40, 40, 50, 60 ]));
11343 import std.algorithm.comparison : equal;
11346 assert(equal(r[0], [ "A", "AG" ]));
11347 assert(equal(r[1], [ "B" ]));
11348 assert(equal(r[2], [ "E", "F" ]));
11351 assert(equal(r[1], [ "A" ]));
11352 assert(equal(r[2], [ "AG", "B", "E", "F" ]));
11357 import std.algorithm.comparison : equal;
11362 assert(equal(r.lowerBound(42), [1, 2, 3]));
11364 assert(equal(r.lowerBound!(pol)(42), [1, 2, 3]));
11365 assert(equal(r.lowerBound!(pol)(41), [1, 2, 3]));
11366 assert(equal(r.lowerBound!(pol)(43), [1, 2, 3, 42]));
11367 assert(equal(r.lowerBound!(pol)(51), [1, 2, 3, 42]));
11368 assert(equal(r.lowerBound!(pol)(3), [1, 2]));
11369 assert(equal(r.lowerBound!(pol)(55), [1, 2, 3, 42, 52]));
11370 assert(equal(r.lowerBound!(pol)(420), a));
11371 assert(equal(r.lowerBound!(pol)(0), a[0 .. 0]));
11373 assert(equal(r.upperBound!(pol)(42), [52, 64]));
11374 assert(equal(r.upperBound!(pol)(41), [42, 52, 64]));
11375 assert(equal(r.upperBound!(pol)(43), [52, 64]));
11376 assert(equal(r.upperBound!(pol)(51), [52, 64]));
11377 assert(equal(r.upperBound!(pol)(53), [64]));
11378 assert(equal(r.upperBound!(pol)(55), [64]));
11379 assert(equal(r.upperBound!(pol)(420), a[0 .. 0]));
11380 assert(equal(r.upperBound!(pol)(0), a));
11421 import std.algorithm.comparison : equal;
11424 assert(s.groupBy.equal!equal([[100, 101, 102], [200, 201], [300]]));
11485 import std.algorithm.comparison : equal;
11490 assert(equal(p.lowerBound(4), [0, 1, 2, 3]));
11491 assert(equal(p.lowerBound(5), [0, 1, 2, 3, 4]));
11492 assert(equal(p.lowerBound(6), [0, 1, 2, 3, 4, 5]));
11493 assert(equal(p.lowerBound(6.9), [0, 1, 2, 3, 4, 5, 6]));
11498 import std.algorithm.comparison : equal;
11502 assert(equal(p, [4, 4, 5, 6 ]));
11504 assert(equal(p, [ 5, 6 ]));
11514 import std.algorithm.comparison : equal;
11519 assert(equal(p, [ 3, 3, 3 ]), text(p));
11521 assert(equal(p, [ 4, 4 ]), text(p));
11523 assert(equal(p, [ 2 ]));
11529 assert(equal(p, [ 3, 3, 3]));
12656 assert(rb.take(10).equal(rb2.take(10)));