Merge pull request #4814 from e-y-e/fixflags

[trivial] [large diff] Update uses of Flag to use the Yes/No structs.

Author: andralex

std/algorithm/comparison.d

@@ -60,7 +60,7 @@ import std.functional; // : unaryFun, binaryFun;
 import std.range.primitives;
 import std.traits;
 // FIXME
-import std.typecons; // : tuple, Tuple, Flag;
+import std.typecons; // : tuple, Tuple, Flag, Yes;
 import std.meta : allSatisfy;
 
 /**
@@ -1805,8 +1805,8 @@ alias AllocateGC = Flag!"allocateGC";
 /**
 Checks if both ranges are permutations of each other.
 
-This function can allocate if the $(D AllocateGC.yes) flag is passed. This has
-the benefit of have better complexity than the $(D AllocateGC.no) option. However,
+This function can allocate if the $(D Yes.allocateGC) flag is passed. This has
+the benefit of have better complexity than the $(D Yes.allocateGC) option. However,
 this option is only available for ranges whose equality can be determined via each
 element's $(D toHash) method. If customized equality is needed, then the $(D pred)
 template parameter can be passed, and the function will automatically switch to
@@ -1819,7 +1819,7 @@ Allocating forward range option: amortized $(BIGOH r1.length) + $(BIGOH r2.lengt
 
 Params:
     pred = an optional parameter to change how equality is defined
-    allocate_gc = AllocateGC.yes/no
+    allocate_gc = $(D Yes.allocateGC)/$(D No.allocateGC)
     r1 = A finite forward range
     r2 = A finite forward range
 
@@ -1830,7 +1830,7 @@ Returns:
 
 bool isPermutation(AllocateGC allocate_gc, Range1, Range2)
 (Range1 r1, Range2 r2)
-    if (allocate_gc == AllocateGC.yes &&
+    if (allocate_gc == Yes.allocateGC &&
         isForwardRange!Range1 &&
         isForwardRange!Range2 &&
         !isInfinite!Range1 &&
@@ -1959,8 +1959,8 @@ bool isPermutation(alias pred = "a == b", Range1, Range2)
     assert(!isPermutation([1, 1], [1, 1, 1]));
 
     // Faster, but allocates GC handled memory
-    assert(isPermutation!(AllocateGC.yes)([1.1, 2.3, 3.5], [2.3, 3.5, 1.1]));
-    assert(!isPermutation!(AllocateGC.yes)([1, 2], [3, 4]));
+    assert(isPermutation!(Yes.allocateGC)([1.1, 2.3, 3.5], [2.3, 3.5, 1.1]));
+    assert(!isPermutation!(Yes.allocateGC)([1, 2], [3, 4]));
 }
 
 // Test @nogc inference
@@ -1985,23 +1985,23 @@ bool isPermutation(alias pred = "a == b", Range1, Range2)
 
     auto r3 = new ReferenceForwardRange!int([1, 2, 3, 4]);
     auto r4 = new ReferenceForwardRange!int([4, 2, 1, 3]);
-    assert(isPermutation!(AllocateGC.yes)(r3, r4));
+    assert(isPermutation!(Yes.allocateGC)(r3, r4));
 
     auto r5 = new ReferenceForwardRange!int([1, 2, 3]);
     auto r6 = new ReferenceForwardRange!int([4, 2, 1, 3]);
     assert(!isPermutation(r5, r6));
 
     auto r7 = new ReferenceForwardRange!int([4, 2, 1, 3]);
     auto r8 = new ReferenceForwardRange!int([1, 2, 3]);
-    assert(!isPermutation!(AllocateGC.yes)(r7, r8));
+    assert(!isPermutation!(Yes.allocateGC)(r7, r8));
 
     DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Random) r9;
     DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Random) r10;
     assert(isPermutation(r9, r10));
 
     DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Random) r11;
     DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Random) r12;
-    assert(isPermutation!(AllocateGC.yes)(r11, r12));
+    assert(isPermutation!(Yes.allocateGC)(r11, r12));
 
     alias mytuple = Tuple!(int, int);
 

std/algorithm/searching.d

@@ -102,7 +102,7 @@ import std.functional; // : unaryFun, binaryFun;
 import std.range.primitives;
 import std.traits;
 // FIXME
-import std.typecons; // : Tuple, Flag;
+import std.typecons; // : Tuple, Flag, Yes, No;
 
 /++
 Checks if $(I _all) of the elements verify $(D pred).
@@ -3959,8 +3959,8 @@ Params:
     to iterate over.
     sentinel = The element to stop at.
     openRight = Determines whether the element for which the given predicate is
-        true should be included in the resulting range ($(D OpenRight.no)), or
-        not ($(D OpenRight.yes)).
+        true should be included in the resulting range ($(D No.openRight)), or
+        not ($(D Yes.openRight)).
 
 Returns:
     An $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives) that
@@ -3971,7 +3971,7 @@ Returns:
  */
 Until!(pred, Range, Sentinel)
 until(alias pred = "a == b", Range, Sentinel)
