Merge pull request #4973 from wilzbach/add-examples-to-std-algorithm

Add public examples to std.algorithm

Author: andralex

std/algorithm/mutation.d

@@ -1755,6 +1755,24 @@ if (s == SwapStrategy.stable
     return result;
 }
 
+///
+@safe pure unittest
+{
+    import std.typecons : tuple;
+
+    auto a = [ 0, 1, 2, 3, 4, 5 ];
+    assert(remove!(SwapStrategy.stable)(a, 1) == [ 0, 2, 3, 4, 5 ]);
+    a = [ 0, 1, 2, 3, 4, 5 ];
+    assert(remove!(SwapStrategy.stable)(a, 1, 3) == [ 0, 2, 4, 5] );
+    a = [ 0, 1, 2, 3, 4, 5 ];
+    assert(remove!(SwapStrategy.stable)(a, 1, tuple(3, 6)) == [ 0, 2 ]);
+
+    a = [ 0, 1, 2, 3, 4, 5 ];
+    assert(remove!(SwapStrategy.unstable)(a, 1) == [0, 5, 2, 3, 4]);
+    a = [ 0, 1, 2, 3, 4, 5 ];
+    assert(remove!(SwapStrategy.unstable)(a, tuple(1, 4)) == [0]);
+}
+
 @safe unittest
 {
     import std.exception : assertThrown;

std/algorithm/searching.d

@@ -270,14 +270,6 @@ if (isInputRange!(Range) && is(typeof(r.front == lPar)))
  * invoke the Boyer-Moore matching algorithm for finding of $(D needle) in a
  * given haystack.
  */
-BoyerMooreFinder!(binaryFun!(pred), Range) boyerMooreFinder
-(alias pred = "a == b", Range)
-(Range needle) if ((isRandomAccessRange!(Range) && hasSlicing!Range) || isSomeString!Range)
-{
-    return typeof(return)(needle);
-}
-
-/// Ditto
 struct BoyerMooreFinder(alias pred, Range)
 {
 private:
@@ -379,6 +371,29 @@ public:
     alias opDollar = length;
 }
 
+/// Ditto
+BoyerMooreFinder!(binaryFun!(pred), Range) boyerMooreFinder
+(alias pred = "a == b", Range)
+(Range needle) if ((isRandomAccessRange!(Range) && hasSlicing!Range) || isSomeString!Range)
+{
+    return typeof(return)(needle);
+}
+
+///
+@safe pure nothrow unittest
+{
+    auto bmFinder = boyerMooreFinder("TG");
+
+    string r = "TAGTGCCTGA";
+    // search for the first match in the haystack r
+    r = bmFinder.beFound(r);
+    assert(r == "TGCCTGA");
+
+    // continue search in haystack
+    r = bmFinder.beFound(r[2 .. $]);
+    assert(r == "TGA");
+}
+
 /**
 Returns the common prefix of two ranges.
 

std/algorithm/sorting.d

@@ -2938,39 +2938,11 @@ schwartzSort(alias transform, alias less = "a < b",
     return typeof(return)(r);
 }
 
-@safe unittest
-{
-    // issue 4909
-    import std.typecons : Tuple;
-    Tuple!(char)[] chars;
-    schwartzSort!"a[0]"(chars);
-}
-
-@safe unittest
-{
-    // issue 5924
-    import std.typecons : Tuple;
-    Tuple!(char)[] chars;
-    schwartzSort!((Tuple!(char) c){ return c[0]; })(chars);
-}
-
+///
 @safe unittest
 {
     import std.algorithm.iteration : map;
-    import std.math : log2;
-
-    debug(std_algorithm) scope(success)
-        writeln("unittest @", __FILE__, ":", __LINE__, " done.");
-
-    static double entropy(double[] probs) {
-        double result = 0;
-        foreach (ref p; probs)
-        {
-            if (!p) continue;
-            result -= p * log2(p);
-        }
-        return result;
-    }
+    import std.numeric : entropy;
 
     auto lowEnt = [ 1.0, 0, 0 ],
          midEnt = [ 0.1, 0.1, 0.8 ],
@@ -2980,7 +2952,7 @@ schwartzSort(alias transform, alias less = "a < b",
     arr[1] = lowEnt;
     arr[2] = highEnt;
 
-    schwartzSort!(entropy, q{a > b})(arr);
+    schwartzSort!(entropy, "a > b")(arr);
 
     assert(arr[0] == highEnt);
     assert(arr[1] == midEnt);
@@ -2991,21 +2963,11 @@ schwartzSort(alias transform, alias less = "a < b",
 @safe unittest
 {
     import std.algorithm.iteration : map;
-    import std.math : log2;
+    import std.numeric : entropy;
 
     debug(std_algorithm) scope(success)
         writeln("unittest @", __FILE__, ":", __LINE__, " done.");
 
-    static double entropy(double[] probs) {
-        double result = 0;
-        foreach (ref p; probs)
-        {
-            if (!p) continue;
-            result -= p * log2(p);
-        }
-        return result;
-    }
-
     auto lowEnt = [ 1.0, 0, 0 ],
         midEnt = [ 0.1, 0.1, 0.8 ],
         highEnt = [ 0.31, 0.29, 0.4 ];
@@ -3014,14 +2976,30 @@ schwartzSort(alias transform, alias less = "a < b",
     arr[1] = lowEnt;
     arr[2] = highEnt;
 
-    schwartzSort!(entropy, q{a < b})(arr);
+    schwartzSort!(entropy, "a < b")(arr);
 
     assert(arr[0] == lowEnt);
     assert(arr[1] == midEnt);
     assert(arr[2] == highEnt);
     assert(isSorted!("a < b")(map!(entropy)(arr)));
 }
 
+@safe unittest
+{
+    // issue 4909
+    import std.typecons : Tuple;
+    Tuple!(char)[] chars;
+    schwartzSort!"a[0]"(chars);
+}
+
+@safe unittest
+{
+    // issue 5924
+    import std.typecons : Tuple;
+    Tuple!(char)[] chars;
+    schwartzSort!((Tuple!(char) c){ return c[0]; })(chars);
+}
+
 // partialSort
 /**
 Reorders the random-access range $(D r) such that the range $(D r[0