Use selective imports for module imports (part III)

Author: wilzbach

std/algorithm/searching.d

@@ -110,7 +110,7 @@ import std.functional : unaryFun, binaryFun;
 import std.range.primitives;
 import std.traits;
 // FIXME
-import std.typecons : Tuple, Flag, Yes, No;
+import std.typecons : Tuple, tuple, Flag, Yes, No;
 
 /++
 Checks if $(I _all) of the elements verify $(D pred).

std/algorithm/sorting.d

@@ -78,7 +78,7 @@ module std.algorithm.sorting;
 import std.algorithm.mutation : SwapStrategy;
 import std.functional : unaryFun, binaryFun;
 import std.range.primitives;
-import std.typecons : Flag, No;
+import std.typecons : Flag, Yes, No;
 // FIXME
 import std.meta : allSatisfy;
 import std.range : SortedRange;
@@ -747,7 +747,9 @@ if (isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range)
         assert(a == [ 42, 42 ]);
 
         import std.algorithm.iteration : map;
+        import std.array : array;
         import std.random;
+        import std.range : iota;
         import std.stdio;
         auto s = unpredictableSeed;
         auto g = Random(s);
@@ -1059,6 +1061,7 @@ if (isRandomAccessRange!Range && !isInfinite!Range &&
 @safe unittest
 {
     import std.algorithm.comparison : equal;
+    import std.range : iota;
 
     ubyte[256] index = void;
     iota(256).makeIndex(index[]);
@@ -1540,7 +1543,8 @@ private void multiSortImpl(Range, SwapStrategy ss, funs...)(Range r)
 @safe unittest
 {
     import std.algorithm.comparison : equal;
-    import std.range;
+    import std.array : array;
+    import std.range : indexed, iota, retro;
 
     static struct Point { int x, y; }
     auto pts1 = [ Point(5, 6), Point(1, 0), Point(5, 7), Point(1, 1), Point(1, 2), Point(0, 1) ];
@@ -1787,6 +1791,7 @@ private void sort5(alias lt, Range)(Range r)
 {
     import std.algorithm.iteration : permutations;
     import std.algorithm.mutation : copy;
+    import std.range : iota;
 
     int[5] buf;
     foreach (per; iota(5).permutations)
@@ -1928,6 +1933,9 @@ if (((ss == SwapStrategy.unstable && (hasSwappableElements!Range ||
 {
     // Simple regression benchmark
     import std.algorithm.iteration, std.algorithm.mutation, std.random;
+    import std.array : array;
+    import std.range : iota;
+
     Random rng;
     int[] a = iota(20148).map!(_ => uniform(-1000, 1000, rng)).array;
     static uint comps;
@@ -3439,6 +3447,8 @@ done:
 
 @safe unittest
 {
+    import std.array : array;
+
     auto a = [ 10, 5, 3, 4, 8,  11,  13, 3, 9, 4, 10 ];
     assert(expandPartition!((a, b) => a < b)(a, 4, 5, 6) == 9);
     a = randomArray;
@@ -3453,7 +3463,10 @@ private T[] randomArray(Flag!"exactSize" flag = No.exactSize, T = int)(
     T minValue = 0, T maxValue = 255)
 {
     import std.algorithm.iteration : map;
+    import std.array : array;
     import std.random : unpredictableSeed, Random, uniform;
+    import std.range : iota;
+
     auto size = flag == Yes.exactSize ? maxSize : uniform(1, maxSize);
     return iota(0, size).map!(_ => uniform(minValue, maxValue)).array;
 }

std/ascii.d

@@ -652,6 +652,8 @@ if (is(C : dchar))
 
 @safe unittest //Test both toUpper and toLower with non-builtin
 {
+    import std.traits : OriginalType;
+
     //User Defined [Char|Wchar|Dchar]
     static struct UDC {  char c; alias c this; }
     static struct UDW { wchar c; alias c this; }

std/net/isemail.d

@@ -25,7 +25,7 @@
 module std.net.isemail;
 
 // FIXME
-import std.range.primitives : ElementType;
+import std.range.primitives : back, ElementType, front, empty, popFront;
 import std.regex;
 import std.traits;
 import std.typecons : Flag, Yes, No;
@@ -1912,6 +1912,7 @@ if (is(Unqual!(ElementType!(S1)) == dchar) && is(Unqual!(ElementType!(S2)) == dc
 ElementType!(A) pop (A) (ref A a)
 if (isDynamicArray!(A) && !isNarrowString!(A) && isMutable!(A) && !is(A == void[]))
 {
+    import std.range.primitives : popBack;
     auto e = a.back;
     a.popBack();
     return e;

std/range/package.d

@@ -3319,12 +3319,13 @@ private struct Generator(Fun...)
     static assert(isInputRange!Generator);
 
 private:
+    import std.traits : FunctionAttribute, functionAttributes, ReturnType;
     static if (is(Fun[0]))
         Fun[0] fun;
     else
         alias fun = Fun[0];
 
-    enum returnByRef_ = (functionAttributes!fun & FunctionAttribute.ref_) ? true : false;
+    enum returnByRef_ = functionAttributes!fun & FunctionAttribute.ref_;
     static if (returnByRef_)
         ReturnType!fun *elem_;
     else
@@ -5550,6 +5551,8 @@ body
 
 nothrow @nogc @safe unittest
 {
+    import std.traits : Signed;
+
     auto t0 = iota(0, 10);
     auto t1 = iota(0, 10, 2);
     auto t2 = iota(1, 1, 0);
@@ -10774,6 +10777,7 @@ private struct Bitwise(R)
 if (isInputRange!R && isIntegral!(ElementType!R))
 {
 private:
+    import std.traits : Unsigned;
     alias ElemType = ElementType!R;
     alias UnsignedElemType = Unsigned!ElemType;
 
@@ -11089,6 +11093,7 @@ if (isInputRange!R && isIntegral!(ElementType!R))
 @safe pure nothrow unittest
 {
     import std.internal.test.dummyrange;
+    import std.meta : AliasSeq;
 
     alias IntegralTypes = AliasSeq!(byte, ubyte, short, ushort, int, uint,
             long, ulong);
@@ -11184,6 +11189,7 @@ if (isInputRange!R && isIntegral!(ElementType!R))
 // Test opIndex and opSlice
 @system unittest
 {
+    import std.meta : AliasSeq;
     alias IntegralTypes = AliasSeq!(byte, ubyte, short, ushort, int, uint,
             long, ulong);
     foreach (IntegralType; IntegralTypes)

std/stdio.d

@@ -20,7 +20,7 @@ import std.meta : allSatisfy;
 import std.range.primitives : ElementEncodingType, empty, front,
     isBidirectionalRange, isInputRange, put;
 import std.traits : isSomeChar, isSomeString, Unqual, isPointer;
-import std.typecons : Flag;
+import std.typecons : Flag, Yes, No;
 
 /++
 If flag $(D KeepTerminator) is set to $(D KeepTerminator.yes), then the delimiter

std/typecons.d

@@ -41,7 +41,7 @@ Authors:   $(HTTP erdani.org, Andrei Alexandrescu),
 module std.typecons;
 
 import core.stdc.stdint : uintptr_t;
-import std.meta : AliasSeq, allSatisfy;
+import std.meta : Alias, AliasSeq, aliasSeqOf, allSatisfy;
 import std.traits;
 
 debug(Unique) import std.stdio;
@@ -3974,6 +3974,7 @@ private static:
             };
         }
     }
+    import std.meta : templateNot;
 
     alias Implementation = AutoImplement!(Issue17177, how, templateNot!isFinalFunction);
 }

std/uni.d

@@ -709,8 +709,8 @@ module std.uni;
 
 import std.meta : AliasSeq;
 import std.range.primitives :back, ElementEncodingType, ElementType, empty,
-    front, isForwardRange, isInputRange, isRandomAccessRange, popFront, put,
-    save;
+    front, isForwardRange, isInputRange, isRandomAccessRange, popFront, popFrontN,
+    put, save;
 import std.traits :isConvertibleToString, isIntegral, isSomeChar,
     isSomeString, Unqual;