-(Range range, Sentinel sentinel, OpenRight openRight = OpenRight.yes)
+(Range range, Sentinel sentinel, OpenRight openRight = Yes.openRight)
 if (!is(Sentinel == OpenRight))
 {
     return typeof(return)(range, sentinel, openRight);
@@ -3980,7 +3980,7 @@ if (!is(Sentinel == OpenRight))
 /// Ditto
 Until!(pred, Range, void)
 until(alias pred, Range)
-(Range range, OpenRight openRight = OpenRight.yes)
+(Range range, OpenRight openRight = Yes.openRight)
 {
     return typeof(return)(range, openRight);
 }
@@ -4003,7 +4003,7 @@ struct Until(alias pred, Range, Sentinel) if (isInputRange!Range)
     static if (!is(Sentinel == void))
         ///
         this(Range input, Sentinel sentinel,
-                OpenRight openRight = OpenRight.yes)
+                OpenRight openRight = Yes.openRight)
         {
             _input = input;
             _sentinel = sentinel;
@@ -4012,7 +4012,7 @@ struct Until(alias pred, Range, Sentinel) if (isInputRange!Range)
         }
     else
         ///
-        this(Range input, OpenRight openRight = OpenRight.yes)
+        this(Range input, OpenRight openRight = Yes.openRight)
         {
             _input = input;
             _openRight = openRight;
@@ -4089,7 +4089,7 @@ struct Until(alias pred, Range, Sentinel) if (isInputRange!Range)
     import std.algorithm.comparison : equal;
     int[] a = [ 1, 2, 4, 7, 7, 2, 4, 7, 3, 5];
     assert(equal(a.until(7), [1, 2, 4][]));
-    assert(equal(a.until(7, OpenRight.no), [1, 2, 4, 7][]));
+    assert(equal(a.until(7, No.openRight), [1, 2, 4, 7][]));
 }
 
 @safe unittest
@@ -4099,20 +4099,20 @@ struct Until(alias pred, Range, Sentinel) if (isInputRange!Range)
     int[] a = [ 1, 2, 4, 7, 7, 2, 4, 7, 3, 5];
 
     static assert(isForwardRange!(typeof(a.until(7))));
-    static assert(isForwardRange!(typeof(until!"a == 2"(a, OpenRight.no))));
+    static assert(isForwardRange!(typeof(until!"a == 2"(a, No.openRight))));
 
     assert(equal(a.until(7), [1, 2, 4][]));
     assert(equal(a.until([7, 2]), [1, 2, 4, 7][]));
-    assert(equal(a.until(7, OpenRight.no), [1, 2, 4, 7][]));
-    assert(equal(until!"a == 2"(a, OpenRight.no), [1, 2][]));
+    assert(equal(a.until(7, No.openRight), [1, 2, 4, 7][]));
+    assert(equal(until!"a == 2"(a, No.openRight), [1, 2][]));
 }
 
 unittest // bugzilla 13171
 {
     import std.algorithm.comparison : equal;
     import std.range;
     auto a = [1, 2, 3, 4];
-    assert(equal(refRange(&a).until(3, OpenRight.no), [1, 2, 3]));
+    assert(equal(refRange(&a).until(3, No.openRight), [1, 2, 3]));
     assert(a == [4]);
 }
 

