mirrors/phobos
1
0
Fork 0
mirror of https://github.com/dlang/phobos.git synced 2025-04-29 22:50:38 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

import std.typetuple -> import std.meta

Browse source
This commit is contained in:
Dicebot 2015-04-25 13:51:11 +03:00
parent d689291080
commit 73f773838d
43 changed files with 172 additions and 172 deletions
Download patch file Download diff file Expand all files Collapse all files

2
std/algorithm/comparison.d
View file

@ -132,7 +132,7 @@ efficient search, but one that only supports matching on equality:
@safe unittest @safe unittest
{ {
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
if (auto pos = 3.among(1, 2, 3)) if (auto pos = 3.among(1, 2, 3))
assert(pos == 3); assert(pos == 3);

12
std/algorithm/iteration.d
View file

@ -294,7 +294,7 @@ private struct _Cache(R, bool bidir)
private private
{ {
import std.algorithm.internal : algoFormat; import std.algorithm.internal : algoFormat;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
alias E = ElementType!R; alias E = ElementType!R;
alias UE = Unqual!E; alias UE = Unqual!E;
@ -430,14 +430,14 @@ template map(fun...) if (fun.length >= 1)
{ {
auto map(Range)(Range r) if (isInputRange!(Unqual!Range)) auto map(Range)(Range r) if (isInputRange!(Unqual!Range))
{ {
import std.typetuple : staticMap; import std.meta : staticMap;
alias AppliedReturnType(alias f) = typeof(f(r.front)); alias AppliedReturnType(alias f) = typeof(f(r.front));
static if (fun.length > 1) static if (fun.length > 1)
{ {
import std.functional : adjoin; import std.functional : adjoin;
import std.typetuple : staticIndexOf; import std.meta : staticIndexOf;
alias _funs = staticMap!(unaryFun, fun); alias _funs = staticMap!(unaryFun, fun);
alias _fun = adjoin!_funs; alias _fun = adjoin!_funs;
@ -817,7 +817,7 @@ See_Also: $(XREF range,tee)
*/ */
template each(alias pred = "a") template each(alias pred = "a")
{ {
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
alias BinaryArgs = TypeTuple!(pred, "i", "a"); alias BinaryArgs = TypeTuple!(pred, "i", "a");
enum isRangeUnaryIterable(R) = enum isRangeUnaryIterable(R) =
@ -2445,7 +2445,7 @@ See_Also:
+/ +/
template reduce(fun...) if (fun.length >= 1) template reduce(fun...) if (fun.length >= 1)
{ {
import std.typetuple : staticMap; import std.meta : staticMap;
alias binfuns = staticMap!(binaryFun, fun); alias binfuns = staticMap!(binaryFun, fun);
static if (fun.length > 1) static if (fun.length > 1)
@ -3756,7 +3756,7 @@ if (isSomeChar!C)
@safe pure unittest @safe pure unittest
{ {
import std.algorithm.comparison : equal; import std.algorithm.comparison : equal;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
foreach(S; TypeTuple!(string, wstring, dstring)) foreach(S; TypeTuple!(string, wstring, dstring))
{ {
import std.conv : to; import std.conv : to;

2
std/algorithm/mutation.d
View file

@ -736,7 +736,7 @@ unittest
{ {
import std.algorithm.iteration : filter; import std.algorithm.iteration : filter;
import std.traits : hasElaborateAssign; import std.traits : hasElaborateAssign;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
debug(std_algorithm) scope(success) debug(std_algorithm) scope(success)
writeln("unittest @", __FILE__, ":", __LINE__, " done."); writeln("unittest @", __FILE__, ":", __LINE__, " done.");

18
std/algorithm/searching.d
View file

@ -481,7 +481,7 @@ if (isNarrowString!R1 && isNarrowString!R2)
import std.exception : assertThrown; import std.exception : assertThrown;
import std.utf : UTFException; import std.utf : UTFException;
import std.range; import std.range;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
assert(commonPrefix([1, 2, 3], [1, 2, 3, 4, 5]) == [1, 2, 3]); assert(commonPrefix([1, 2, 3], [1, 2, 3, 4, 5]) == [1, 2, 3]);
assert(commonPrefix([1, 2, 3, 4, 5], [1, 2, 3]) == [1, 2, 3]); assert(commonPrefix([1, 2, 3, 4, 5], [1, 2, 3]) == [1, 2, 3]);
@ -1065,7 +1065,7 @@ if (isBidirectionalRange!R &&
@safe unittest @safe unittest
{ {
import std.algorithm.iteration : filterBidirectional; import std.algorithm.iteration : filterBidirectional;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
import std.conv : to; import std.conv : to;
debug(std_algorithm) scope(success) debug(std_algorithm) scope(success)
@ -1367,7 +1367,7 @@ if (isInputRange!InputRange &&
@safe pure unittest @safe pure unittest
{ {
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
foreach(R; TypeTuple!(string, wstring, dstring)) foreach(R; TypeTuple!(string, wstring, dstring))
{ {
foreach(E; TypeTuple!(char, wchar, dchar)) foreach(E; TypeTuple!(char, wchar, dchar))
@ -1411,7 +1411,7 @@ if (isInputRange!InputRange &&
@safe unittest @safe unittest
{ {
import std.exception : assertCTFEable; import std.exception : assertCTFEable;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
void dg() @safe pure nothrow void dg() @safe pure nothrow
{ {
@ -1959,7 +1959,7 @@ if (Ranges.length > 1 && is(typeof(startsWith!pred(haystack, needles))))
@safe unittest @safe unittest
{ {
import std.algorithm.internal : rndstuff; import std.algorithm.internal : rndstuff;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
import std.uni : toUpper; import std.uni : toUpper;
debug(std_algorithm) scope(success) debug(std_algorithm) scope(success)
@ -1992,7 +1992,7 @@ if (Ranges.length > 1 && is(typeof(startsWith!pred(haystack, needles))))
import std.algorithm.internal : rndstuff; import std.algorithm.internal : rndstuff;
import std.algorithm.comparison : equal; import std.algorithm.comparison : equal;
import std.range : retro; import std.range : retro;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
debug(std_algorithm) scope(success) debug(std_algorithm) scope(success)
writeln("unittest @", __FILE__, ":", __LINE__, " done."); writeln("unittest @", __FILE__, ":", __LINE__, " done.");
@ -2090,7 +2090,7 @@ $(LREF among) for checking a value against multiple possibilities.
+/ +/
template canFind(alias pred="a == b") template canFind(alias pred="a == b")
{ {
import std.typetuple : allSatisfy; import std.meta : allSatisfy;
/++ /++
Returns $(D true) if and only if any value $(D v) found in the Returns $(D true) if and only if any value $(D v) found in the
@ -2688,7 +2688,7 @@ unittest
unittest unittest
{ {
import std.conv : text; import std.conv : text;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
debug(std_algorithm) scope(success) debug(std_algorithm) scope(success)
writeln("unittest @", __FILE__, ":", __LINE__, " done."); writeln("unittest @", __FILE__, ":", __LINE__, " done.");
@ -3171,7 +3171,7 @@ if (isInputRange!R &&
import std.algorithm.iteration : filter; import std.algorithm.iteration : filter;
import std.conv : to; import std.conv : to;
import std.range; import std.range;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
debug(std_algorithm) scope(success) debug(std_algorithm) scope(success)
writeln("unittest @", __FILE__, ":", __LINE__, " done."); writeln("unittest @", __FILE__, ":", __LINE__, " done.");

2
std/algorithm/setops.d
View file

@ -47,7 +47,7 @@ import std.range.primitives;
import std.functional; // : unaryFun, binaryFun; import std.functional; // : unaryFun, binaryFun;
import std.traits; import std.traits;
// FIXME // FIXME
import std.typetuple; // : TypeTuple, staticMap, allSatisfy, anySatisfy; import std.meta; // : TypeTuple, staticMap, allSatisfy, anySatisfy;
// cartesianProduct // cartesianProduct
/** /**

2
std/array.d
View file

@ -68,7 +68,7 @@ Source: $(PHOBOSSRC std/_array.d)
module std.array; module std.array;
import std.traits; import std.traits;
import std.typetuple; import std.meta;
import std.functional; import std.functional;
static import std.algorithm; // FIXME, remove with alias of splitter static import std.algorithm; // FIXME, remove with alias of splitter

2
std/ascii.d
View file

@ -30,7 +30,7 @@ version (unittest)
// FIXME: When dmd bug #314 is fixed, make these selective. // FIXME: When dmd bug #314 is fixed, make these selective.
import std.range; // : chain; import std.range; // : chain;
import std.traits; // : functionAttributes, FunctionAttribute, isSafe; import std.traits; // : functionAttributes, FunctionAttribute, isSafe;
import std.typetuple; // : TypeTuple; import std.meta; // : TypeTuple;
} }

6
std/bigint.d
View file

@ -1263,7 +1263,7 @@ unittest // 11148
assert(__traits(compiles, foo(cbi))); assert(__traits(compiles, foo(cbi)));
assert(__traits(compiles, foo(ibi))); assert(__traits(compiles, foo(ibi)));
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
import std.conv : to; import std.conv : to;
foreach (T1; TypeTuple!(BigInt, const(BigInt), immutable(BigInt))) foreach (T1; TypeTuple!(BigInt, const(BigInt), immutable(BigInt)))
@ -1343,7 +1343,7 @@ unittest // 13391
BigInt x2 = "123456789123456789"; BigInt x2 = "123456789123456789";
BigInt x3 = "123456789123456789123456789"; BigInt x3 = "123456789123456789123456789";
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong)) foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong))
{ {
assert((x1 * T.max) / T.max == x1); assert((x1 * T.max) / T.max == x1);
@ -1371,7 +1371,7 @@ unittest // 13391
unittest // 13963 unittest // 13963
{ {
BigInt x = 1; BigInt x = 1;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
foreach(Int; TypeTuple!(byte, ubyte, short, ushort, int, uint)) foreach(Int; TypeTuple!(byte, ubyte, short, ushort, int, uint))
{ {
assert(is(typeof(x % Int(1)) == int)); assert(is(typeof(x % Int(1)) == int));

18
std/bitmanip.d
View file

@ -2160,7 +2160,7 @@ private ulong swapEndianImpl(ulong val) @trusted pure nothrow @nogc
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(bool, byte, ubyte, short, ushort, int, uint, long, ulong, char, wchar, dchar)) foreach(T; TypeTuple!(bool, byte, ubyte, short, ushort, int, uint, long, ulong, char, wchar, dchar))
{ {
scope(failure) writefln("Failed type: %s", T.stringof); scope(failure) writefln("Failed type: %s", T.stringof);
@ -2276,7 +2276,7 @@ private auto nativeToBigEndianImpl(T)(T val) @safe pure nothrow @nogc
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(bool, byte, ubyte, short, ushort, int, uint, long, ulong, foreach(T; TypeTuple!(bool, byte, ubyte, short, ushort, int, uint, long, ulong,
char, wchar, dchar char, wchar, dchar
/* The trouble here is with floats and doubles being compared against nan /* The trouble here is with floats and doubles being compared against nan
@ -2450,7 +2450,7 @@ private auto nativeToLittleEndianImpl(T)(T val) @safe pure nothrow @nogc
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(bool, byte, ubyte, short, ushort, int, uint, long, ulong, foreach(T; TypeTuple!(bool, byte, ubyte, short, ushort, int, uint, long, ulong,
char, wchar, dchar/*, char, wchar, dchar/*,
float, double*/)) float, double*/))
@ -2580,7 +2580,7 @@ private template isFloatOrDouble(T)
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(float, double)) foreach(T; TypeTuple!(float, double))
{ {
static assert(isFloatOrDouble!(T)); static assert(isFloatOrDouble!(T));
@ -2609,7 +2609,7 @@ private template canSwapEndianness(T)
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(bool, ubyte, byte, ushort, short, uint, int, ulong, foreach(T; TypeTuple!(bool, ubyte, byte, ushort, short, uint, int, ulong,
long, char, wchar, dchar, float, double)) long, char, wchar, dchar, float, double))
{ {
@ -3700,7 +3700,7 @@ unittest
{ {
import std.format : format; import std.format : format;
import std.array; import std.array;
import std.typetuple; import std.meta;
foreach(endianness; TypeTuple!(Endian.bigEndian, Endian.littleEndian)) foreach(endianness; TypeTuple!(Endian.bigEndian, Endian.littleEndian))
{ {
auto toWrite = appender!(ubyte[])(); auto toWrite = appender!(ubyte[])();
@ -3775,7 +3775,7 @@ unittest
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong)) foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong))
{ {
assert(countTrailingZeros(cast(T)0) == 8 * T.sizeof); assert(countTrailingZeros(cast(T)0) == 8 * T.sizeof);
@ -3856,7 +3856,7 @@ unittest
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong)) foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong))
{ {
assert(countBitsSet(cast(T)0) == 0); assert(countBitsSet(cast(T)0) == 0);
@ -3957,7 +3957,7 @@ unittest
import std.algorithm : equal; import std.algorithm : equal;
import std.range: iota; import std.range: iota;
import std.typetuple; import std.meta;
foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong)) foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong))
{ {
assert(bitsSet(cast(T)0).empty); assert(bitsSet(cast(T)0).empty);

2
std/concurrency.d
View file

@ -81,7 +81,7 @@ private
import std.string; import std.string;
import std.traits; import std.traits;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
template hasLocalAliasing(T...) template hasLocalAliasing(T...)
{ {

2
std/container/package.d
View file

@ -424,7 +424,7 @@ public import std.container.dlist;
public import std.container.rbtree; public import std.container.rbtree;
public import std.container.slist; public import std.container.slist;
import std.typetuple; import std.meta;
/* The following documentation and type $(D TotalContainer) are /* The following documentation and type $(D TotalContainer) are

2
std/container/rbtree.d
View file

@ -635,7 +635,7 @@ final class RedBlackTree(T, alias less = "a < b", bool allowDuplicates = false)
{ {
import std.range.primitives; import std.range.primitives;
import std.range : Take; import std.range : Take;
import std.typetuple : allSatisfy; import std.meta : allSatisfy;
import std.traits; import std.traits;
alias _less = binaryFun!less; alias _less = binaryFun!less;

2
std/conv.d
View file

@ -25,7 +25,7 @@ public import std.ascii : LetterCase;
import std.range.primitives; import std.range.primitives;
import std.traits; import std.traits;
import std.typetuple; import std.meta;
private string convFormat(Char, Args...)(in Char[] fmt, Args args) private string convFormat(Char, Args...)(in Char[] fmt, Args args)
{ {

8
std/datetime.d
View file

@ -31077,7 +31077,7 @@ unittest
import std.range; import std.range;
import std.string; import std.string;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
static struct Rand3Letters static struct Rand3Letters
{ {
@ -31346,7 +31346,7 @@ unittest
import std.range; import std.range;
import std.string; import std.string;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
auto std1 = SysTime(DateTime(2012, 12, 21, 13, 14, 15), UTC()); auto std1 = SysTime(DateTime(2012, 12, 21, 13, 14, 15), UTC());
auto std2 = SysTime(DateTime(2012, 12, 21, 13, 14, 0), UTC()); auto std2 = SysTime(DateTime(2012, 12, 21, 13, 14, 0), UTC());
@ -31672,7 +31672,7 @@ unittest
import std.format : format; import std.format : format;
import std.string; import std.string;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
static string genTest(size_t index) static string genTest(size_t index)
{ {
@ -32800,7 +32800,7 @@ unittest
import std.algorithm; import std.algorithm;
import std.string; import std.string;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
foreach(cr; TypeTuple!(function(string a){return cast(ubyte[])a;}, foreach(cr; TypeTuple!(function(string a){return cast(ubyte[])a;},
function(string a){return map!(b => cast(char)b)(a.representation);})) function(string a){return map!(b => cast(char)b)(a.representation);}))

2
std/digest/digest.d
View file

@ -62,7 +62,7 @@ $(TR $(TDNW Implementation helpers) $(TD $(MYREF digestLength) $(MYREF WrapperDi
module std.digest.digest; module std.digest.digest;
import std.traits; import std.traits;
import std.typetuple : allSatisfy; import std.meta : allSatisfy;
public import std.ascii : LetterCase; public import std.ascii : LetterCase;

2
std/encoding.d
View file

@ -2043,7 +2043,7 @@ unittest
unittest unittest
{ {
import std.range; import std.range;
import std.typetuple; import std.meta;
{ {
import std.conv : to; import std.conv : to;

2
std/exception.d
View file

@ -426,7 +426,7 @@ unittest
// purity and safety inference test // purity and safety inference test
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach (EncloseSafe; TypeTuple!(false, true)) foreach (EncloseSafe; TypeTuple!(false, true))
foreach (EnclosePure; TypeTuple!(false, true)) foreach (EnclosePure; TypeTuple!(false, true))

2
std/file.d
View file

@ -27,7 +27,7 @@ import std.path;
import std.range.primitives; import std.range.primitives;
import std.traits; import std.traits;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
import std.internal.cstring; import std.internal.cstring;
version (Windows) version (Windows)

2
std/format.d
View file

@ -64,7 +64,7 @@ import core.vararg;
import std.exception; import std.exception;
import std.range.primitives; import std.range.primitives;
import std.traits; import std.traits;
import std.typetuple; import std.meta;
version(CRuntime_DigitalMars) version(CRuntime_DigitalMars)
{ {

4
std/functional.d
View file

@ -862,7 +862,7 @@ unittest
unittest unittest
{ {
import std.typetuple : staticMap; import std.meta : staticMap;
import std.typecons : Tuple, tuple; import std.typecons : Tuple, tuple;
alias funs = staticMap!(unaryFun, "a", "a * 2", "a * 3", "a * a", "-a"); alias funs = staticMap!(unaryFun, "a", "a * 2", "a * 3", "a * a", "-a");
alias afun = adjoin!funs; alias afun = adjoin!funs;
@ -1410,7 +1410,7 @@ Forwards function arguments with saving ref-ness.
*/ */
template forward(args...) template forward(args...)
{ {
import std.typetuple; import std.meta;
static if (args.length) static if (args.length)
{ {

2
std/internal/test/dummyrange.d
View file

@ -5,7 +5,7 @@ Used with the dummy ranges for testing higher order ranges.
module std.internal.test.dummyrange; module std.internal.test.dummyrange;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
import std.range.primitives; import std.range.primitives;
enum RangeType enum RangeType

12
std/math.d
View file

@ -539,7 +539,7 @@ auto abs(Num)(Num y) @safe pure nothrow @nogc
@safe pure nothrow @nogc unittest @safe pure nothrow @nogc unittest
{ {
import std.typetuple; import std.meta;
foreach (T; TypeTuple!(float, double, real)) foreach (T; TypeTuple!(float, double, real))
{ {
T f = 3; T f = 3;
@ -2451,7 +2451,7 @@ unittest
unittest unittest
{ {
import std.typetuple, std.typecons; import std.meta, std.typecons;
foreach (T; TypeTuple!(real, double, float)) foreach (T; TypeTuple!(real, double, float))
{ {
@ -2506,7 +2506,7 @@ unittest
unittest unittest
{ {
import std.typetuple: TypeTuple; import std.meta: TypeTuple;
void foo() { void foo() {
foreach (T; TypeTuple!(real, double, float)) foreach (T; TypeTuple!(real, double, float))
{ {
@ -4647,7 +4647,7 @@ bool isNaN(X)(X x) @nogc @trusted pure nothrow
@safe pure nothrow @nogc unittest @safe pure nothrow @nogc unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(float, double, real)) foreach(T; TypeTuple!(float, double, real))
{ {
@ -4810,7 +4810,7 @@ int isSubnormal(X)(X x) @trusted pure nothrow @nogc
/// ///
@safe pure nothrow @nogc unittest @safe pure nothrow @nogc unittest
{ {
import std.typetuple; import std.meta;
foreach (T; TypeTuple!(float, double, real)) foreach (T; TypeTuple!(float, double, real))
{ {
@ -5043,7 +5043,7 @@ R copysign(R, X)(X to, R from) @trusted pure nothrow @nogc
@safe pure nothrow @nogc unittest @safe pure nothrow @nogc unittest
{ {
import std.typetuple; import std.meta;
foreach (X; TypeTuple!(float, double, real, int, long)) foreach (X; TypeTuple!(float, double, real, int, long))
{ {

2
std/net/curl.d
View file

@ -171,7 +171,7 @@ import std.stream;
import std.string; import std.string;
import std.traits; import std.traits;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
import std.internal.cstring; import std.internal.cstring;

14
std/numeric.d
View file

@ -114,7 +114,7 @@ private template CustomFloatParams(uint bits)
private template CustomFloatParams(uint precision, uint exponentWidth, CustomFloatFlags flags) private template CustomFloatParams(uint precision, uint exponentWidth, CustomFloatFlags flags)
{ {
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
alias CustomFloatParams = alias CustomFloatParams =
TypeTuple!( TypeTuple!(
precision, precision,
@ -175,7 +175,7 @@ struct CustomFloat(uint precision, // fraction bits (23 for float)
precision + exponentWidth > 0) precision + exponentWidth > 0)
{ {
import std.bitmanip; import std.bitmanip;
import std.typetuple; import std.meta;
private: private:
// get the correct unsigned bitfield type to support > 32 bits // get the correct unsigned bitfield type to support > 32 bits
template uType(uint bits) template uType(uint bits)
@ -631,7 +631,7 @@ public:
unittest unittest
{ {
import std.typetuple; import std.meta;
alias FPTypes = alias FPTypes =
TypeTuple!( TypeTuple!(
CustomFloat!(5, 10), CustomFloat!(5, 10),
@ -1448,7 +1448,7 @@ euclideanDistance(Range1, Range2, F)(Range1 a, Range2 b, F limit)
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(double, const double, immutable double)) foreach(T; TypeTuple!(double, const double, immutable double))
{ {
T[] a = [ 1.0, 2.0, ]; T[] a = [ 1.0, 2.0, ];
@ -1538,7 +1538,7 @@ dotProduct(F1, F2)(in F1[] avector, in F2[] bvector)
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(double, const double, immutable double)) foreach(T; TypeTuple!(double, const double, immutable double))
{ {
T[] a = [ 1.0, 2.0, ]; T[] a = [ 1.0, 2.0, ];
@ -1582,7 +1582,7 @@ cosineSimilarity(Range1, Range2)(Range1 a, Range2 b)
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(double, const double, immutable double)) foreach(T; TypeTuple!(double, const double, immutable double))
{ {
T[] a = [ 1.0, 2.0, ]; T[] a = [ 1.0, 2.0, ];
@ -1732,7 +1732,7 @@ if (isInputRange!Range &&
unittest unittest
{ {
import std.typetuple; import std.meta;
foreach(T; TypeTuple!(double, const double, immutable double)) foreach(T; TypeTuple!(double, const double, immutable double))
{ {
T[] p = [ 0.0, 0, 0, 1 ]; T[] p = [ 0.0, 0, 0, 1 ];

2
std/parallelism.d
View file

@ -89,7 +89,7 @@ import std.math;
import std.range; import std.range;
import std.traits; import std.traits;
import std.typecons; import std.typecons;
import std.typetuple; import std.meta;
version(OSX) version(OSX)
{ {

2
std/path.d
View file

@ -2691,7 +2691,7 @@ unittest
else version (Posix) valid ~= pfdep; else version (Posix) valid ~= pfdep;
else static assert (0); else static assert (0);
import std.typetuple; import std.meta;
foreach (T; TypeTuple!(char[], const(char)[], string, wchar[], foreach (T; TypeTuple!(char[], const(char)[], string, wchar[],
const(wchar)[], wstring, dchar[], const(dchar)[], dstring)) const(wchar)[], wstring, dchar[], const(dchar)[], dstring))
{ {

24
std/random.d
View file

@ -66,8 +66,8 @@ import std.traits;
version(unittest) version(unittest)
{ {
static import std.typetuple; static import std.meta;
package alias PseudoRngTypes = std.typetuple.TypeTuple!(MinstdRand0, MinstdRand, Mt19937, Xorshift32, Xorshift64, package alias PseudoRngTypes = TypeTuple!(MinstdRand0, MinstdRand, Mt19937, Xorshift32, Xorshift64,
Xorshift96, Xorshift128, Xorshift160, Xorshift192); Xorshift96, Xorshift128, Xorshift160, Xorshift192);
} }
@ -515,7 +515,7 @@ unittest
assert(rnd.front == 399268537); assert(rnd.front == 399268537);
// Check .save works // Check .save works
foreach (Type; std.typetuple.TypeTuple!(MinstdRand0, MinstdRand)) foreach (Type; TypeTuple!(MinstdRand0, MinstdRand))
{ {
auto rnd1 = Type(unpredictableSeed); auto rnd1 = Type(unpredictableSeed);
auto rnd2 = rnd1.save; auto rnd2 = rnd1.save;
@ -788,7 +788,7 @@ unittest
{ {
import std.range; import std.range;
// Check .save works // Check .save works
foreach(Type; std.typetuple.TypeTuple!(Mt19937)) foreach(Type; TypeTuple!(Mt19937))
{ {
auto gen1 = Type(unpredictableSeed); auto gen1 = Type(unpredictableSeed);
auto gen2 = gen1.save; auto gen2 = gen1.save;
@ -806,7 +806,7 @@ unittest
0x9d2c5680, 15, 0x9d2c5680, 15,
0xefc60000, 18); 0xefc60000, 18);
foreach (R; std.typetuple.TypeTuple!(MT!(uint, 32), MT!(ulong, 32), MT!(ulong, 48), MT!(ulong, 64))) foreach (R; TypeTuple!(MT!(uint, 32), MT!(ulong, 32), MT!(ulong, 48), MT!(ulong, 64)))
auto a = R(); auto a = R();
} }
@ -1061,7 +1061,7 @@ unittest
[0UL, 246875399, 3690007200, 1264581005, 3906711041, 1866187943, 2481925219, 2464530826, 1604040631, 3653403911] [0UL, 246875399, 3690007200, 1264581005, 3906711041, 1866187943, 2481925219, 2464530826, 1604040631, 3653403911]
]; ];
alias XorshiftTypes = std.typetuple.TypeTuple!(Xorshift32, Xorshift64, Xorshift96, Xorshift128, Xorshift160, Xorshift192); alias XorshiftTypes = TypeTuple!(Xorshift32, Xorshift64, Xorshift96, Xorshift128, Xorshift160, Xorshift192);
foreach (I, Type; XorshiftTypes) foreach (I, Type; XorshiftTypes)
{ {
@ -1436,7 +1436,7 @@ if ((isIntegral!(CommonType!(T1, T2)) || isSomeChar!(CommonType!(T1, T2))) &&
auto c = uniform(0.0, 1.0); auto c = uniform(0.0, 1.0);
assert(0 <= c && c < 1); assert(0 <= c && c < 1);
foreach (T; std.typetuple.TypeTuple!(char, wchar, dchar, byte, ubyte, short, ushort, foreach (T; TypeTuple!(char, wchar, dchar, byte, ubyte, short, ushort,
int, uint, long, ulong, float, double, real)) int, uint, long, ulong, float, double, real))
{ {
T lo = 0, hi = 100; T lo = 0, hi = 100;
@ -1490,7 +1490,7 @@ if ((isIntegral!(CommonType!(T1, T2)) || isSomeChar!(CommonType!(T1, T2))) &&
auto reproRng = Xorshift(239842); auto reproRng = Xorshift(239842);
foreach (T; std.typetuple.TypeTuple!(char, wchar, dchar, byte, ubyte, short, foreach (T; TypeTuple!(char, wchar, dchar, byte, ubyte, short,
ushort, int, uint, long, ulong)) ushort, int, uint, long, ulong))
{ {
T lo = T.min + 10, hi = T.max - 10; T lo = T.min + 10, hi = T.max - 10;
@ -1609,7 +1609,7 @@ if (!is(T == enum) && (isIntegral!T || isSomeChar!T))
@safe unittest @safe unittest
{ {
foreach(T; std.typetuple.TypeTuple!(char, wchar, dchar, byte, ubyte, short, ushort, foreach(T; TypeTuple!(char, wchar, dchar, byte, ubyte, short, ushort,
int, uint, long, ulong)) int, uint, long, ulong))
{ {
T init = uniform!T(); T init = uniform!T();
@ -1756,11 +1756,11 @@ body
@safe unittest @safe unittest
{ {
import std.typetuple; import std.meta;
foreach (UniformRNG; PseudoRngTypes) foreach (UniformRNG; PseudoRngTypes)
{ {
foreach (T; std.typetuple.TypeTuple!(float, double, real)) foreach (T; TypeTuple!(float, double, real))
(){ // avoid slow optimizations for large functions @@@BUG@@@ 2396 (){ // avoid slow optimizations for large functions @@@BUG@@@ 2396
UniformRNG rng = UniformRNG(unpredictableSeed); UniformRNG rng = UniformRNG(unpredictableSeed);
@ -2199,7 +2199,7 @@ unittest
import std.algorithm; import std.algorithm;
import std.conv; import std.conv;
int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]; int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ];
foreach (UniformRNG; std.typetuple.TypeTuple!(void, PseudoRngTypes)) foreach (UniformRNG; TypeTuple!(void, PseudoRngTypes))
{ {
static if (is(UniformRNG == void)) static if (is(UniformRNG == void))
{ {

2
std/range/interfaces.d
View file

@ -70,7 +70,7 @@ module std.range.interfaces;
import std.range.primitives; import std.range.primitives;
import std.traits; import std.traits;
import std.typetuple; import std.meta;
/**These interfaces are intended to provide virtual function-based wrappers /**These interfaces are intended to provide virtual function-based wrappers
* around input ranges with element type E. This is useful where a well-defined * around input ranges with element type E. This is useful where a well-defined

4
std/range/package.d
View file

@ -175,7 +175,7 @@ public import std.array;
public import std.typecons : Flag, Yes, No; public import std.typecons : Flag, Yes, No;
import std.traits; import std.traits;
import std.typetuple; import std.meta;
/** /**
@ -853,7 +853,7 @@ if (Ranges.length > 0 &&
} }
} }
import std.typetuple : anySatisfy; import std.meta : anySatisfy;
static if (anySatisfy!(isInfinite, R)) static if (anySatisfy!(isInfinite, R))
{ {

8
std/range/primitives.d
View file

@ -512,7 +512,7 @@ unittest
{ {
import std.conv : to; import std.conv : to;
import std.typecons : tuple; import std.typecons : tuple;
import std.typetuple; import std.meta;
static struct PutC(C) static struct PutC(C)
{ {
@ -609,7 +609,7 @@ unittest
unittest unittest
{ {
import std.format; import std.format;
import std.typetuple; import std.meta;
struct PutC(C) struct PutC(C)
{ {
void put(C){} void put(C){}
@ -2055,7 +2055,7 @@ if (isNarrowString!(C[]))
@safe pure unittest @safe pure unittest
{ {
import std.typetuple; import std.meta;
foreach(S; TypeTuple!(string, wstring, dstring)) foreach(S; TypeTuple!(string, wstring, dstring))
{ {
@ -2128,7 +2128,7 @@ if (isNarrowString!(T[]))
@safe pure unittest @safe pure unittest
{ {
import std.typetuple; import std.meta;
foreach(S; TypeTuple!(string, wstring, dstring)) foreach(S; TypeTuple!(string, wstring, dstring))
{ {

2
std/regex/internal/ir.d
View file

@ -9,7 +9,7 @@ module std.regex.internal.ir;
package(std.regex): package(std.regex):
import std.exception, std.uni, std.typetuple, std.traits, std.range; import std.exception, std.uni, std.meta, std.traits, std.range;
// just a common trait, may be moved elsewhere // just a common trait, may be moved elsewhere
alias BasicElementOf(Range) = Unqual!(ElementEncodingType!Range); alias BasicElementOf(Range) = Unqual!(ElementEncodingType!Range);

2
std/regex/internal/parser.d
View file

@ -5,7 +5,7 @@
module std.regex.internal.parser; module std.regex.internal.parser;
import std.regex.internal.ir; import std.regex.internal.ir;
import std.algorithm, std.range, std.uni, std.typetuple, import std.algorithm, std.range, std.uni, std.meta,
std.traits, std.typecons, std.exception; std.traits, std.typecons, std.exception;
// package relevant info from parser into a regex object // package relevant info from parser into a regex object

2
std/regex/internal/tests.d
View file

@ -6,7 +6,7 @@ module std.regex.internal.tests;
package(std.regex): package(std.regex):
import std.algorithm, std.conv, std.exception, std.range, std.typecons, import std.algorithm, std.conv, std.exception, std.range, std.typecons,
std.typetuple, std.regex; std.meta, std.regex;
import std.regex.internal.parser : Escapables; // characters that need escaping import std.regex.internal.parser : Escapables; // characters that need escaping

8
std/stdio.d
View file

@ -1353,7 +1353,7 @@ void main()
{ {
static import std.file; static import std.file;
import std.algorithm : equal; import std.algorithm : equal;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
auto deleteme = testFilename(); auto deleteme = testFilename();
std.file.write(deleteme, "hello\nworld\n"); std.file.write(deleteme, "hello\nworld\n");
@ -1995,7 +1995,7 @@ the contents may well have changed).
std.file.write(deleteme, "hi"); std.file.write(deleteme, "hi");
scope(success) std.file.remove(deleteme); scope(success) std.file.remove(deleteme);
import std.typetuple; import std.meta;
foreach (T; TypeTuple!(char, wchar, dchar)) foreach (T; TypeTuple!(char, wchar, dchar))
{ {
auto blc = File(deleteme).byLine!(T, T); auto blc = File(deleteme).byLine!(T, T);
@ -3491,7 +3491,7 @@ if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum) &&
unittest unittest
{ {
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
//we can't actually test readln, so at the very least, //we can't actually test readln, so at the very least,
//we test compilability //we test compilability
@ -3748,7 +3748,7 @@ struct lines
unittest unittest
{ {
static import std.file; static import std.file;
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
//printf("Entering test at line %d\n", __LINE__); //printf("Entering test at line %d\n", __LINE__);
scope(failure) printf("Failed test at line %d\n", __LINE__); scope(failure) printf("Failed test at line %d\n", __LINE__);

2
std/string.d
View file

@ -162,7 +162,7 @@ import std.typecons : Flag;
import std.range.primitives; import std.range.primitives;
import std.traits; import std.traits;
import std.typetuple; import std.meta;
//public imports for backward compatibility //public imports for backward compatibility
public import std.algorithm : startsWith, endsWith, cmp, count; public import std.algorithm : startsWith, endsWith, cmp, count;

2
std/traits.d
View file

@ -150,7 +150,7 @@
*/ */
module std.traits; module std.traits;
import std.typetuple; import std.meta;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Functions // Functions

16
std/typecons.d
View file

@ -45,7 +45,7 @@ Authors: $(WEB erdani.org, Andrei Alexandrescu),
module std.typecons; module std.typecons;
import std.traits; import std.traits;
// FIXME // FIXME
import std.typetuple; // : TypeTuple, allSatisfy; import std.meta; // : TypeTuple, allSatisfy;
debug(Unique) import std.stdio; debug(Unique) import std.stdio;
@ -418,7 +418,7 @@ Params:
*/ */
template Tuple(Specs...) template Tuple(Specs...)
{ {
import std.typetuple : staticMap; import std.meta : staticMap;
// Parse (type,name) pairs (FieldSpecs) out of the specified // Parse (type,name) pairs (FieldSpecs) out of the specified
// arguments. Some fields would have name, others not. // arguments. Some fields would have name, others not.
@ -960,7 +960,7 @@ unittest
ReverseTupleType!T reverse(T)(T t) ReverseTupleType!T reverse(T)(T t)
if (isTuple!T) if (isTuple!T)
{ {
import std.typetuple : Reverse; import std.meta : Reverse;
// @@@BUG@@@ Cannot be an internal function due to forward reference issues. // @@@BUG@@@ Cannot be an internal function due to forward reference issues.
// @@@BUG@@@ 9929 Need 'this' when calling template with expanded tuple // @@@BUG@@@ 9929 Need 'this' when calling template with expanded tuple
@ -3200,7 +3200,7 @@ private static:
{ {
template Impl(names...) template Impl(names...)
{ {
import std.typetuple : Filter; import std.meta : Filter;
static if (names.length > 0) static if (names.length > 0)
{ {
alias methods = Filter!(pred, MemberFunctionsTuple!(C, names[0])); alias methods = Filter!(pred, MemberFunctionsTuple!(C, names[0]));
@ -3884,7 +3884,7 @@ unittest
template wrap(Targets...) template wrap(Targets...)
if (Targets.length >= 1 && allSatisfy!(isMutable, Targets)) if (Targets.length >= 1 && allSatisfy!(isMutable, Targets))
{ {
import std.typetuple : staticMap; import std.meta : staticMap;
// strict upcast // strict upcast
auto wrap(Source)(inout Source src) @trusted pure nothrow auto wrap(Source)(inout Source src) @trusted pure nothrow
@ -4057,7 +4057,7 @@ if (Targets.length >= 1 && allSatisfy!(isMutable, Targets))
template wrap(Targets...) template wrap(Targets...)
if (Targets.length >= 1 && !allSatisfy!(isMutable, Targets)) if (Targets.length >= 1 && !allSatisfy!(isMutable, Targets))
{ {
import std.typetuple : staticMap; import std.meta : staticMap;
alias wrap = .wrap!(staticMap!(Unqual, Targets)); alias wrap = .wrap!(staticMap!(Unqual, Targets));
} }
@ -4291,7 +4291,7 @@ unittest
// Make a tuple of non-static function symbols // Make a tuple of non-static function symbols
private template GetOverloadedMethods(T) private template GetOverloadedMethods(T)
{ {
import std.typetuple : Filter; import std.meta : Filter;
alias allMembers = TypeTuple!(__traits(allMembers, T)); alias allMembers = TypeTuple!(__traits(allMembers, T));
template follows(size_t i = 0) template follows(size_t i = 0)
@ -4316,7 +4316,7 @@ private template GetOverloadedMethods(T)
enum isMethod = false; enum isMethod = false;
} }
alias follows = TypeTuple!( alias follows = TypeTuple!(
std.typetuple.Filter!(isMethod, __traits(getOverloads, T, name)), Filter!(isMethod, __traits(getOverloads, T, name)),
follows!(i + 1)); follows!(i + 1));
} }
} }

2
std/typelist.d
View file

@ -43,7 +43,7 @@
deprecated("Please use std.typetuple instead. This module will be removed in March 2015.") deprecated("Please use std.typetuple instead. This module will be removed in March 2015.")
module std.typelist; module std.typelist;
version(unittest) { version(unittest) {
import std.typetuple; import std.meta;
} }
/** /**

2
std/uni.d
View file

@ -649,7 +649,7 @@ CLUSTER = $(S_LINK Grapheme cluster, grapheme cluster)
module std.uni; module std.uni;
import core.stdc.stdlib; import core.stdc.stdlib;
import std.traits, std.typetuple; import std.traits, std.meta;
import std.range.primitives; import std.range.primitives;

2
std/uri.d
View file

@ -545,7 +545,7 @@ unittest
result = decode("%41%42%43"); result = decode("%41%42%43");
debug(uri) writeln(result); debug(uri) writeln(result);
import std.typetuple : TypeTuple; import std.meta : TypeTuple;
foreach (StringType; TypeTuple!(char[], wchar[], dchar[], string, wstring, dstring)) foreach (StringType; TypeTuple!(char[], wchar[], dchar[], string, wstring, dstring))
{ {
import std.conv : to; import std.conv : to;

2
std/utf.d
View file

@ -22,7 +22,7 @@ module std.utf;
import std.range.primitives; import std.range.primitives;
import std.traits; // isSomeChar, isSomeString import std.traits; // isSomeChar, isSomeString
import std.typetuple; // TypeTuple import std.meta; // TypeTuple
//debug=utf; // uncomment to turn on debugging printf's //debug=utf; // uncomment to turn on debugging printf's

6
std/uuid.d
View file

@ -126,7 +126,7 @@ import std.traits;
*/ */
public struct UUID public struct UUID
{ {
import std.typetuple : allSatisfy; import std.meta : allSatisfy;
import std.traits : isIntegral; import std.traits : isIntegral;
private: private:
@ -418,7 +418,7 @@ public struct UUID
@safe pure unittest @safe pure unittest
{ {
import std.exception; import std.exception;
import std.typetuple; import std.meta;
import std.conv : to; import std.conv : to;
foreach(S; TypeTuple!(char[], const(char)[], immutable(char)[], foreach(S; TypeTuple!(char[], const(char)[], immutable(char)[],
@ -1355,7 +1355,7 @@ unittest
@safe pure unittest @safe pure unittest
{ {
import std.exception; import std.exception;
import std.typetuple; import std.meta;
import std.conv : to; import std.conv : to;
struct TestRange(bool forward) struct TestRange(bool forward)

2
std/variant.d
View file

@ -66,7 +66,7 @@
module std.variant; module std.variant;
import core.stdc.string, std.conv, std.exception, std.traits, std.typecons, import core.stdc.string, std.conv, std.exception, std.traits, std.typecons,
std.typetuple; std.meta;
/++ /++
Gives the $(D sizeof) the largest type given. Gives the $(D sizeof) the largest type given.