// Written in the D programming language.
/**
* Templates to manipulate template argument lists (also known as type lists).
*
* Some operations on alias sequences are built in to the language,
* such as TL[$(I n)] which gets the $(I n)th type from the
* alias sequence. TL[$(I lwr) .. $(I upr)] returns a new type
* list that is a slice of the old one.
*
* Several templates in this module use or operate on eponymous templates that
* take a single argument and evaluate to a boolean constant. Such templates
* are referred to as $(I template predicates).
*
* $(SCRIPT inhibitQuickIndex = 1;)
* $(DIVC quickindex,
* $(BOOKTABLE ,
* $(TR $(TH Category) $(TH Templates))
* $(TR $(TD Building blocks) $(TD
* $(LREF Alias)
* $(LREF AliasSeq)
* $(LREF aliasSeqOf)
* ))
* $(TR $(TD Alias sequence filtering) $(TD
* $(LREF Erase)
* $(LREF EraseAll)
* $(LREF Filter)
* $(LREF NoDuplicates)
* $(LREF Stride)
* ))
* $(TR $(TD Alias sequence type hierarchy) $(TD
* $(LREF DerivedToFront)
* $(LREF MostDerived)
* ))
* $(TR $(TD Alias sequence transformation) $(TD
* $(LREF Repeat)
* $(LREF Replace)
* $(LREF ReplaceAll)
* $(LREF Reverse)
* $(LREF staticMap)
* $(LREF staticSort)
* ))
* $(TR $(TD Alias sequence searching) $(TD
* $(LREF allSatisfy)
* $(LREF anySatisfy)
* $(LREF staticIndexOf)
* ))
* $(TR $(TD Template predicates) $(TD
* $(LREF templateAnd)
* $(LREF templateNot)
* $(LREF templateOr)
* $(LREF staticIsSorted)
* ))
* $(TR $(TD Template instantiation) $(TD
* $(LREF ApplyLeft)
* $(LREF ApplyRight)
* ))
* ))
*
* References:
* Based on ideas in Table 3.1 from
* $(LINK2 http://amazon.com/exec/obidos/ASIN/0201704315/ref=ase_classicempire/102-2957199-2585768,
* Modern C++ Design),
* Andrei Alexandrescu (Addison-Wesley Professional, 2001)
* Copyright: Copyright Digital Mars 2005 - 2015.
* License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
* Authors:
* $(HTTP digitalmars.com, Walter Bright),
* $(HTTP klickverbot.at, David Nadlinger)
* Source: $(PHOBOSSRC std/_meta.d)
*/
module std.meta;
/**
* Creates a sequence of zero or more aliases. This is most commonly
* used as template parameters or arguments.
*
* In previous versions of Phobos, this was known as `TypeTuple`.
*/
template AliasSeq(TList...)
{
alias AliasSeq = TList;
}
///
@safe unittest
{
import std.meta;
alias TL = AliasSeq!(int, double);
int foo(TL td) // same as int foo(int, double);
{
return td[0] + cast(int) td[1];
}
}
///
@safe unittest
{
alias TL = AliasSeq!(int, double);
alias Types = AliasSeq!(TL, char);
static assert(is(Types == AliasSeq!(int, double, char)));
}
/**
Returns an `AliasSeq` expression of `Func` being
applied to every variadic template argument.
*/
///
@safe unittest
{
auto ref ArgCall(alias Func, alias arg)()
{
return Func(arg);
}
template Map(alias Func, args...)
{
static if (args.length > 1)
{
alias Map = AliasSeq!(ArgCall!(Func, args[0]), Map!(Func, args[1 .. $]));
}
else
{
alias Map = ArgCall!(Func, args[0]);
}
}
static int square(int arg)
{
return arg * arg;
}
static int refSquare(ref int arg)
{
arg *= arg;
return arg;
}
static ref int refRetSquare(ref int arg)
{
arg *= arg;
return arg;
}
static void test(int a, int b)
{
assert(a == 4);
assert(b == 16);
}
static void testRef(ref int a, ref int b)
{
assert(a++ == 16);
assert(b++ == 256);
}
static int a = 2;
static int b = 4;
test(Map!(square, a, b));
test(Map!(refSquare, a, b));
assert(a == 4);
assert(b == 16);
testRef(Map!(refRetSquare, a, b));
assert(a == 17);
assert(b == 257);
}
/**
* Allows `alias`ing of any single symbol, type or compile-time expression.
*
* Not everything can be directly aliased. An alias cannot be declared
* of - for example - a literal:
*
* `alias a = 4; //Error`
*
* With this template any single entity can be aliased:
*
* `alias b = Alias!4; //OK`
*
* See_Also:
* To alias more than one thing at once, use $(LREF AliasSeq)
*/
alias Alias(alias a) = a;
/// Ditto
alias Alias(T) = T;
///
@safe unittest
{
// Without Alias this would fail if Args[0] was e.g. a value and
// some logic would be needed to detect when to use enum instead
alias Head(Args ...) = Alias!(Args[0]);
alias Tail(Args ...) = Args[1 .. $];
alias Blah = AliasSeq!(3, int, "hello");
static assert(Head!Blah == 3);
static assert(is(Head!(Tail!Blah) == int));
static assert((Tail!Blah)[1] == "hello");
}
///
@safe unittest
{
alias a = Alias!(123);
static assert(a == 123);
enum abc = 1;
alias b = Alias!(abc);
static assert(b == 1);
alias c = Alias!(3 + 4);
static assert(c == 7);
alias concat = (s0, s1) => s0 ~ s1;
alias d = Alias!(concat("Hello", " World!"));
static assert(d == "Hello World!");
alias e = Alias!(int);
static assert(is(e == int));
alias f = Alias!(AliasSeq!(int));
static assert(!is(typeof(f[0]))); //not an AliasSeq
static assert(is(f == int));
auto g = 6;
alias h = Alias!g;
++h;
assert(g == 7);
}
package template OldAlias(alias a)
{
static if (__traits(compiles, { alias x = a; }))
alias OldAlias = a;
else static if (__traits(compiles, { enum x = a; }))
enum OldAlias = a;
else
static assert(0, "Cannot alias " ~ a.stringof);
}
import std.traits : isAggregateType, Unqual;
package template OldAlias(T)
if (!isAggregateType!T || is(Unqual!T == T))
{
alias OldAlias = T;
}
@safe unittest
{
static struct Foo {}
static assert(is(OldAlias!(const(Foo)) == Foo));
static assert(is(OldAlias!(const(int)) == const(int)));
static assert(OldAlias!123 == 123);
enum abc = 123;
static assert(OldAlias!abc == 123);
}
/**
* Returns the index of the first occurrence of type T in the
* sequence of zero or more types TList.
* If not found, -1 is returned.
*/
template staticIndexOf(T, TList...)
{
enum staticIndexOf = genericIndexOf!(T, TList).index;
}
/// Ditto
template staticIndexOf(alias T, TList...)
{
enum staticIndexOf = genericIndexOf!(T, TList).index;
}
///
@safe unittest
{
import std.stdio;
void foo()
{
writefln("The index of long is %s",
staticIndexOf!(long, AliasSeq!(int, long, double)));
// prints: The index of long is 1
}
}
// [internal]
private template genericIndexOf(args...)
if (args.length >= 1)
{
alias e = OldAlias!(args[0]);
alias tuple = args[1 .. $];
static if (tuple.length)
{
alias head = OldAlias!(tuple[0]);
alias tail = tuple[1 .. $];
static if (isSame!(e, head))
{
enum index = 0;
}
else
{
enum next = genericIndexOf!(e, tail).index;
enum index = (next == -1) ? -1 : 1 + next;
}
}
else
{
enum index = -1;
}
}
@safe unittest
{
static assert(staticIndexOf!( byte, byte, short, int, long) == 0);
static assert(staticIndexOf!(short, byte, short, int, long) == 1);
static assert(staticIndexOf!( int, byte, short, int, long) == 2);
static assert(staticIndexOf!( long, byte, short, int, long) == 3);
static assert(staticIndexOf!( char, byte, short, int, long) == -1);
static assert(staticIndexOf!( -1, byte, short, int, long) == -1);
static assert(staticIndexOf!(void) == -1);
static assert(staticIndexOf!("abc", "abc", "def", "ghi", "jkl") == 0);
static assert(staticIndexOf!("def", "abc", "def", "ghi", "jkl") == 1);
static assert(staticIndexOf!("ghi", "abc", "def", "ghi", "jkl") == 2);
static assert(staticIndexOf!("jkl", "abc", "def", "ghi", "jkl") == 3);
static assert(staticIndexOf!("mno", "abc", "def", "ghi", "jkl") == -1);
static assert(staticIndexOf!( void, "abc", "def", "ghi", "jkl") == -1);
static assert(staticIndexOf!(42) == -1);
static assert(staticIndexOf!(void, 0, "void", void) == 2);
static assert(staticIndexOf!("void", 0, void, "void") == 2);
}
/**
* Returns an `AliasSeq` created from TList with the first occurrence,
* if any, of T removed.
*/
template Erase(T, TList...)
{
alias Erase = GenericErase!(T, TList).result;
}
/// Ditto
template Erase(alias T, TList...)
{
alias Erase = GenericErase!(T, TList).result;
}
///
@safe unittest
{
alias Types = AliasSeq!(int, long, double, char);
alias TL = Erase!(long, Types);
static assert(is(TL == AliasSeq!(int, double, char)));
}
// [internal]
private template GenericErase(args...)
if (args.length >= 1)
{
alias e = OldAlias!(args[0]);
alias tuple = args[1 .. $] ;
static if (tuple.length)
{
alias head = OldAlias!(tuple[0]);
alias tail = tuple[1 .. $];
static if (isSame!(e, head))
alias result = tail;
else
alias result = AliasSeq!(head, GenericErase!(e, tail).result);
}
else
{
alias result = AliasSeq!();
}
}
@safe unittest
{
static assert(Pack!(Erase!(int,
short, int, int, 4)).
equals!(short, int, 4));
static assert(Pack!(Erase!(1,
real, 3, 1, 4, 1, 5, 9)).
equals!(real, 3, 4, 1, 5, 9));
}
/**
* Returns an `AliasSeq` created from TList with the all occurrences,
* if any, of T removed.
*/
template EraseAll(T, TList...)
{
alias EraseAll = GenericEraseAll!(T, TList).result;
}
/// Ditto
template EraseAll(alias T, TList...)
{
alias EraseAll = GenericEraseAll!(T, TList).result;
}
///
@safe unittest
{
alias Types = AliasSeq!(int, long, long, int);
alias TL = EraseAll!(long, Types);
static assert(is(TL == AliasSeq!(int, int)));
}
// [internal]
private template GenericEraseAll(args...)
if (args.length >= 1)
{
alias e = OldAlias!(args[0]);
alias tuple = args[1 .. $];
static if (tuple.length)
{
alias head = OldAlias!(tuple[0]);
alias tail = tuple[1 .. $];
alias next = AliasSeq!(
GenericEraseAll!(e, tail[0..$/2]).result,
GenericEraseAll!(e, tail[$/2..$]).result
);
static if (isSame!(e, head))
alias result = next;
else
alias result = AliasSeq!(head, next);
}
else
{
alias result = AliasSeq!();
}
}
@safe unittest
{
static assert(Pack!(EraseAll!(int,
short, int, int, 4)).
equals!(short, 4));
static assert(Pack!(EraseAll!(1,
real, 3, 1, 4, 1, 5, 9)).
equals!(real, 3, 4, 5, 9));
}
/**
* Returns an `AliasSeq` created from TList with the all duplicate
* types removed.
*/
template NoDuplicates(TList...)
{
template EraseAllN(uint N, T...)
{
static if (N <= 1)
{
alias EraseAllN = T;
}
else
{
alias EraseAllN = EraseAllN!(N-1, T[1 .. N], EraseAll!(T[0], T[N..$]));
}
}
static if (TList.length > 500)
{
enum steps = 16;
alias first = NoDuplicates!(TList[0 .. steps]);
alias NoDuplicates = NoDuplicates!(EraseAllN!(first.length, first, TList[steps..$]));
}
else static if (TList.length == 0)
{
alias NoDuplicates = TList;
}
else
{
alias NoDuplicates =
AliasSeq!(TList[0], NoDuplicates!(EraseAll!(TList[0], TList[1 .. $])));
}
}
///
@safe unittest
{
alias Types = AliasSeq!(int, long, long, int, float);
alias TL = NoDuplicates!(Types);
static assert(is(TL == AliasSeq!(int, long, float)));
}
@safe unittest
{
// Bugzilla 14561: huge enums
alias LongList = Repeat!(1500, int);
static assert(NoDuplicates!LongList.length == 1);
}
@safe unittest
{
static assert(
Pack!(
NoDuplicates!(1, int, 1, NoDuplicates, int, NoDuplicates, real))
.equals!(1, int, NoDuplicates, real));
}
/**
* Returns an `AliasSeq` created from TList with the first occurrence
* of type T, if found, replaced with type U.
*/
template Replace(T, U, TList...)
{
alias Replace = GenericReplace!(T, U, TList).result;
}
/// Ditto
template Replace(alias T, U, TList...)
{
alias Replace = GenericReplace!(T, U, TList).result;
}
/// Ditto
template Replace(T, alias U, TList...)
{
alias Replace = GenericReplace!(T, U, TList).result;
}
/// Ditto
template Replace(alias T, alias U, TList...)
{
alias Replace = GenericReplace!(T, U, TList).result;
}
///
@safe unittest
{
alias Types = AliasSeq!(int, long, long, int, float);
alias TL = Replace!(long, char, Types);
static assert(is(TL == AliasSeq!(int, char, long, int, float)));
}
// [internal]
private template GenericReplace(args...)
if (args.length >= 2)
{
alias from = OldAlias!(args[0]);
alias to = OldAlias!(args[1]);
alias tuple = args[2 .. $];
static if (tuple.length)
{
alias head = OldAlias!(tuple[0]);
alias tail = tuple[1 .. $];
static if (isSame!(from, head))
alias result = AliasSeq!(to, tail);
else
alias result = AliasSeq!(head,
GenericReplace!(from, to, tail).result);
}
else
{
alias result = AliasSeq!();
}
}
@safe unittest
{
static assert(Pack!(Replace!(byte, ubyte,
short, byte, byte, byte)).
equals!(short, ubyte, byte, byte));
static assert(Pack!(Replace!(1111, byte,
2222, 1111, 1111, 1111)).
equals!(2222, byte, 1111, 1111));
static assert(Pack!(Replace!(byte, 1111,
short, byte, byte, byte)).
equals!(short, 1111, byte, byte));
static assert(Pack!(Replace!(1111, "11",
2222, 1111, 1111, 1111)).
equals!(2222, "11", 1111, 1111));
}
/**
* Returns an `AliasSeq` created from TList with all occurrences
* of type T, if found, replaced with type U.
*/
template ReplaceAll(T, U, TList...)
{
alias ReplaceAll = GenericReplaceAll!(T, U, TList).result;
}
/// Ditto
template ReplaceAll(alias T, U, TList...)
{
alias ReplaceAll = GenericReplaceAll!(T, U, TList).result;
}
/// Ditto
template ReplaceAll(T, alias U, TList...)
{
alias ReplaceAll = GenericReplaceAll!(T, U, TList).result;
}
/// Ditto
template ReplaceAll(alias T, alias U, TList...)
{
alias ReplaceAll = GenericReplaceAll!(T, U, TList).result;
}
///
@safe unittest
{
alias Types = AliasSeq!(int, long, long, int, float);
alias TL = ReplaceAll!(long, char, Types);
static assert(is(TL == AliasSeq!(int, char, char, int, float)));
}
// [internal]
private template GenericReplaceAll(args...)
if (args.length >= 2)
{
alias from = OldAlias!(args[0]);
alias to = OldAlias!(args[1]);
alias tuple = args[2 .. $];
static if (tuple.length)
{
alias head = OldAlias!(tuple[0]);
alias tail = tuple[1 .. $];
alias next = GenericReplaceAll!(from, to, tail).result;
static if (isSame!(from, head))
alias result = AliasSeq!(to, next);
else
alias result = AliasSeq!(head, next);
}
else
{
alias result = AliasSeq!();
}
}
@safe unittest
{
static assert(Pack!(ReplaceAll!(byte, ubyte,
byte, short, byte, byte)).
equals!(ubyte, short, ubyte, ubyte));
static assert(Pack!(ReplaceAll!(1111, byte,
1111, 2222, 1111, 1111)).
equals!(byte, 2222, byte, byte));
static assert(Pack!(ReplaceAll!(byte, 1111,
byte, short, byte, byte)).
equals!(1111, short, 1111, 1111));
static assert(Pack!(ReplaceAll!(1111, "11",
1111, 2222, 1111, 1111)).
equals!("11", 2222, "11", "11"));
}
/**
* Returns an `AliasSeq` created from TList with the order reversed.
*/
template Reverse(TList...)
{
static if (TList.length <= 1)
{
alias Reverse = TList;
}
else
{
alias Reverse =
AliasSeq!(
Reverse!(TList[$/2 .. $ ]),
Reverse!(TList[ 0 .. $/2]));
}
}
///
@safe unittest
{
alias Types = AliasSeq!(int, long, long, int, float);
alias TL = Reverse!(Types);
static assert(is(TL == AliasSeq!(float, int, long, long, int)));
}
/**
* Returns the type from TList that is the most derived from type T.
* If none are found, T is returned.
*/
template MostDerived(T, TList...)
{
static if (TList.length == 0)
alias MostDerived = T;
else static if (is(TList[0] : T))
alias MostDerived = MostDerived!(TList[0], TList[1 .. $]);
else
alias MostDerived = MostDerived!(T, TList[1 .. $]);
}
///
@safe unittest
{
class A { }
class B : A { }
class C : B { }
alias Types = AliasSeq!(A, C, B);
MostDerived!(Object, Types) x; // x is declared as type C
static assert(is(typeof(x) == C));
}
/**
* Returns the `AliasSeq` TList with the types sorted so that the most
* derived types come first.
*/
template DerivedToFront(TList...)
{
static if (TList.length == 0)
alias DerivedToFront = TList;
else
alias DerivedToFront =
AliasSeq!(MostDerived!(TList[0], TList[1 .. $]),
DerivedToFront!(ReplaceAll!(MostDerived!(TList[0], TList[1 .. $]),
TList[0],
TList[1 .. $])));
}
///
@safe unittest
{
class A { }
class B : A { }
class C : B { }
alias Types = AliasSeq!(A, C, B);
alias TL = DerivedToFront!(Types);
static assert(is(TL == AliasSeq!(C, B, A)));
}
/**
Evaluates to $(D AliasSeq!(F!(T[0]), F!(T[1]), ..., F!(T[$ - 1]))).
*/
template staticMap(alias F, T...)
{
static if (T.length == 0)
{
alias staticMap = AliasSeq!();
}
else static if (T.length == 1)
{
alias staticMap = AliasSeq!(F!(T[0]));
}
else
{
alias staticMap =
AliasSeq!(
staticMap!(F, T[ 0 .. $/2]),
staticMap!(F, T[$/2 .. $ ]));
}
}
///
@safe unittest
{
import std.traits : Unqual;
alias TL = staticMap!(Unqual, int, const int, immutable int);
static assert(is(TL == AliasSeq!(int, int, int)));
}
@safe unittest
{
import std.traits : Unqual;
// empty
alias Empty = staticMap!(Unqual);
static assert(Empty.length == 0);
// single
alias Single = staticMap!(Unqual, const int);
static assert(is(Single == AliasSeq!int));
alias T = staticMap!(Unqual, int, const int, immutable int);
static assert(is(T == AliasSeq!(int, int, int)));
}
/**
Tests whether all given items satisfy a template predicate, i.e. evaluates to
$(D F!(T[0]) && F!(T[1]) && ... && F!(T[$ - 1])).
Evaluation is $(I not) short-circuited if a false result is encountered; the
template predicate must be instantiable with all the given items.
*/
template allSatisfy(alias F, T...)
{
static if (T.length == 0)
{
enum allSatisfy = true;
}
else static if (T.length == 1)
{
enum allSatisfy = F!(T[0]);
}
else
{
enum allSatisfy =
allSatisfy!(F, T[ 0 .. $/2]) &&
allSatisfy!(F, T[$/2 .. $ ]);
}
}
///
@safe unittest
{
import std.traits : isIntegral;
static assert(!allSatisfy!(isIntegral, int, double));
static assert( allSatisfy!(isIntegral, int, long));
}
/**
Tests whether any given items satisfy a template predicate, i.e. evaluates to
$(D F!(T[0]) || F!(T[1]) || ... || F!(T[$ - 1])).
Evaluation is short-circuited if a true result is encountered; the
template predicate must be instantiable with one of the given items.
*/
template anySatisfy(alias F, T...)
{
static if (T.length == 0)
{
enum anySatisfy = false;
}
else static if (T.length == 1)
{
enum anySatisfy = F!(T[0]);
}
else
{
enum anySatisfy =
anySatisfy!(F, T[ 0 .. $/2]) ||
anySatisfy!(F, T[$/2 .. $ ]);
}
}
///
@safe unittest
{
import std.traits : isIntegral;
static assert(!anySatisfy!(isIntegral, string, double));
static assert( anySatisfy!(isIntegral, int, double));
}
/**
* Filters an $(D AliasSeq) using a template predicate. Returns a
* $(D AliasSeq) of the elements which satisfy the predicate.
*/
template Filter(alias pred, TList...)
{
static if (TList.length == 0)
{
alias Filter = AliasSeq!();
}
else static if (TList.length == 1)
{
static if (pred!(TList[0]))
alias Filter = AliasSeq!(TList[0]);
else
alias Filter = AliasSeq!();
}
else
{
alias Filter =
AliasSeq!(
Filter!(pred, TList[ 0 .. $/2]),
Filter!(pred, TList[$/2 .. $ ]));
}
}
///
@safe unittest
{
import std.traits : isNarrowString, isUnsigned;
alias Types1 = AliasSeq!(string, wstring, dchar[], char[], dstring, int);
alias TL1 = Filter!(isNarrowString, Types1);
static assert(is(TL1 == AliasSeq!(string, wstring, char[])));
alias Types2 = AliasSeq!(int, byte, ubyte, dstring, dchar, uint, ulong);
alias TL2 = Filter!(isUnsigned, Types2);
static assert(is(TL2 == AliasSeq!(ubyte, uint, ulong)));
}
@safe unittest
{
import std.traits : isPointer;
static assert(is(Filter!(isPointer, int, void*, char[], int*) == AliasSeq!(void*, int*)));
static assert(is(Filter!isPointer == AliasSeq!()));
}
// Used in template predicate unit tests below.
private version (unittest)
{
template testAlways(T...)
{
enum testAlways = true;
}
template testNever(T...)
{
enum testNever = false;
}
template testError(T...)
{
static assert(false, "Should never be instantiated.");
}
}
/**
* Negates the passed template predicate.
*/
template templateNot(alias pred)
{
enum templateNot(T...) = !pred!T;
}
///
@safe unittest
{
import std.traits : isPointer;
alias isNoPointer = templateNot!isPointer;
static assert(!isNoPointer!(int*));
static assert(allSatisfy!(isNoPointer, string, char, float));
}
@safe unittest
{
foreach (T; AliasSeq!(int, staticMap, 42))
{
static assert(!Instantiate!(templateNot!testAlways, T));
static assert(Instantiate!(templateNot!testNever, T));
}
}
/**
* Combines several template predicates using logical AND, i.e. constructs a new
* predicate which evaluates to true for a given input T if and only if all of
* the passed predicates are true for T.
*
* The predicates are evaluated from left to right, aborting evaluation in a
* short-cut manner if a false result is encountered, in which case the latter
* instantiations do not need to compile.
*/
template templateAnd(Preds...)
{
template templateAnd(T...)
{
static if (Preds.length == 0)
{
enum templateAnd = true;
}
else
{
static if (Instantiate!(Preds[0], T))
alias templateAnd = Instantiate!(.templateAnd!(Preds[1 .. $]), T);
else
enum templateAnd = false;
}
}
}
///
@safe unittest
{
import std.traits : isNumeric, isUnsigned;
alias storesNegativeNumbers = templateAnd!(isNumeric, templateNot!isUnsigned);
static assert(storesNegativeNumbers!int);
static assert(!storesNegativeNumbers!string && !storesNegativeNumbers!uint);
// An empty list of predicates always yields true.
alias alwaysTrue = templateAnd!();
static assert(alwaysTrue!int);
}
@safe unittest
{
foreach (T; AliasSeq!(int, staticMap, 42))
{
static assert( Instantiate!(templateAnd!(), T));
static assert( Instantiate!(templateAnd!(testAlways), T));
static assert( Instantiate!(templateAnd!(testAlways, testAlways), T));
static assert(!Instantiate!(templateAnd!(testNever), T));
static assert(!Instantiate!(templateAnd!(testAlways, testNever), T));
static assert(!Instantiate!(templateAnd!(testNever, testAlways), T));
static assert(!Instantiate!(templateAnd!(testNever, testError), T));
static assert(!is(typeof(Instantiate!(templateAnd!(testAlways, testError), T))));
}
}
/**
* Combines several template predicates using logical OR, i.e. constructs a new
* predicate which evaluates to true for a given input T if and only at least
* one of the passed predicates is true for T.
*
* The predicates are evaluated from left to right, aborting evaluation in a
* short-cut manner if a true result is encountered, in which case the latter
* instantiations do not need to compile.
*/
template templateOr(Preds...)
{
template templateOr(T...)
{
static if (Preds.length == 0)
{
enum templateOr = false;
}
else
{
static if (Instantiate!(Preds[0], T))
enum templateOr = true;
else
alias templateOr = Instantiate!(.templateOr!(Preds[1 .. $]), T);
}
}
}
///
@safe unittest
{
import std.traits : isPointer, isUnsigned;
alias isPtrOrUnsigned = templateOr!(isPointer, isUnsigned);
static assert( isPtrOrUnsigned!uint && isPtrOrUnsigned!(short*));
static assert(!isPtrOrUnsigned!int && !isPtrOrUnsigned!(string));
// An empty list of predicates never yields true.
alias alwaysFalse = templateOr!();
static assert(!alwaysFalse!int);
}
@safe unittest
{
foreach (T; AliasSeq!(int, staticMap, 42))
{
static assert( Instantiate!(templateOr!(testAlways), T));
static assert( Instantiate!(templateOr!(testAlways, testAlways), T));
static assert( Instantiate!(templateOr!(testAlways, testNever), T));
static assert( Instantiate!(templateOr!(testNever, testAlways), T));
static assert(!Instantiate!(templateOr!(), T));
static assert(!Instantiate!(templateOr!(testNever), T));
static assert( Instantiate!(templateOr!(testAlways, testError), T));
static assert( Instantiate!(templateOr!(testNever, testAlways, testError), T));
// DMD @@BUG@@: Assertion fails for int, seems like a error gagging
// problem. The bug goes away when removing some of the other template
// instantiations in the module.
// static assert(!is(typeof(Instantiate!(templateOr!(testNever, testError), T))));
}
}
/**
* Converts an input range $(D range) to an alias sequence.
*/
template aliasSeqOf(alias range)
{
import std.traits : isArray, isNarrowString;
alias ArrT = typeof(range);
static if (isArray!ArrT && !isNarrowString!ArrT)
{
static if (range.length == 0)
{
alias aliasSeqOf = AliasSeq!();
}
else static if (range.length == 1)
{
alias aliasSeqOf = AliasSeq!(range[0]);
}
else
{
alias aliasSeqOf = AliasSeq!(aliasSeqOf!(range[0 .. $/2]), aliasSeqOf!(range[$/2 .. $]));
}
}
else
{
import std.range.primitives : isInputRange;
static if (isInputRange!ArrT)
{
import std.array : array;
alias aliasSeqOf = aliasSeqOf!(array(range));
}
else
{
static assert(false, "Cannot transform range of type " ~ ArrT.stringof ~ " into a AliasSeq.");
}
}
}
///
@safe unittest
{
import std.algorithm.iteration : map;
import std.algorithm.sorting : sort;
import std.string : capitalize;
struct S
{
int a;
int c;
int b;
}
alias capMembers = aliasSeqOf!([__traits(allMembers, S)].sort().map!capitalize());
static assert(capMembers[0] == "A");
static assert(capMembers[1] == "B");
static assert(capMembers[2] == "C");
}
///
@safe unittest
{
static immutable REF = [0, 1, 2, 3];
foreach (I, V; aliasSeqOf!([0, 1, 2, 3]))
{
static assert(V == I);
static assert(V == REF[I]);
}
}
@safe unittest
{
import std.conv : to, octal;
import std.range : iota;
//Testing compile time octal
foreach (I2; aliasSeqOf!(iota(0, 8)))
foreach (I1; aliasSeqOf!(iota(0, 8)))
{
enum oct = I2 * 8 + I1;
enum dec = I2 * 10 + I1;
enum str = to!string(dec);
static assert(octal!dec == oct);
static assert(octal!str == oct);
}
}
@safe unittest
{
enum REF = "日本語"d;
foreach (I, V; aliasSeqOf!"日本語"c)
{
static assert(V == REF[I]);
}
}
/**
* $(LINK2 http://en.wikipedia.org/wiki/Partial_application, Partially applies)
* $(D_PARAM Template) by binding its first (left) or last (right) arguments
* to $(D_PARAM args).
*
* Behaves like the identity function when $(D_PARAM args) is empty.
* Params:
* Template = template to partially apply
* args = arguments to bind
* Returns:
* _Template with arity smaller than or equal to $(D_PARAM Template)
*/
template ApplyLeft(alias Template, args...)
{
alias ApplyLeft(right...) = SmartAlias!(Template!(args, right));
}
/// Ditto
template ApplyRight(alias Template, args...)
{
alias ApplyRight(left...) = SmartAlias!(Template!(left, args));
}
///
@safe unittest
{
// enum bool isImplicitlyConvertible(From, To)
import std.traits : isImplicitlyConvertible;
static assert(allSatisfy!(
ApplyLeft!(isImplicitlyConvertible, ubyte),
short, ushort, int, uint, long, ulong));
static assert(is(Filter!(ApplyRight!(isImplicitlyConvertible, short),
ubyte, string, short, float, int) == AliasSeq!(ubyte, short)));
}
///
@safe unittest
{
import std.traits : hasMember, ifTestable;
struct T1
{
bool foo;
}
struct T2
{
struct Test
{
bool opCast(T : bool)() { return true; }
}
Test foo;
}
static assert(allSatisfy!(ApplyRight!(hasMember, "foo"), T1, T2));
static assert(allSatisfy!(ApplyRight!(ifTestable, a => a.foo), T1, T2));
}
///
@safe unittest
{
import std.traits : Largest;
alias Types = AliasSeq!(byte, short, int, long);
static assert(is(staticMap!(ApplyLeft!(Largest, short), Types) ==
AliasSeq!(short, short, int, long)));
static assert(is(staticMap!(ApplyLeft!(Largest, int), Types) ==
AliasSeq!(int, int, int, long)));
}
///
@safe unittest
{
import std.traits : FunctionAttribute, SetFunctionAttributes;
static void foo() @system;
static int bar(int) @system;
alias SafeFunctions = AliasSeq!(
void function() @safe,
int function(int) @safe);
static assert(is(staticMap!(ApplyRight!(
SetFunctionAttributes, "D", FunctionAttribute.safe),
typeof(&foo), typeof(&bar)) == SafeFunctions));
}
private template SmartAlias(T...)
{
static if (T.length == 1)
{
alias SmartAlias = Alias!T;
}
else
{
alias SmartAlias = AliasSeq!T;
}
}
@safe unittest
{
static assert(is(typeof({
alias T(T0, int a, double b, alias T1, string c) = AliasSeq!(T0, a, b, T1, c);
alias T0 = ApplyRight!(ApplyLeft, ApplyRight);
alias T1 = T0!ApplyLeft;
alias T2 = T1!T;
alias T3 = T2!(3, "foo");
alias T4 = T3!(short, 3, 3.3);
static assert(Pack!T4.equals!(short, 3, 3.3, 3, "foo"));
import std.traits : isImplicitlyConvertible;
alias U1 = ApplyLeft!(ApplyRight, isImplicitlyConvertible);
alias U2 = U1!int;
enum U3 = U2!short;
static assert(U3);
})));
}
/**
* Creates an `AliasSeq` which repeats a type or an `AliasSeq` exactly `n` times.
*/
template Repeat(size_t n, TList...)
if (n > 0)
{
static if (n == 1)
{
alias Repeat = AliasSeq!TList;
}
else static if (n == 2)
{
alias Repeat = AliasSeq!(TList, TList);
}
else
{
alias R = Repeat!((n - 1) / 2, TList);
static if ((n - 1) % 2 == 0)
{
alias Repeat = AliasSeq!(TList, R, R);
}
else
{
alias Repeat = AliasSeq!(TList, TList, R, R);
}
}
}
///
@safe unittest
{
alias ImInt1 = Repeat!(1, immutable(int));
static assert(is(ImInt1 == AliasSeq!(immutable(int))));
alias Real3 = Repeat!(3, real);
static assert(is(Real3 == AliasSeq!(real, real, real)));
alias Real12 = Repeat!(4, Real3);
static assert(is(Real12 == AliasSeq!(real, real, real, real, real, real,
real, real, real, real, real, real)));
alias Composite = AliasSeq!(uint, int);
alias Composite2 = Repeat!(2, Composite);
static assert(is(Composite2 == AliasSeq!(uint, int, uint, int)));
}
///
@safe unittest
{
auto staticArray(T, size_t n)(Repeat!(n, T) elems)
{
T[n] a = [elems];
return a;
}
auto a = staticArray!(long, 3)(3, 1, 4);
assert(is(typeof(a) == long[3]));
assert(a == [3, 1, 4]);
}
/**
* Sorts a $(LREF AliasSeq) using $(D cmp).
*
* Parameters:
* cmp = A template that returns a $(D bool) (if its first argument is less than the second one)
* or an $(D int) (-1 means less than, 0 means equal, 1 means greater than)
*
* Seq = The $(LREF AliasSeq) to sort
*
* Returns: The sorted alias sequence
*/
template staticSort(alias cmp, Seq...)
{
static if (Seq.length < 2)
{
alias staticSort = Seq;
}
else
{
private alias btm = staticSort!(cmp, Seq[0 .. $ / 2]);
private alias top = staticSort!(cmp, Seq[$ / 2 .. $]);
static if (isLessEq!(cmp, btm[$ - 1], top[0]))
alias staticSort = AliasSeq!(btm, top); // already ascending
else static if (isLessEq!(cmp, top[$ - 1], btm[0]))
alias staticSort = AliasSeq!(top, btm); // already descending
else
alias staticSort = staticMerge!(cmp, Seq.length / 2, btm, top);
}
}
///
@safe unittest
{
alias Nums = AliasSeq!(7, 2, 3, 23);
enum Comp(int N1, int N2) = N1 < N2;
static assert(AliasSeq!(2, 3, 7, 23) == staticSort!(Comp, Nums));
}
///
@safe unittest
{
alias Types = AliasSeq!(uint, short, ubyte, long, ulong);
enum Comp(T1, T2) = __traits(isUnsigned, T2) - __traits(isUnsigned, T1);
static assert(is(AliasSeq!(uint, ubyte, ulong, short, long) == staticSort!(Comp,
Types)));
}
private template staticMerge(alias cmp, int half, Seq...)
{
static if (half == 0 || half == Seq.length)
{
alias staticMerge = Seq;
}
else
{
static if (isLessEq!(cmp, Seq[0], Seq[half]))
{
alias staticMerge = AliasSeq!(Seq[0],
staticMerge!(cmp, half - 1, Seq[1 .. $]));
}
else
{
alias staticMerge = AliasSeq!(Seq[half],
staticMerge!(cmp, half, Seq[0 .. half], Seq[half + 1 .. $]));
}
}
}
private template isLessEq(alias cmp, Seq...)
if (Seq.length == 2)
{
private enum Result = cmp!(Seq[1], Seq[0]);
static if (is(typeof(Result) == bool))
enum isLessEq = !Result;
else static if (is(typeof(Result) : int))
enum isLessEq = Result >= 0;
else
static assert(0, typeof(Result).stringof ~ " is not a value comparison type");
}
/**
* Checks if an $(LREF AliasSeq) is sorted according to $(D cmp).
*
* Parameters:
* cmp = A template that returns a $(D bool) (if its first argument is less than the second one)
* or an $(D int) (-1 means less than, 0 means equal, 1 means greater than)
*
* Seq = The $(LREF AliasSeq) to check
*
* Returns: `true` if `Seq` is sorted; otherwise `false`
*/
template staticIsSorted(alias cmp, Seq...)
{
static if (Seq.length <= 1)
enum staticIsSorted = true;
else static if (Seq.length == 2)
enum staticIsSorted = isLessEq!(cmp, Seq[0], Seq[1]);
else
{
enum staticIsSorted =
isLessEq!(cmp, Seq[($ / 2) - 1], Seq[$ / 2]) &&
staticIsSorted!(cmp, Seq[0 .. $ / 2]) &&
staticIsSorted!(cmp, Seq[$ / 2 .. $]);
}
}
///
@safe unittest
{
enum Comp(int N1, int N2) = N1 < N2;
static assert( staticIsSorted!(Comp, 2, 2));
static assert( staticIsSorted!(Comp, 2, 3, 7, 23));
static assert(!staticIsSorted!(Comp, 7, 2, 3, 23));
}
///
@safe unittest
{
enum Comp(T1, T2) = __traits(isUnsigned, T2) - __traits(isUnsigned, T1);
static assert( staticIsSorted!(Comp, uint, ubyte, ulong, short, long));
static assert(!staticIsSorted!(Comp, uint, short, ubyte, long, ulong));
}
/**
Selects a subset of the argument list by stepping with fixed `stepSize` over the list.
A negative `stepSize` starts iteration with the last list element.
Params:
stepSize = Number of elements to increment on each iteration. Can't be `0`.
Args = Template arguments
Returns: A template argument list filtered by the selected stride.
*/
template Stride(int stepSize, Args...)
if (stepSize != 0)
{
static if (Args.length == 0)
{
alias Stride = AliasSeq!();
}
else static if (stepSize > 0)
{
static if (stepSize >= Args.length)
alias Stride = AliasSeq!(Args[0]);
else
alias Stride = AliasSeq!(Args[0], Stride!(stepSize, Args[stepSize .. $]));
}
else
{
static if (-stepSize >= Args.length)
alias Stride = AliasSeq!(Args[$ - 1]);
else
alias Stride = AliasSeq!(Args[$ - 1], Stride!(stepSize, Args[0 .. $ + stepSize]));
}
}
///
@safe unittest
{
static assert(is(Stride!(1, short, int, long) == AliasSeq!(short, int, long)));
static assert(is(Stride!(2, short, int, long) == AliasSeq!(short, long)));
static assert(is(Stride!(-1, short, int, long) == AliasSeq!(long, int, short)));
static assert(is(Stride!(-2, short, int, long) == AliasSeq!(long, short)));
alias attribs = AliasSeq!(short, int, long, ushort, uint, ulong);
static assert(is(Stride!(3, attribs) == AliasSeq!(short, ushort)));
static assert(is(Stride!(3, attribs[1 .. $]) == AliasSeq!(int, uint)));
static assert(is(Stride!(-3, attribs) == AliasSeq!(ulong, long)));
}
@safe unittest
{
static assert(Pack!(Stride!(5, int)).equals!(int));
static assert(Pack!(Stride!(-5, int)).equals!(int));
static assert(!__traits(compiles, Stride!(0, int)));
}
// : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : //
private:
/*
* [internal] Returns true if a and b are the same thing, or false if
* not. Both a and b can be types, literals, or symbols.
*
* How: When:
* is(a == b) - both are types
* a == b - both are literals (true literals, enums)
* __traits(isSame, a, b) - other cases (variables, functions,
* templates, etc.)
*/
private template isSame(ab...)
if (ab.length == 2)
{
static if (__traits(compiles, expectType!(ab[0]),
expectType!(ab[1])))
{
enum isSame = is(ab[0] == ab[1]);
}
else static if (!__traits(compiles, expectType!(ab[0])) &&
!__traits(compiles, expectType!(ab[1])) &&
__traits(compiles, expectBool!(ab[0] == ab[1])))
{
static if (!__traits(compiles, &ab[0]) ||
!__traits(compiles, &ab[1]))
enum isSame = (ab[0] == ab[1]);
else
enum isSame = __traits(isSame, ab[0], ab[1]);
}
else
{
enum isSame = __traits(isSame, ab[0], ab[1]);
}
}
private template expectType(T) {}
private template expectBool(bool b) {}
@safe unittest
{
static assert( isSame!(int, int));
static assert(!isSame!(int, short));
enum a = 1, b = 1, c = 2, s = "a", t = "a";
static assert( isSame!(1, 1));
static assert( isSame!(a, 1));
static assert( isSame!(a, b));
static assert(!isSame!(b, c));
static assert( isSame!("a", "a"));
static assert( isSame!(s, "a"));
static assert( isSame!(s, t));
static assert(!isSame!(1, "1"));
static assert(!isSame!(a, "a"));
static assert( isSame!(isSame, isSame));
static assert(!isSame!(isSame, a));
static assert(!isSame!(byte, a));
static assert(!isSame!(short, isSame));
static assert(!isSame!(a, int));
static assert(!isSame!(long, isSame));
static immutable X = 1, Y = 1, Z = 2;
static assert( isSame!(X, X));
static assert(!isSame!(X, Y));
static assert(!isSame!(Y, Z));
int foo();
int bar();
real baz(int);
static assert( isSame!(foo, foo));
static assert(!isSame!(foo, bar));
static assert(!isSame!(bar, baz));
static assert( isSame!(baz, baz));
static assert(!isSame!(foo, 0));
int x, y;
real z;
static assert( isSame!(x, x));
static assert(!isSame!(x, y));
static assert(!isSame!(y, z));
static assert( isSame!(z, z));
static assert(!isSame!(x, 0));
}
/*
* [internal] Confines a tuple within a template.
*/
private template Pack(T...)
{
alias tuple = T;
// For convenience
template equals(U...)
{
static if (T.length == U.length)
{
static if (T.length == 0)
enum equals = true;
else
enum equals = isSame!(T[0], U[0]) &&
Pack!(T[1 .. $]).equals!(U[1 .. $]);
}
else
{
enum equals = false;
}
}
}
@safe unittest
{
static assert( Pack!(1, int, "abc").equals!(1, int, "abc"));
static assert(!Pack!(1, int, "abc").equals!(1, int, "cba"));
}
/*
* Instantiates the given template with the given list of parameters.
*
* Used to work around syntactic limitations of D with regard to instantiating
* a template from an alias sequence (e.g. T[0]!(...) is not valid) or a template
* returning another template (e.g. Foo!(Bar)!(Baz) is not allowed).
*/
// TODO: Consider publicly exposing this, maybe even if only for better
// understandability of error messages.
alias Instantiate(alias Template, Params...) = Template!Params;