std/algorithm/setops.d

@@ -46,6 +46,7 @@ import std.traits;
 import std.meta; // : AliasSeq, staticMap, allSatisfy, anySatisfy;
 
 import std.algorithm.sorting; // : Merge;
+import std.typecons : No;
 
 // cartesianProduct
 /**
@@ -574,7 +575,7 @@ duplicate in between calls).
  */
 void largestPartialIntersection
 (alias less = "a < b", RangeOfRanges, Range)
-(RangeOfRanges ror, Range tgt, SortOutput sorted = SortOutput.no)
+(RangeOfRanges ror, Range tgt, SortOutput sorted = No.sortOutput)
 {
     struct UnitWeights
     {
@@ -631,7 +632,7 @@ Params:
 */
 void largestPartialIntersectionWeighted
 (alias less = "a < b", RangeOfRanges, Range, WeightsAA)
-(RangeOfRanges ror, Range tgt, WeightsAA weights, SortOutput sorted = SortOutput.no)
+(RangeOfRanges ror, Range tgt, WeightsAA weights, SortOutput sorted = No.sortOutput)
 {
     import std.algorithm.iteration : group;
     import std.algorithm.sorting : topNCopy;
@@ -672,7 +673,7 @@ unittest
 unittest
 {
     import std.conv : text;
-    import std.typecons : tuple, Tuple;
+    import std.typecons : tuple, Tuple, Yes;
 
     debug(std_algorithm) scope(success)
         writeln("unittest @", __FILE__, ":", __LINE__, " done.");
@@ -686,7 +687,7 @@ unittest
             [ 7 ],
         ];
     auto b = new Tuple!(double, uint)[2];
-    largestPartialIntersection(a, b, SortOutput.yes);
+    largestPartialIntersection(a, b, Yes.sortOutput);
     //sort(b);
     //writeln(b);
     assert(b == [ tuple(7.0, 4u), tuple(1.0, 3u) ][], text(b));
@@ -696,7 +697,7 @@ unittest
 unittest
 {
     import std.conv : text;
-    import std.typecons : tuple, Tuple;
+    import std.typecons : tuple, Tuple, Yes;
 
     debug(std_algorithm) scope(success)
         writeln("unittest @", __FILE__, ":", __LINE__, " done.");
@@ -710,7 +711,7 @@ unittest
             [ "7" ],
         ];
     auto b = new Tuple!(string, uint)[2];
-    largestPartialIntersection(a, b, SortOutput.yes);
+    largestPartialIntersection(a, b, Yes.sortOutput);
     //writeln(b);
     assert(b == [ tuple("7", 4u), tuple("1", 3u) ][], text(b));
 }

std/algorithm/sorting.d

@@ -3148,7 +3148,7 @@ Params:
 Returns: The slice of `target` containing the copied elements.
  */
 TRange topNCopy(alias less = "a < b", SRange, TRange)
-    (SRange source, TRange target, SortOutput sorted = SortOutput.no)
+    (SRange source, TRange target, SortOutput sorted = No.sortOutput)
     if (isInputRange!(SRange) && isRandomAccessRange!(TRange)
             && hasLength!(TRange) && hasSlicing!(TRange))
 {
@@ -3158,7 +3158,7 @@ TRange topNCopy(alias less = "a < b", SRange, TRange)
     auto heap = BinaryHeap!(TRange, less)(target, 0);
     foreach (e; source) heap.conditionalInsert(e);
     auto result = target[0 .. heap.length];
-    if (sorted == SortOutput.yes)
+    if (sorted == Yes.sortOutput)
     {
         while (!heap.empty) heap.removeFront();
     }
@@ -3170,7 +3170,7 @@ unittest
 {
     int[] a = [ 10, 16, 2, 3, 1, 5, 0 ];
     int[] b = new int[3];
-    topNCopy(a, b, SortOutput.yes);
+    topNCopy(a, b, Yes.sortOutput);
     assert(b == [ 0, 1, 2 ]);
 }
 
@@ -3187,7 +3187,7 @@ unittest
     randomShuffle(a, r);
     auto n = uniform(0, a.length, r);
     ptrdiff_t[] b = new ptrdiff_t[n];
-    topNCopy!(binaryFun!("a < b"))(a, b, SortOutput.yes);
+    topNCopy!(binaryFun!("a < b"))(a, b, Yes.sortOutput);
     assert(isSorted!(binaryFun!("a < b"))(b));
 }
 
@@ -3225,7 +3225,7 @@ ignored.
 */
 void topNIndex(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
                Range, RangeIndex)
-              (Range r, RangeIndex index, SortOutput sorted = SortOutput.no)
+              (Range r, RangeIndex index, SortOutput sorted = No.sortOutput)
     if (isRandomAccessRange!Range &&
         isRandomAccessRange!RangeIndex &&
         hasAssignableElements!RangeIndex &&
@@ -3249,7 +3249,7 @@ void topNIndex(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
     {
         heap.conditionalInsert(cast(ElementType!RangeIndex) i);
     }
-    if (sorted == SortOutput.yes)
+    if (sorted == Yes.sortOutput)
     {
         while (!heap.empty) heap.removeFront();
     }
@@ -3258,7 +3258,7 @@ void topNIndex(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
 /// ditto
 void topNIndex(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
                Range, RangeIndex)
-              (Range r, RangeIndex index, SortOutput sorted = SortOutput.no)
+              (Range r, RangeIndex index, SortOutput sorted = No.sortOutput)
     if (isRandomAccessRange!Range &&
         isRandomAccessRange!RangeIndex &&
         hasAssignableElements!RangeIndex &&
@@ -3280,7 +3280,7 @@ void topNIndex(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
     {
         heap.conditionalInsert(&r[i]);
     }
-    if (sorted == SortOutput.yes)
+    if (sorted == Yes.sortOutput)
     {
         while (!heap.empty) heap.removeFront();
     }
@@ -3292,12 +3292,12 @@ unittest
     // Construct index to top 3 elements using numerical indices:
     int[] a = [ 10, 2, 7, 5, 8, 1 ];
     int[] index = new int[3];
-    topNIndex(a, index, SortOutput.yes);
+    topNIndex(a, index, Yes.sortOutput);
     assert(index == [5, 1, 3]); // because a[5]==1, a[1]==2, a[3]==5
 
     // Construct index to top 3 elements using pointer indices:
     int*[] ptrIndex = new int*[3];
-    topNIndex(a, ptrIndex, SortOutput.yes);
+    topNIndex(a, ptrIndex, Yes.sortOutput);
     assert(ptrIndex == [ &a[5], &a[1], &a[3] ]);
 }
 
@@ -3311,14 +3311,14 @@ unittest
     {
         int[] a = [ 10, 8, 9, 2, 4, 6, 7, 1, 3, 5 ];
         int*[] b = new int*[5];
-        topNIndex!("a > b")(a, b, SortOutput.yes);
+        topNIndex!("a > b")(a, b, Yes.sortOutput);
         //foreach (e; b) writeln(*e);
         assert(b == [ &a[0], &a[2], &a[1], &a[6], &a[5]]);
     }
     {
         int[] a = [ 10, 8, 9, 2, 4, 6, 7, 1, 3, 5 ];
         auto b = new ubyte[5];
-        topNIndex!("a > b")(a, b, SortOutput.yes);
+        topNIndex!("a > b")(a, b, Yes.sortOutput);
         //foreach (e; b) writeln(e, ":", a[e]);
         assert(b == [ cast(ubyte) 0, cast(ubyte)2, cast(ubyte)1, cast(ubyte)6, cast(ubyte)5], text(b));
     }