Transform isSliceOf into a documented unittest using overlap

Author: RazvanN7

changelog/std-array-sliceOf.dd

@@ -59,9 +59,6 @@ $(TR $(TH Function Name) $(TH Description)
         $(TD Checks if the final segments of two arrays refer to the same place
         in memory.
     ))
-    $(TR $(TD $(LREF isSliceOf))
-        $(TD Checks if the first array is a slice of the second array.
-    ))
     $(TR $(TD $(LREF split))
         $(TD Eagerly split a range or string into an array.
     ))
@@ -1271,6 +1268,63 @@ if (is(typeof(a.ptr < b.ptr) == bool))
     static assert(test == "three"d);
 }
 
+///
+@safe pure nothrow unittest
+{
+
+    // can be used as an alternative implementation of overlap that returns
+    // `true` or `false` instead of a slice of the overlap
+    bool isSliceOf(T)(const scope T[] part, const scope T[] whole)
+    {
+        return part.overlap(whole) is part;
+    }
+
+    auto x = [1, 2, 3, 4, 5];
+
+    assert(isSliceOf(x[3..$], x));
+    assert(isSliceOf(x[], x));
+    assert(!isSliceOf(x, x[3..$]));
+    assert(!isSliceOf([7, 8], x));
+    assert(isSliceOf(null, x));
+
+    // null is a slice of itself
+    assert(isSliceOf(null, null));
+
+    foreach (T; AliasSeq!(int[], const(int)[], immutable(int)[], const int[], immutable int[]))
+    {
+        T a = [1, 2, 3, 4, 5];
+        T b = a;
+        T c = a[1 .. $];
+        T d = a[0 .. 1];
+        T e = null;
+
+        assert(isSliceOf(a, a));
+        assert(isSliceOf(b, a));
+        assert(isSliceOf(a, b));
+
+        assert(isSliceOf(c, a));
+        assert(isSliceOf(c, b));
+        assert(!isSliceOf(a, c));
+        assert(!isSliceOf(b, c));
+
+        assert(isSliceOf(d, a));
+        assert(isSliceOf(d, b));
+        assert(!isSliceOf(a, d));
+        assert(!isSliceOf(b, d));
+
+        assert(isSliceOf(e, a));
+        assert(isSliceOf(e, b));
+        assert(isSliceOf(e, c));
+        assert(isSliceOf(e, d));
+
+        //verifies R-value compatibilty
+        assert(!isSliceOf(a[$ .. $], a));
+        assert(isSliceOf(a[0 .. 0], a));
+        assert(isSliceOf(a, a[0.. $]));
+        assert(isSliceOf(a[0 .. $], a));
+    }
+}
+
 @safe pure nothrow unittest
 {
     static void test(L, R)(L l, R r)
@@ -1816,84 +1870,6 @@ pure nothrow @nogc bool sameTail(T)(in T[] lhs, in T[] rhs)
     }}
 }
 
-/**
-Checks whether a `part` is part of a `whole` array.
-
-Params:
-
-    part = The array to check for its origin
-    whole = The origin array to be queried
-
-Returns: `true` if `part` is a slice of `whole`.
-*/
-bool isSliceOf(T)(const scope T[] part, const scope T[] whole) @trusted
-{
-    return whole.ptr <= part.ptr &&
-           part.ptr + part.length <= whole.ptr + whole.length;
-}
-
-///
-@safe pure nothrow unittest
-{
-    auto a = [1, 2, 3, 4, 5];
-
-    assert(a[3..$].isSliceOf(a));
-    assert(a[].isSliceOf(a));
-    assert(!a.isSliceOf(a[3..$]));
-    assert(![7, 8].isSliceOf(a));
-    assert(!null.isSliceOf(a));
-
-    // null is a slice of itself
-    assert(null.isSliceOf(null));
-}
-
-@safe pure nothrow unittest
-{
-    static foreach (T; AliasSeq!(int[], const(int)[], immutable(int)[], const int[], immutable int[]))
-    {{
-        T a = [1, 2, 3, 4, 5];
-        T b = a;
-        T c = a[1 .. $];
-        T d = a[0 .. 1];
-        T e = null;
-
-        assert(a.isSliceOf(a));
-        assert(b.isSliceOf(a));
-        assert(a.isSliceOf(b));
-
-        assert(c.isSliceOf(a));
-        assert(c.isSliceOf(b));
-        assert(!a.isSliceOf(c));
-        assert(!b.isSliceOf(c));
-
-        assert(d.isSliceOf(a));
-        assert(d.isSliceOf(b));
-        assert(!a.isSliceOf(d));
-        assert(!b.isSliceOf(d));
-
-        assert(!e.isSliceOf(a));
-        assert(!e.isSliceOf(b));
-        assert(!e.isSliceOf(c));
-        assert(!e.isSliceOf(d));
-
-        //verifies R-value compatibilty
-        assert(a[$ .. $].isSliceOf(a));
-        assert(a[0 .. 0].isSliceOf(a));
-        assert(a.isSliceOf(a[0.. $]));
-        assert(a[0 .. $].isSliceOf(a));
-    }}
-}
-
-// null is a slice of itself
-@safe pure nothrow unittest
-{
-    assert(null.isSliceOf(null));
-
-    int[] arr;
-    assert(null.isSliceOf(arr));
-    assert(arr.isSliceOf(null));
-}
-
 /**
 Params:
     s = an $(REF_ALTTEXT input range, isInputRange, std,range,primitives)