Move memory functions into memory.lifecycle

- move
- moveEmplace
- forward
- emplace
- swap

4 files changed, 0 insertions, 5972 deletions

diff --git a/meta/source/tanya/meta/metafunction.d b/meta/source/tanya/meta/metafunction.d
deleted file mode 100644
index 6da6b47..0000000
--- a/meta/source/tanya/meta/metafunction.d
+++ /dev/null
@@ -1,1862 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * This module is suited for computations on template arguments, both types and
- * values at compile time.
- *
- * It contains different algorithms for iterating, searching and modifying
- * template arguments.
- *
- * Copyright: Eugene Wissner 2017-2018.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/meta/metafunction.d,
- *                 tanya/meta/metafunction.d)
- */
-module tanya.meta.metafunction;
-
-import tanya.meta.trait;
-import tanya.meta.transform;
-
-/**
- * Finds the minimum value in $(D_PARAM Args) according to $(D_PARAM pred).
- *
- * $(D_PARAM Args) should contain at least one element.
- *
- * $(D_PARAM pred) can evaluate to:
- * $(UL
- *  $(LI $(D_KEYWORD bool): $(D_KEYWORD true) means
- *       $(D_INLINECODE Args[0] < Args[1]).)
- *  $(LI $(D_KEYWORD int): a negative number means that
- *       $(D_INLINECODE Args[0] < Args[1]), a positive number that
- *       $(D_INLINECODE Args[0] > Args[1]), `0` if they equal.)
- * )
- * 
- * Params:
- *  pred = Template predicate.
- *  Args = Elements for which you want to find the minimum value.
- *
- * Returns: The minimum.
- *
- * See_Also: $(D_PSYMBOL isLess).
- */
-template Min(alias pred, Args...)
-if (Args.length > 0 && __traits(isTemplate, pred))
-{
-    static if (Args.length == 1)
-    {
-        alias Min = Alias!(Args[0]);
-    }
-    else static if (isLess!(pred, Args[1], Args[0]))
-    {
-        alias Min = Min!(pred, Args[1], Args[2 .. $]);
-    }
-    else
-    {
-        alias Min = Min!(pred, Args[0], Args[2 .. $]);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum bool cmp(alias T, alias U) = T < U;
-    static assert(Min!(cmp, 8, 4, 5, 3, 13) == 3);
-    static assert(Min!(cmp, 8) == 8);
-}
-
-/**
- * Finds the maximum value in $(D_PARAM Args) according to $(D_PARAM pred).
- *
- * $(D_PARAM Args) should contain at least one element.
- *
- * $(D_PARAM pred) can evaluate to:
- * $(UL
- *  $(LI $(D_KEYWORD bool): $(D_KEYWORD true) means
- *       $(D_INLINECODE Args[0] < Args[1]).)
- *  $(LI $(D_KEYWORD int): a negative number means that
- *       $(D_INLINECODE Args[0] < Args[1]), a positive number that
- *       $(D_INLINECODE Args[0] > Args[1]), `0` if they equal.)
- * )
- * 
- * Params:
- *  pred = Template predicate.
- *  Args = Elements for which you want to find the maximum value.
- *
- * Returns: The maximum.
- *
- * See_Also: $(D_PSYMBOL isLess).
- */
-template Max(alias pred, Args...)
-if (Args.length > 0 && __traits(isTemplate, pred))
-{
-    static if (Args.length == 1)
-    {
-        alias Max = Alias!(Args[0]);
-    }
-    else static if (isGreater!(pred, Args[1], Args[0]))
-    {
-        alias Max = Max!(pred, Args[1], Args[2 .. $]);
-    }
-    else
-    {
-        alias Max = Max!(pred, Args[0], Args[2 .. $]);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum bool cmp(alias T, alias U) = T < U;
-    static assert(Max!(cmp, 8, 4, 5, 3, 13) == 13);
-    static assert(Max!(cmp, 8) == 8);
-}
-
-/**
- * Zips one or more $(D_PSYMBOL Pack)s with $(D_PARAM f).
- *
- * Given $(D_PARAM f) and tuples t1, t2, ..., tk, where tk[i] denotes the
- * $(I i)-th element of the tuple $(I k)-th tuple, $(D_PSYMBOL ZipWith)
- * produces a sequence:
- *
- * ---
- * f(t1[0], t2[0], ... tk[0]),
- * f(t1[1], t2[1], ... tk[1]),
- * ...
- * f(tk[0], tk[1], ... tk[i]),
- * ---
- *
- * $(D_PSYMBOL ZipWith) begins with the first elements from $(D_PARAM Packs)
- * and applies $(D_PARAM f) to them, then it takes the second
- * ones and does the same, and so on.
- *
- * If not all argument tuples have the same length, $(D_PSYMBOL ZipWith) will
- * zip only `n` elements from each tuple, where `n` is the length of the
- * shortest tuple in the argument list. Remaining elements in the longer tuples
- * are just ignored.
- *
- * Params:
- *  f      = Some template that can be applied to the elements of
- *           $(D_PARAM Packs).
- *  Packs  = $(D_PSYMBOL Pack) instances.
- *
- * Returns: A sequence, whose $(I i)-th element contains the $(I i)-th element
- *          from each of the $(D_PARAM Packs).
- */
-template ZipWith(alias f, Packs...)
-if (Packs.length > 0
- && __traits(isTemplate, f)
- && (allSatisfy!(ApplyLeft!(isInstanceOf, Pack), Packs)
- || allSatisfy!(ApplyLeft!(isInstanceOf, Tuple), Packs)))
-{
-    private template GetIth(size_t i, Args...)
-    {
-        static if ((Args.length == 0) || (Args[0].Seq.length <= i))
-        {
-            alias GetIth = AliasSeq!();
-        }
-        else
-        {
-            alias GetIth = AliasSeq!(Args[0].Seq[i], GetIth!(i, Args[1 .. $]));
-        }
-    }
-    private template Iterate(size_t i, Args...)
-    {
-        alias Pack = GetIth!(i, Args);
-
-        static if (Pack.length < Packs.length)
-        {
-            alias Iterate = AliasSeq!();
-        }
-        else
-        {
-            alias Iterate = AliasSeq!(f!Pack, Iterate!(i + 1, Args));
-        }
-    }
-    alias ZipWith = Iterate!(0, Packs);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias Result1 = ZipWith!(AliasSeq, Pack!(1, 2), Pack!(5, 6), Pack!(9, 10));
-    static assert(Result1 == AliasSeq!(1, 5, 9, 2, 6, 10));
-
-    alias Result2 = ZipWith!(AliasSeq, Pack!(1, 2, 3), Pack!(4, 5));
-    static assert(Result2 == AliasSeq!(1, 4, 2, 5));
-
-    alias Result3 = ZipWith!(AliasSeq, Pack!(), Pack!(4, 5));
-    static assert(Result3.length == 0);
-}
-
-/**
- * Holds a typed sequence of template parameters.
- *
- * Different than $(D_PSYMBOL AliasSeq), $(D_PSYMBOL Pack) doesn't unpack
- * its template parameters automatically. Consider:
- *
- * ---
- * template A(Args...)
- * {
- *  static assert(Args.length == 4);
- * }
- *
- * alias AInstance = A!(AliasSeq!(int, uint), AliasSeq!(float, double));
- * ---
- *
- * Using $(D_PSYMBOL AliasSeq) template `A` gets 4 parameters instead of 2,
- * because $(D_PSYMBOL AliasSeq) is just an alias for its template parameters.
- *
- * With $(D_PSYMBOL Pack) it is possible to pass distinguishable
- * sequences of parameters to a template. So:
- *
- * ---
- * template B(Args...)
- * {
- *  static assert(Args.length == 2);
- * }
- *
- * alias BInstance = B!(Pack!(int, uint), Pack!(float, double));
- * ---
- *
- * Params:
- *  Args = Elements of this $(D_PSYMBOL Pack).
- *
- * See_Also: $(D_PSYMBOL AliasSeq).
- */
-struct Pack(Args...)
-{
-    /// Elements in this tuple as $(D_PSYMBOL AliasSeq).
-    alias Seq = Args;
-
-    /// The length of the tuple.
-    enum size_t length = Args.length;
-
-    alias Seq this;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias A = Pack!short;
-    alias B = Pack!(3, 8, 9);
-    alias C = Pack!(A, B);
-
-    static assert(C.length == 2);
-
-    static assert(A.length == 1);
-    static assert(is(A.Seq == AliasSeq!short));
-    static assert(B.length == 3);
-    static assert(B.Seq == AliasSeq!(3, 8, 9));
-
-    alias D = Pack!();
-    static assert(D.length == 0);
-    static assert(is(D.Seq == AliasSeq!()));
-}
-
-/**
- * Unordered sequence of unique aliases.
- *
- * $(D_PARAM Args) can contain duplicates, but they will be filtered out, so
- * $(D_PSYMBOL Set) contains only unique items. $(D_PSYMBOL isEqual) is used
- * for determining if two items are equal.
- *
- * Params:
- *  Args = Elements of this $(D_PSYMBOL Set).
- */
-struct Set(Args...)
-{
-    /// Elements in this set as $(D_PSYMBOL AliasSeq).
-    alias Seq = NoDuplicates!Args;
-
-    /// The length of the set.
-    enum size_t length = Seq.length;
-
-    alias Seq this;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias S1 = Set!(int, 5, 5, int, 4);
-    static assert(S1.length == 3);
-}
-
-/**
- * Produces a $(D_PSYMBOL Set) containing all elements of the given
- * $(D_PARAM Sets).
- *
- * Params:
- *  Sets = List of $(D_PSYMBOL Set) instances.
- *
- * Returns: Set-theoretic union of all $(D_PARAM Sets).
- *
- * See_Also: $(D_PSYMBOL Set).
- */
-template Union(Sets...)
-if (allSatisfy!(ApplyLeft!(isInstanceOf, Set), Sets))
-{
-    private template Impl(Sets...)
-    {
-        static if (Sets.length == 0)
-        {
-            alias Impl = AliasSeq!();
-        }
-        else
-        {
-            alias Impl = AliasSeq!(Sets[0].Seq, Impl!(Sets[1 .. $]));
-        }
-    }
-    alias Union = Set!(Impl!Sets);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias S1 = Set!(2, 5, 8, 4);
-    alias S2 = Set!(3, 8, 4, 1);
-    static assert(Union!(S1, S2).Seq == AliasSeq!(2, 5, 8, 4, 3, 1));
-}
-
-/**
- * Produces a $(D_PSYMBOL Set) that containing elements of
- * $(D_INLINECODE Sets[0]) that are also elements of all other sets in
- * $(D_PARAM Sets).
- *
- * Params:
- *  Sets = List of $(D_PSYMBOL Set) instances.
- *
- * Returns: Set-theoretic intersection of all $(D_PARAM Sets).
- *
- * See_Also: $(D_PSYMBOL Set).
- */
-template Intersection(Sets...)
-if (allSatisfy!(ApplyLeft!(isInstanceOf, Set), Sets))
-{
-    private template Impl(Args...)
-    if (Args.length > 0)
-    {
-        alias Equal = ApplyLeft!(isEqual, Args[0]);
-        static if (Args.length == 1)
-        {
-            enum bool Impl = true;
-        }
-        else static if (!anySatisfy!(Equal, Args[1].Seq))
-        {
-            enum bool Impl = false;
-        }
-        else
-        {
-            enum bool Impl = Impl!(Args[0], Args[2 .. $]);
-        }
-    }
-
-    private enum bool FilterImpl(Args...) = Impl!(Args[0], Sets[1 .. $]);
-
-    static if (Sets.length == 0)
-    {
-        alias Intersection = Set!();
-    }
-    else
-    {
-        alias Intersection = Set!(Filter!(FilterImpl, Sets[0].Seq));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias S1 = Set!(2, 5, 8, 4);
-    alias S2 = Set!(3, 8, 4, 1);
-    static assert(Intersection!(S1, S2).Seq == AliasSeq!(8, 4));
-
-    static assert(Intersection!(S1).Seq == AliasSeq!(2, 5, 8, 4));
-    static assert(Intersection!().length == 0);
-}
-
-/**
- * Produces a $(D_PSYMBOL Set) that contains all elements of
- * $(D_PARAM S1) that are not members of $(D_PARAM S2).
- *
- * Params:
- *  S1 = A $(D_PSYMBOL Set).
- *  S2 = A $(D_PSYMBOL Set).
- *
- * Returns: Set-theoretic difference of two sets $(D_PARAM S1) and
- *          $(D_PARAM S2).
- *
- * See_Also: $(D_PSYMBOL Set).
- */
-template Difference(alias S1, alias S2)
-if (isInstanceOf!(Set, S1) && isInstanceOf!(Set, S2))
-{
-    private template Impl(Args...)
-    {
-        alias Equal = ApplyLeft!(isEqual, Args[0]);
-        enum bool Impl = !anySatisfy!(Equal, S2.Seq);
-    }
-
-    static if (S1.length == 0)
-    {
-        alias Difference = Set!();
-    }
-    else static if (S2.length == 1)
-    {
-        alias Difference = S1;
-    }
-    else
-    {
-        alias Difference = Set!(Filter!(Impl, S1.Seq));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias S1 = Set!(2, 5, 8, 4);
-    alias S2 = Set!(3, 8, 4, 1);
-    static assert(Difference!(S1, S2).Seq == AliasSeq!(2, 5));
-    static assert(Difference!(S2, S1).Seq == AliasSeq!(3, 1));
-    static assert(Difference!(S1, Set!()).Seq == AliasSeq!(2, 5, 8, 4));
-}
-
-/**
- * Tests whether $(D_INLINECODE Args[0]) is less than or equal to
- * $(D_INLINECODE Args[1]) according to $(D_PARAM cmp).
- *
- * $(D_PARAM cmp) can evaluate to:
- * $(UL
- *  $(LI $(D_KEYWORD bool): $(D_KEYWORD true) means
- *       $(D_INLINECODE Args[0] < Args[1]).)
- *  $(LI $(D_KEYWORD int): a negative number means that
- *       $(D_INLINECODE Args[0] < Args[1]), a positive number that
- *       $(D_INLINECODE Args[0] > Args[1]), `0` if they equal.)
- * )
- *
- * Params:
- *  Args = Two aliases to compare for equality.
- *
- * Returns: $(D_KEYWORD true) if $(D_INLINECODE Args[0]) is less than or equal
- *          to $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
- */
-template isLessEqual(alias cmp, Args...)
-if (Args.length == 2 && __traits(isTemplate, cmp))
-{
-    private enum result = cmp!(Args[1], Args[0]);
-    static if (is(typeof(result) == bool))
-    {
-        enum bool isLessEqual = !result;
-    }
-    else
-    {
-        enum bool isLessEqual = result >= 0;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum bool boolCmp(T, U) = T.sizeof < U.sizeof;
-    static assert(isLessEqual!(boolCmp, byte, int));
-    static assert(isLessEqual!(boolCmp, uint, int));
-    static assert(!isLessEqual!(boolCmp, long, int));
-
-    enum ptrdiff_t intCmp(T, U) = T.sizeof - U.sizeof;
-    static assert(isLessEqual!(intCmp, byte, int));
-    static assert(isLessEqual!(intCmp, uint, int));
-    static assert(!isLessEqual!(intCmp, long, int));
-}
-
-/**
- * Tests whether $(D_INLINECODE Args[0]) is greater than or equal to
- * $(D_INLINECODE Args[1]) according to $(D_PARAM cmp).
- *
- * $(D_PARAM cmp) can evaluate to:
- * $(UL
- *  $(LI $(D_KEYWORD bool): $(D_KEYWORD true) means
- *       $(D_INLINECODE Args[0] < Args[1]).)
- *  $(LI $(D_KEYWORD int): a negative number means that
- *       $(D_INLINECODE Args[0] < Args[1]), a positive number that
- *       $(D_INLINECODE Args[0] > Args[1]), `0` if they equal.)
- * )
- *
- * Params:
- *  Args = Two aliases to compare for equality.
- *
- * Returns: $(D_KEYWORD true) if $(D_INLINECODE Args[0]) is greater than or
- *          equal to $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
- */
-template isGreaterEqual(alias cmp, Args...)
-if (Args.length == 2 && __traits(isTemplate, cmp))
-{
-    private enum result = cmp!Args;
-    static if (is(typeof(result) == bool))
-    {
-        enum bool isGreaterEqual = !result;
-    }
-    else
-    {
-        enum bool isGreaterEqual = result >= 0;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum bool boolCmp(T, U) = T.sizeof < U.sizeof;
-    static assert(!isGreaterEqual!(boolCmp, byte, int));
-    static assert(isGreaterEqual!(boolCmp, uint, int));
-    static assert(isGreaterEqual!(boolCmp, long, int));
-
-    enum ptrdiff_t intCmp(T, U) = T.sizeof - U.sizeof;
-    static assert(!isGreaterEqual!(intCmp, byte, int));
-    static assert(isGreaterEqual!(intCmp, uint, int));
-    static assert(isGreaterEqual!(intCmp, long, int));
-}
-
-/**
- * Tests whether $(D_INLINECODE Args[0]) is less than
- * $(D_INLINECODE Args[1]) according to $(D_PARAM cmp).
- *
- * $(D_PARAM cmp) can evaluate to:
- * $(UL
- *  $(LI $(D_KEYWORD bool): $(D_KEYWORD true) means
- *       $(D_INLINECODE Args[0] < Args[1]).)
- *  $(LI $(D_KEYWORD int): a negative number means that
- *       $(D_INLINECODE Args[0] < Args[1]), a positive number that
- *       $(D_INLINECODE Args[0] > Args[1]), `0` if they equal.)
- * )
- *
- * Params:
- *  Args = Two aliases to compare for equality.
- *
- * Returns: $(D_KEYWORD true) if $(D_INLINECODE Args[0]) is less than
- *          $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
- */
-template isLess(alias cmp, Args...)
-if (Args.length == 2 && __traits(isTemplate, cmp))
-{
-    private enum result = cmp!Args;
-    static if (is(typeof(result) == bool))
-    {
-        enum bool isLess = result;
-    }
-    else
-    {
-        enum bool isLess = result < 0;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum bool boolCmp(T, U) = T.sizeof < U.sizeof;
-    static assert(isLess!(boolCmp, byte, int));
-    static assert(!isLess!(boolCmp, uint, int));
-    static assert(!isLess!(boolCmp, long, int));
-
-    enum ptrdiff_t intCmp(T, U) = T.sizeof - U.sizeof;
-    static assert(isLess!(intCmp, byte, int));
-    static assert(!isLess!(intCmp, uint, int));
-    static assert(!isLess!(intCmp, long, int));
-}
-
-/**
- * Tests whether $(D_INLINECODE Args[0]) is greater than
- * $(D_INLINECODE Args[1]) according to $(D_PARAM cmp).
- *
- * $(D_PARAM cmp) can evaluate to:
- * $(UL
- *  $(LI $(D_KEYWORD bool): $(D_KEYWORD true) means
- *       $(D_INLINECODE Args[0] < Args[1]).)
- *  $(LI $(D_KEYWORD int): a negative number means that
- *       $(D_INLINECODE Args[0] < Args[1]), a positive number that
- *       $(D_INLINECODE Args[0] > Args[1]), `0` if they equal.)
- * )
- *
- * Params:
- *  Args = Two aliases to compare for equality.
- *
- * Returns: $(D_KEYWORD true) if $(D_INLINECODE Args[0]) is greater than
- *          $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
- */
-template isGreater(alias cmp, Args...)
-if (Args.length == 2 && __traits(isTemplate, cmp))
-{
-    private enum result = cmp!Args;
-    static if (is(typeof(result) == bool))
-    {
-        enum bool isGreater = !result && cmp!(Args[1], Args[0]);
-    }
-    else
-    {
-        enum bool isGreater = result > 0;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum bool boolCmp(T, U) = T.sizeof < U.sizeof;
-    static assert(!isGreater!(boolCmp, byte, int));
-    static assert(!isGreater!(boolCmp, uint, int));
-    static assert(isGreater!(boolCmp, long, int));
-
-    enum ptrdiff_t intCmp(T, U) = T.sizeof - U.sizeof;
-    static assert(!isGreater!(intCmp, byte, int));
-    static assert(!isGreater!(intCmp, uint, int));
-    static assert(isGreater!(intCmp, long, int));
-}
-
-/**
- * Tests whether $(D_INLINECODE Args[0]) is equal to $(D_INLINECODE Args[1]).
- *
- * $(D_PSYMBOL isEqual) checks first if $(D_PARAM Args) can be compared directly. If not, they are compared as types:
- * $(D_INLINECODE is(Args[0] == Args[1])). It it fails, the arguments are
- * considered to be not equal.
- *
- * If two items cannot be compared (for example comparing a type with a
- * number), they are considered not equal.
- *
- * Params:
- *  Args = Two aliases to compare for equality.
- *
- * Returns: $(D_KEYWORD true) if $(D_INLINECODE Args[0]) is equal to
- *          $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
- */
-template isEqual(Args...)
-if (Args.length == 2)
-{
-    static if ((is(typeof(Args[0] == Args[1])) && (Args[0] == Args[1]))
-            || (isTypeTuple!Args && is(Args[0] == Args[1]))
-            || __traits(isSame, Args[0], Args[1]))
-    {
-        enum bool isEqual = true;
-    }
-    else
-    {
-        enum bool isEqual = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isEqual!(int, int));
-    static assert(isEqual!(8, 8));
-    static assert(!isEqual!(int, const(int)));
-    static assert(!isEqual!(5, int));
-    static assert(!isEqual!(5, 8));
-}
-
-/**
- * Tests whether $(D_INLINECODE Args[0]) isn't equal to
- * $(D_INLINECODE Args[1]).
- *
- * $(D_PSYMBOL isNotEqual) checks first if $(D_PARAM Args) can be compared directly. If not, they are compared as types:
- * $(D_INLINECODE is(Args[0] == Args[1])). It it fails, the arguments are
- * considered to be not equal.
- *
- * Params:
- *  Args = Two aliases to compare for equality.
- *
- * Returns: $(D_KEYWORD true) if $(D_INLINECODE Args[0]) isn't equal to
- *          $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
- */
-template isNotEqual(Args...)
-if (Args.length == 2)
-{
-    enum bool isNotEqual = !isEqual!Args;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(!isNotEqual!(int, int));
-    static assert(isNotEqual!(5, int));
-    static assert(isNotEqual!(5, 8));
-}
-
-/**
- * Instantiates the template $(D_PARAM T) with $(D_PARAM Args).
- *
- * Params:
- *  T    = Template.
- *  Args = Template parameters.
- *
- * Returns: Instantiated template.
- */
-alias Instantiate(alias T, Args...) = T!Args;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    template Template(T)
-    {
-        alias Template = T;
-    }
-    alias Seq = AliasSeq!(Template, Template);
-
-    alias Instance1 = Instantiate!(Seq[0], int);
-    static assert(is(Instance1 == int));
-
-    alias Instance2 = Instantiate!(Seq[1], float);
-    static assert(is(Instance2 == float));
-}
-
-/**
- * Creates an alias for $(D_PARAM T).
- *
- * In contrast to the $(D_KEYWORD alias)-keyword $(D_PSYMBOL Alias) can alias
- * any kind of D symbol that can be used as argument to template alias
- * parameters.
- *
- * $(UL
- *  $(LI Types)
- *  $(LI Local and global names)
- *  $(LI Module names)
- *  $(LI Template names)
- *  $(LI Template instance names)
- *  $(LI Literals)
- * )
- *
- * Params:
- *  T = A symbol.
- *
- * Returns: An alias for $(D_PARAM T).
- *
- * See_Also: $(LINK2 https://dlang.org/spec/template.html#aliasparameters,
- *                   Template Alias Parameters).
- */
-alias Alias(alias T) = T;
-
-/// ditto
-alias Alias(T) = T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Alias!int));
-
-    static assert(is(typeof(Alias!5)));
-    static assert(is(typeof(Alias!(() {}))));
-
-    int i;
-    static assert(is(typeof(Alias!i)));
-}
-
-/**
- * Holds a sequence of aliases.
- *
- * $(D_PSYMBOL AliasSeq) can be used to pass multiple parameters to a template
- * at once. $(D_PSYMBOL AliasSeq) behaves as it were just $(D_PARAM Args). Note
- * that because of this property, if multiple instances of
- * $(D_PSYMBOL AliasSeq) are passed to a template, they are not distinguishable
- * from each other and act as a single sequence. There is also no way to make
- * $(D_PSYMBOL AliasSeq) nested, it always unpacks its elements.
- *
- * Params:
- *  Args = Symbol sequence.
- *
- * Returns: An alias for sequence $(D_PARAM Args).
- *
- * See_Also: $(D_PSYMBOL Alias).
- */
-alias AliasSeq(Args...) = Args;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(typeof({ alias T = AliasSeq!(short, 5); })));
-    static assert(is(typeof({ alias T = AliasSeq!(int, short, 5); })));
-    static assert(is(typeof({ alias T = AliasSeq!(() {}, short, 5); })));
-    static assert(is(typeof({ alias T = AliasSeq!(); })));
-
-    static assert(AliasSeq!().length == 0);
-    static assert(AliasSeq!(int, short, 5).length == 3);
-
-    alias A = AliasSeq!(short, float);
-    alias B = AliasSeq!(ushort, double);
-    alias C = AliasSeq!(A, B);
-    static assert(C.length == 4);
-}
-
-/**
- * Tests whether all the items of $(D_PARAM L) satisfy the condition
- * $(D_PARAM F).
- *
- * $(D_PARAM F) is a template that accepts one parameter and returns a boolean,
- * so $(D_INLINECODE F!([0]) && F!([1])) and so on, can be called.
- *
- * Params:
- *  F = Template predicate. 
- *  L = List of items to test.
- *
- * Returns: $(D_KEYWORD true) if all the items of $(D_PARAM L) satisfy
- *          $(D_PARAM F), $(D_KEYWORD false) otherwise.
- */
-template allSatisfy(alias F, L...)
-if (__traits(isTemplate, F))
-{
-    static if (L.length == 0)
-    {
-        enum bool allSatisfy = true;
-    }
-    else static if (F!(L[0]))
-    {
-        enum bool allSatisfy = allSatisfy!(F, L[1 .. $]);
-    }
-    else
-    {
-        enum bool allSatisfy = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(allSatisfy!(isSigned, int, short, byte, long));
-    static assert(!allSatisfy!(isUnsigned, uint, ushort, float, ulong));
-}
-
-/**
- * Tests whether any of the items of $(D_PARAM L) satisfy the condition
- * $(D_PARAM F).
- *
- * $(D_PARAM F) is a template that accepts one parameter and returns a boolean,
- * so $(D_INLINECODE F!([0]) && F!([1])) and so on, can be called.
- *
- * Params:
- *  F = Template predicate. 
- *  L = List of items to test.
- *
- * Returns: $(D_KEYWORD true) if any of the items of $(D_PARAM L) satisfy
- *          $(D_PARAM F), $(D_KEYWORD false) otherwise.
- */
-template anySatisfy(alias F, L...)
-if (__traits(isTemplate, F))
-{
-    static if (L.length == 0)
-    {
-        enum bool anySatisfy = false;
-    }
-    else static if (F!(L[0]))
-    {
-        enum bool anySatisfy = true;
-    }
-    else
-    {
-        enum bool anySatisfy = anySatisfy!(F, L[1 .. $]);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(anySatisfy!(isSigned, int, short, byte, long));
-    static assert(anySatisfy!(isUnsigned, uint, ushort, float, ulong));
-    static assert(!anySatisfy!(isSigned, uint, ushort, ulong));
-}
-
-private template indexOf(ptrdiff_t i, Args...)
-if (Args.length > 0)
-{
-    static if (Args.length == 1)
-    {
-        enum ptrdiff_t indexOf = -1;
-    }
-    else static if (isEqual!(Args[0 .. 2]))
-    {
-        enum ptrdiff_t indexOf = i;
-    }
-    else
-    {
-        enum ptrdiff_t indexOf = indexOf!(i + 1,
-                                          AliasSeq!(Args[0], Args[2 .. $]));
-    }
-}
-
-/**
- * Returns the index of the first occurrence of $(D_PARAM T) in $(D_PARAM L).
- * `-1` is returned if $(D_PARAM T) is not found.
- *
- * Params:
- *  T = The item to search for.
- *  L = Symbol sequence.
- *
- * Returns: The index of the first occurrence of $(D_PARAM T) in $(D_PARAM L).
- */
-template staticIndexOf(T, L...)
-{
-    enum ptrdiff_t staticIndexOf = indexOf!(0, AliasSeq!(T, L));
-}
-
-/// ditto
-template staticIndexOf(alias T, L...)
-{
-    enum ptrdiff_t staticIndexOf = indexOf!(0, AliasSeq!(T, L));
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(staticIndexOf!(int) == -1);
-    static assert(staticIndexOf!(int, int) == 0);
-    static assert(staticIndexOf!(int, float, double, int, real) == 2);
-    static assert(staticIndexOf!(3, () {}, uint, 5, 3) == 3);
-}
-
-/**
- * Looks for $(D_PARAM T) in $(D_PARAM L) and returns $(D_KEYWORD true) if it
- * could be found and $(D_KEYWORD false) otherwise.
- *
- * Params:
- *  T = The item to search for.
- *  L = Symbol sequence.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) can be found in $(D_PARAM L),
- *          $(D_KEYWORD false) otherwise.
- */
-template canFind(T, L...)
-{
-    enum bool canFind = indexOf!(0, AliasSeq!(T, L)) != -1;
-}
-
-/// ditto
-template canFind(alias T, L...)
-{
-    enum bool canFind = indexOf!(0, AliasSeq!(T, L)) != -1;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(!canFind!(int));
-    static assert(canFind!(int, int));
-    static assert(canFind!(int, float, double, int, real));
-    static assert(canFind!(3, () {}, uint, 5, 3));
-}
-
-/*
- * Tests whether $(D_PARAM T) is a template.
- *
- * $(D_PSYMBOL isTemplate) isn't $(D_KEYWORD true) for template instances,
- * since the latter already represent some type. Only not instantiated
- * templates, i.e. that accept some template parameters, are considered
- * templates.
- *
- * Params:
- *  T = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a template,
- *          $(D_KEYWORD false) otherwise.
- */
-private enum bool isTemplate(alias T) = __traits(isTemplate, T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S(T)
-    {
-    }
-    static assert(isTemplate!S);
-    static assert(!isTemplate!(S!int));
-}
-
-/**
- * Combines multiple templates with logical AND. So $(D_PSYMBOL templateAnd)
- * evaluates to $(D_INLINECODE Preds[0] && Preds[1] && Preds[2]) and so on.
- *
- * Empty $(D_PARAM Preds) evaluates to $(D_KEYWORD true).
- *
- * Params:
- *  Preds = Template predicates.
- *
- * Returns: The constructed template.
- */
-template templateAnd(Preds...)
-if (allSatisfy!(isTemplate, Preds))
-{
-    template templateAnd(T...)
-    {
-        static if (Preds.length == 0)
-        {
-            enum bool templateAnd = true;
-        }
-        else static if (Instantiate!(Preds[0], T))
-        {
-            alias templateAnd = Instantiate!(.templateAnd!(Preds[1 .. $]), T);
-        }
-        else
-        {
-            enum bool templateAnd = false;
-        }
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias isMutableInt = templateAnd!(isIntegral, isMutable);
-    static assert(isMutableInt!int);
-    static assert(!isMutableInt!(const int));
-    static assert(!isMutableInt!float);
-
-    alias alwaysTrue = templateAnd!();
-    static assert(alwaysTrue!int);
-
-    alias isIntegral = templateAnd!(.isIntegral);
-    static assert(isIntegral!int);
-    static assert(isIntegral!(const int));
-    static assert(!isIntegral!float);
-}
-
-/**
- * Combines multiple templates with logical OR. So $(D_PSYMBOL templateOr)
- * evaluates to $(D_INLINECODE Preds[0] || Preds[1] || Preds[2]) and so on.
- *
- * Empty $(D_PARAM Preds) evaluates to $(D_KEYWORD false).
- *
- * Params:
- *  Preds = Template predicates.
- *
- * Returns: The constructed template.
- */
-template templateOr(Preds...)
-if (allSatisfy!(isTemplate, Preds))
-{
-    template templateOr(T...)
-    {
-        static if (Preds.length == 0)
-        {
-            enum bool templateOr = false;
-        }
-        else static if (Instantiate!(Preds[0], T))
-        {
-            enum bool templateOr = true;
-        }
-        else
-        {
-            alias templateOr = Instantiate!(.templateOr!(Preds[1 .. $]), T);
-        }
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias isMutableOrInt = templateOr!(isIntegral, isMutable);
-    static assert(isMutableOrInt!int);
-    static assert(isMutableOrInt!(const int));
-    static assert(isMutableOrInt!float);
-    static assert(!isMutableOrInt!(const float));
-
-    alias alwaysFalse = templateOr!();
-    static assert(!alwaysFalse!int);
-
-    alias isIntegral = templateOr!(.isIntegral);
-    static assert(isIntegral!int);
-    static assert(isIntegral!(const int));
-    static assert(!isIntegral!float);
-}
-
-/**
- * Params:
- *  pred = Template predicate.
- *
- * Returns: Negated $(D_PARAM pred).
- */
-template templateNot(alias pred)
-if (__traits(isTemplate, pred))
-{
-    enum bool templateNot(T...) = !pred!T;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias isNotIntegral = templateNot!isIntegral;
-    static assert(!isNotIntegral!int);
-    static assert(isNotIntegral!(char[]));
-}
-
-/**
- * Tests whether $(D_PARAM L) is sorted in ascending order according to
- * $(D_PARAM cmp).
- *
- * $(D_PARAM cmp) can evaluate to:
- * $(UL
- *  $(LI $(D_KEYWORD bool): $(D_KEYWORD true) means
- *       $(D_INLINECODE a[i] < a[i + 1]).)
- *  $(LI $(D_KEYWORD int): a negative number means that
- *       $(D_INLINECODE a[i] < a[i + 1]), a positive number that
- *       $(D_INLINECODE a[i] > a[i + 1]), `0` if they equal.)
- * )
- *
- * Params:
- *  cmp = Sorting template predicate.
- *  L   = Elements to be tested.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM L) is sorted, $(D_KEYWORD false)
- *          if not.
- */
-template isSorted(alias cmp, L...)
-if (__traits(isTemplate, cmp))
-{
-    static if (L.length <= 1)
-    {
-        enum bool isSorted = true;
-    }
-    else
-    {
-        // `L` is sorted if the both halves and the boundary values are sorted.
-        enum bool isSorted = isLessEqual!(cmp, L[$ / 2 - 1], L[$ / 2])
-                          && isSorted!(cmp, L[0 .. $ / 2])
-                          && isSorted!(cmp, L[$ / 2 .. $]);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum cmp(T, U) = T.sizeof < U.sizeof;
-    static assert(isSorted!(cmp));
-    static assert(isSorted!(cmp, byte));
-    static assert(isSorted!(cmp, byte, ubyte, short, uint));
-    static assert(!isSorted!(cmp, long, byte, ubyte, short, uint));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    enum cmp(int x, int y) = x - y;
-    static assert(isSorted!(cmp));
-    static assert(isSorted!(cmp, 1));
-    static assert(isSorted!(cmp, 1, 2, 2));
-    static assert(isSorted!(cmp, 1, 2, 2, 4));
-    static assert(isSorted!(cmp, 1, 2, 2, 4, 8));
-    static assert(!isSorted!(cmp, 32, 2, 2, 4, 8));
-    static assert(isSorted!(cmp, 32, 32));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    enum cmp(int x, int y) = x < y;
-    static assert(isSorted!(cmp));
-    static assert(isSorted!(cmp, 1));
-    static assert(isSorted!(cmp, 1, 2, 2));
-    static assert(isSorted!(cmp, 1, 2, 2, 4));
-    static assert(isSorted!(cmp, 1, 2, 2, 4, 8));
-    static assert(!isSorted!(cmp, 32, 2, 2, 4, 8));
-    static assert(isSorted!(cmp, 32, 32));
-}
-
-/**
- * Params:
- *  T    = A template.
- *  Args = The first arguments for $(D_PARAM T).
- *
- * Returns: $(D_PARAM T) with $(D_PARAM Args) applied to it as its first
- *          arguments.
- */
-template ApplyLeft(alias T, Args...)
-{
-    alias ApplyLeft(U...) = T!(Args, U);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias allAreIntegral = ApplyLeft!(allSatisfy, isIntegral);
-    static assert(allAreIntegral!(int, uint));
-    static assert(!allAreIntegral!(int, float, uint));
-}
-
-/**
- * Params:
- *  T    = A template.
- *  Args = The last arguments for $(D_PARAM T).
- *
- * Returns: $(D_PARAM T) with $(D_PARAM Args) applied to it as itslast
- *          arguments.
- */
-template ApplyRight(alias T, Args...)
-{
-    alias ApplyRight(U...) = T!(U, Args);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias intIs = ApplyRight!(allSatisfy, int);
-    static assert(intIs!(isIntegral));
-    static assert(!intIs!(isUnsigned));
-}
-
-/**
- * Params:
- *  n = The number of times to repeat $(D_PARAM L).
- *  L = The sequence to be repeated.
- *
- * Returns: $(D_PARAM L) repeated $(D_PARAM n) times.
- */
-template Repeat(size_t n, L...)
-if (n > 0)
-{
-    static if (n == 1)
-    {
-        alias Repeat = L;
-    }
-    else
-    {
-        alias Repeat = AliasSeq!(L, Repeat!(n - 1, L));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Repeat!(1, uint, int) == AliasSeq!(uint, int)));
-    static assert(is(Repeat!(2, uint, int) == AliasSeq!(uint, int, uint, int)));
-    static assert(is(Repeat!(3) == AliasSeq!()));
-}
-
-private template ReplaceOne(L...)
-{
-    static if (L.length == 2)
-    {
-        alias ReplaceOne = AliasSeq!();
-    }
-    else static if (isEqual!(L[0], L[2]))
-    {
-        alias ReplaceOne = AliasSeq!(L[1], L[3 .. $]);
-    }
-    else
-    {
-        alias ReplaceOne = AliasSeq!(L[2], ReplaceOne!(L[0], L[1], L[3 .. $]));
-    }
-}
-
-/**
- * Replaces the first occurrence of $(D_PARAM T) in $(D_PARAM L) with
- * $(D_PARAM U).
- *
- * Params:
- *  T = The symbol to be replaced.
- *  U = Replacement.
- *  L = List of symbols.
- *
- * Returns: $(D_PARAM L) with the first occurrence of $(D_PARAM T) replaced.
- */
-template Replace(T, U, L...)
-{
-    alias Replace = ReplaceOne!(T, U, L);
-}
-
-/// ditto
-template Replace(alias T, U, L...)
-{
-    alias Replace = ReplaceOne!(T, U, L);
-}
-
-/// ditto
-template Replace(T, alias U, L...)
-{
-    alias Replace = ReplaceOne!(T, U, L);
-}
-
-/// ditto
-template Replace(alias T, alias U, L...)
-{
-    alias Replace = ReplaceOne!(T, U, L);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Replace!(int, uint, int) == AliasSeq!(uint)));
-    static assert(is(Replace!(int, uint, short, int, int, ushort)
-               == AliasSeq!(short, uint, int, ushort)));
-
-    static assert(Replace!(5, 8, 1, 2, 5, 5) == AliasSeq!(1, 2, 8, 5));
-}
-
-private template ReplaceAllImpl(L...)
-{
-    static if (L.length == 2)
-    {
-        alias ReplaceAllImpl = AliasSeq!();
-    }
-    else
-    {
-        private alias Rest = ReplaceAllImpl!(L[0], L[1], L[3 .. $]);
-        static if (isEqual!(L[0], L[2]))
-        {
-            alias ReplaceAllImpl = AliasSeq!(L[1], Rest);
-        }
-        else
-        {
-            alias ReplaceAllImpl = AliasSeq!(L[2], Rest);
-        }
-    }
-}
-
-/**
- * Replaces all occurrences of $(D_PARAM T) in $(D_PARAM L) with $(D_PARAM U).
- *
- * Params:
- *  T = The symbol to be replaced.
- *  U = Replacement.
- *  L = List of symbols.
- *
- * Returns: $(D_PARAM L) with all occurrences of $(D_PARAM T) replaced.
- */
-template ReplaceAll(T, U, L...)
-{
-    alias ReplaceAll = ReplaceAllImpl!(T, U, L);
-}
-
-/// ditto
-template ReplaceAll(alias T, U, L...)
-{
-    alias ReplaceAll = ReplaceAllImpl!(T, U, L);
-}
-
-/// ditto
-template ReplaceAll(T, alias U, L...)
-{
-    alias ReplaceAll = ReplaceAllImpl!(T, U, L);
-}
-
-/// ditto
-template ReplaceAll(alias T, alias U, L...)
-{
-    alias ReplaceAll = ReplaceAllImpl!(T, U, L);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ReplaceAll!(int, uint, int) == AliasSeq!(uint)));
-    static assert(is(ReplaceAll!(int, uint, short, int, int, ushort)
-               == AliasSeq!(short, uint, uint, ushort)));
-
-    static assert(ReplaceAll!(5, 8, 1, 2, 5, 5) == AliasSeq!(1, 2, 8, 8));
-}
-
-/**
- * Params:
- *  L = List of symbols.
- *
- * Returns: $(D_PARAM L) with elements in reversed order.
- */
-template Reverse(L...)
-{
-    static if (L.length == 0)
-    {
-        alias Reverse = AliasSeq!();
-    }
-    else
-    {
-        alias Reverse = AliasSeq!(L[$ - 1], Reverse!(L[0 .. $ - 1]));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Reverse!(byte, short, int) == AliasSeq!(int, short, byte)));
-}
-
-/**
- * Applies $(D_PARAM F) to all elements of $(D_PARAM T).
- *
- * Params:
- *  F = Template predicate.
- *  T = List of symbols.
- *
- * Returns: Elements $(D_PARAM T) after applying $(D_PARAM F) to them.
- */
-template Map(alias F, T...)
-if (__traits(isTemplate, F))
-{
-    static if (T.length == 0)
-    {
-        alias Map = AliasSeq!();
-    }
-    else
-    {
-        alias Map = AliasSeq!(F!(T[0]), Map!(F, T[1 .. $]));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Map!(Unqual, const int, immutable short)
-               == AliasSeq!(int, short)));
-}
-
-/**
- * Sorts $(D_PARAM L) in ascending order according to $(D_PARAM cmp).
- *
- * $(D_PARAM cmp) can evaluate to:
- * $(UL
- *  $(LI $(D_KEYWORD bool): $(D_KEYWORD true) means
- *       $(D_INLINECODE a[i] < a[i + 1]).)
- *  $(LI $(D_KEYWORD int): a negative number means that
- *       $(D_INLINECODE a[i] < a[i + 1]), a positive number that
- *       $(D_INLINECODE a[i] > a[i + 1]), `0` if they equal.)
- * )
- *
- * Merge sort is used to sort the arguments.
- *
- * Params:
- *  cmp = Sorting template predicate.
- *  L   = Elements to be sorted.
- *
- * Returns: Elements of $(D_PARAM L) in ascending order.
- *
- * See_Also: $(LINK2 https://en.wikipedia.org/wiki/Merge_sort, Merge sort).
- */
-template Sort(alias cmp, L...)
-if (__traits(isTemplate, cmp))
-{
-    private template merge(size_t A, size_t B)
-    {
-        static if (A + B == L.length)
-        {
-            alias merge = AliasSeq!();
-        }
-        else static if (B >= Right.length
-                     || (A < Left.length && isLessEqual!(cmp, Left[A], Right[B])))
-        {
-            alias merge = AliasSeq!(Left[A], merge!(A + 1, B));
-        }
-        else
-        {
-            alias merge = AliasSeq!(Right[B], merge!(A, B + 1));
-        }
-    }
-
-    static if (L.length <= 1)
-    {
-        alias Sort = L;
-    }
-    else
-    {
-        private alias Left = Sort!(cmp, L[0 .. $ / 2]);
-        private alias Right = Sort!(cmp, L[$ / 2 .. $]);
-        alias Sort = merge!(0, 0);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum cmp(T, U) = T.sizeof < U.sizeof;
-    static assert(is(Sort!(cmp, long, short, byte, int)
-               == AliasSeq!(byte, short, int, long)));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    enum cmp(int T, int U) = T - U;
-    static assert(Sort!(cmp, 5, 17, 9, 12, 2, 10, 14)
-               == AliasSeq!(2, 5, 9, 10, 12, 14, 17));
-}
-
-private enum bool DerivedToFrontCmp(A, B) = is(A : B);
-
-/**
- * Returns $(D_PARAM L) sorted in such a way that the most derived types come
- * first.
- *
- * Params:
- *  L = Type tuple.
- *
- * Returns: Sorted $(D_PARAM L).
- */
-template DerivedToFront(L...)
-{
-    alias DerivedToFront = Sort!(DerivedToFrontCmp, L);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class A
-    {
-    }
-    class B : A
-    {
-    }
-    class C : B
-    {
-    }
-    static assert(is(DerivedToFront!(B, A, C) == AliasSeq!(C, B, A)));
-}
-
-/**
- * Returns the type from the type tuple $(D_PARAM L) that is most derived from
- * $(D_PARAM T).
- *
- * Params:
- *  T = The type to compare to.
- *  L = Type tuple.
- *
- * Returns: The type most derived from $(D_PARAM T).
- */
-template MostDerived(T, L...)
-{
-    static if (L.length == 0)
-    {
-        alias MostDerived = T;
-    }
-    else static if (is(T : L[0]))
-    {
-        alias MostDerived = MostDerived!(T, L[1 .. $]);
-    }
-    else
-    {
-        alias MostDerived = MostDerived!(L[0], L[1 .. $]);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class A
-    {
-    }
-    class B : A
-    {
-    }
-    class C : B
-    {
-    }
-    static assert(is(MostDerived!(A, C, B) == C));
-}
-
-private template EraseOne(L...)
-if (L.length > 0)
-{
-    static if (L.length == 1)
-    {
-        alias EraseOne = AliasSeq!();
-    }
-    else static if (isEqual!(L[0 .. 2]))
-    {
-        alias EraseOne = AliasSeq!(L[2 .. $]);
-    }
-    else
-    {
-        alias EraseOne = AliasSeq!(L[1], EraseOne!(L[0], L[2 .. $]));
-    }
-}
-
-/**
- * Removes the first occurrence of $(D_PARAM T) from the alias sequence
- * $(D_PARAL L).
- *
- * Params:
- *  T = The item to be removed.
- *  L = Alias sequence.
- *
- * Returns: $(D_PARAM L) with the first occurrence of $(D_PARAM T) removed.
- */
-template Erase(T, L...)
-{
-    alias Erase = EraseOne!(T, L);
-}
-
-/// ditto
-template Erase(alias T, L...)
-{
-    alias Erase = EraseOne!(T, L);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Erase!(int, short, int, int, uint) == AliasSeq!(short, int, uint)));
-    static assert(is(Erase!(int, short, uint) == AliasSeq!(short, uint)));
-}
-
-private template EraseAllImpl(L...)
-{
-    static if (L.length == 1)
-    {
-        alias EraseAllImpl = AliasSeq!();
-    }
-    else static if (isEqual!(L[0 .. 2]))
-    {
-        alias EraseAllImpl = EraseAllImpl!(L[0], L[2 .. $]);
-    }
-    else
-    {
-        alias EraseAllImpl = AliasSeq!(L[1], EraseAllImpl!(L[0], L[2 .. $]));
-    }
-}
-
-/**
- * Removes all occurrences of $(D_PARAM T) from the alias sequence $(D_PARAL L).
- *
- * Params:
- *  T = The item to be removed.
- *  L = Alias sequence.
- *
- * Returns: $(D_PARAM L) with all occurrences of $(D_PARAM T) removed.
- */
-template EraseAll(T, L...)
-{
-    alias EraseAll = EraseAllImpl!(T, L);
-}
-
-/// ditto
-template EraseAll(alias T, L...)
-{
-    alias EraseAll = EraseAllImpl!(T, L);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(EraseAll!(int, short, int, int, uint) == AliasSeq!(short, uint)));
-    static assert(is(EraseAll!(int, short, uint) == AliasSeq!(short, uint)));
-    static assert(is(EraseAll!(int, int, int) == AliasSeq!()));
-}
-
-/**
- * Returns an alias sequence which contains only items that satisfy the
- * condition $(D_PARAM pred).
- *
- * Params:
- *  pred = Template predicate.
- *  L    = Alias sequence.
- *
- * Returns: $(D_PARAM L) filtered so that it contains only items that satisfy
- *          $(D_PARAM pred).
- */
-template Filter(alias pred, L...)
-{
-    static if (L.length == 0)
-    {
-        alias Filter = AliasSeq!();
-    }
-    else static if (pred!(L[0]))
-    {
-        alias Filter = AliasSeq!(L[0], Filter!(pred, L[1 .. $]));
-    }
-    else
-    {
-        alias Filter = Filter!(pred, L[1 .. $]);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias Given = AliasSeq!(real, int, bool, uint);
-    static assert(is(Filter!(isIntegral, Given) == AliasSeq!(int, uint)));
-}
-
-/**
- * Removes all duplicates from the alias sequence $(D_PARAM L).
- *
- * Params:
- *  L = Alias sequence.
- *
- * Returns: $(D_PARAM L) containing only unique items.
- */
-template NoDuplicates(L...)
-{
-    static if (L.length == 0)
-    {
-        alias NoDuplicates = AliasSeq!();
-    }
-    else
-    {
-        private alias Rest = NoDuplicates!(EraseAll!(L[0], L[1 .. $]));
-        alias NoDuplicates = AliasSeq!(L[0], Rest);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias Given = AliasSeq!(int, uint, int, short, short, uint);
-    static assert(is(NoDuplicates!Given == AliasSeq!(int, uint, short)));
-}
-
-/**
- * Converts an input range $(D_PARAM range) into an alias sequence.
- *
- * Params:
- *  range = Input range.
- *
- * Returns: Alias sequence with items from $(D_PARAM range).
- */
-template aliasSeqOf(alias range)
-{
-    static if (isArray!(typeof(range)))
-    {
-        static if (range.length == 0)
-        {
-            alias aliasSeqOf = AliasSeq!();
-        }
-        else
-        {
-            alias aliasSeqOf = AliasSeq!(range[0], aliasSeqOf!(range[1 .. $]));
-        }
-    }
-    else
-    {
-        ReturnType!(typeof(&range.front))[] toArray(typeof(range) range)
-        {
-            typeof(return) result;
-            foreach (r; range)
-            {
-                result ~= r;
-            }
-            return result;
-        }
-        alias aliasSeqOf = aliasSeqOf!(toArray(range));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(aliasSeqOf!([0, 1, 2, 3]) == AliasSeq!(0, 1, 2, 3));
-}
-
-/**
- * Produces a alias sequence consisting of every $(D_PARAM n)th element of
- * $(D_PARAM Args), starting with the first.
- *
- * Params:
- *  n    = Step.
- *  Args = The items to stride.
- *
- * Returns: Alias sequence of every $(D_PARAM n)th element of $(D_PARAM Args).
- */
-template Stride(size_t n, Args...)
-if (n > 0)
-{
-    static if (Args.length > n)
-    {
-        alias Stride = AliasSeq!(Args[0], Stride!(n, Args[n .. $]));
-    }
-    else static if (Args.length > 0)
-    {
-        alias Stride = AliasSeq!(Args[0]);
-    }
-    else
-    {
-        alias Stride = AliasSeq!();
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(Stride!(3, 1, 2, 3, 4, 5, 6, 7, 8) == AliasSeq!(1, 4, 7));
-    static assert(Stride!(2, 1, 2, 3) == AliasSeq!(1, 3));
-    static assert(Stride!(2, 1, 2) == AliasSeq!(1));
-    static assert(Stride!(2, 1) == AliasSeq!(1));
-    static assert(Stride!(1, 1, 2, 3) == AliasSeq!(1, 2, 3));
-    static assert(is(Stride!3 == AliasSeq!()));
-}
-
-/**
- * Aliases itself to $(D_INLINECODE T[0]) if $(D_PARAM cond) is $(D_KEYWORD true),
- * to $(D_INLINECODE T[1]) if $(D_KEYWORD false).
- *
- * Params:
- *  cond = Template predicate.
- *  T    = Two arguments.
- *
- * Returns: $(D_INLINECODE T[0]) if $(D_PARAM cond) is $(D_KEYWORD true),
- * $(D_INLINECODE T[1]) otherwise.
- */
-template Select(bool cond, T...)
-if (T.length == 2)
-{
-    static if (cond)
-    {
-        alias Select = T[0];
-    }
-    else
-    {
-        alias Select = T[1];
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Select!(true, int, float) == int));
-    static assert(is(Select!(false, int, float) == float));
-}
-
-/**
- * Attaces a numeric index to each element from $(D_PARAM Args).
- *
- * $(D_PSYMBOL EnumerateFrom) returns a sequence of tuples ($(D_PSYMBOL Pack)s)
- * consisting of the index of each element and the element itself.
- *
- * Params:
- *  start = Enumeration initial value.
- *  Args  = Enumerated sequence.
- *
- * See_Also: $(D_PSYMBOL Enumerate).
- */
-template EnumerateFrom(size_t start, Args...)
-{
-    static if (Args.length == 0)
-    {
-        alias EnumerateFrom = AliasSeq!();
-    }
-    else
-    {
-        alias EnumerateFrom = AliasSeq!(Pack!(start, Args[0]), EnumerateFrom!(start + 1, Args[1 .. $]));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(EnumerateFrom!(0, int, uint, bool).length == 3);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias Expected = AliasSeq!(Pack!(cast(size_t) 0, int),
-                               Pack!(cast(size_t) 1, uint));
-    static assert(is(EnumerateFrom!(0, int, uint) == Expected));
-}
-
-/**
- * Attaces a numeric index to each element from $(D_PARAM Args).
- *
- * $(D_PSYMBOL EnumerateFrom) returns a sequence of tuples ($(D_PSYMBOL Pack)s)
- * consisting of the index of each element and the element itself.
- *
- * Params:
- *  Args  = Enumerated sequence.
- *
- * See_Also: $(D_PSYMBOL EnumerateFrom).
- */
-alias Enumerate(Args...) = EnumerateFrom!(0, Args);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias Expected = AliasSeq!(Pack!(cast(size_t) 0, int),
-                               Pack!(cast(size_t) 1, uint));
-    static assert(is(Enumerate!(int, uint) == Expected));
-}
diff --git a/meta/source/tanya/meta/package.d b/meta/source/tanya/meta/package.d
deleted file mode 100644
index d93e4fa..0000000
--- a/meta/source/tanya/meta/package.d
+++ /dev/null
@@ -1,23 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Template metaprogramming.
- *
- * This package contains utilities to acquire type information at compile-time,
- * to transform from one type to another. It has also different algorithms for
- * iterating, searching and modifying template arguments.
- *
- * Copyright: Eugene Wissner 2017-2018.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/meta/package.d,
- *                 tanya/meta/package.d)
- */
-module tanya.meta;
-
-public import tanya.meta.metafunction;
-public import tanya.meta.trait;
-public import tanya.meta.transform;
diff --git a/meta/source/tanya/meta/trait.d b/meta/source/tanya/meta/trait.d
deleted file mode 100644
index 69b97b9..0000000
--- a/meta/source/tanya/meta/trait.d
+++ /dev/null
@@ -1,3106 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Type traits.
- *
- * Templates in this module are used to obtain type information at compile
- * time.
- *
- * Copyright: Eugene Wissner 2017-2018.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/meta/trait.d,
- *                 tanya/meta/trait.d)
- */
-module tanya.meta.trait;
-
-import tanya.meta.metafunction;
-import tanya.meta.transform;
-
-/**
- * Determines whether $(D_PARAM T) is a wide string, i.e. consists of
- * $(D_KEYWORD dchar).
- *
- * The character type of the string can be qualified with $(D_KEYWORD const),
- * $(D_KEYWORD immutable) or $(D_KEYWORD inout), but an occurrence of
- * $(D_KEYWORD shared) in the character type results in returning
- * $(D_KEYWORD false).
- * The string itself (in contrast to its character type) can have any type
- * qualifiers.
- *
- * Static $(D_KEYWORD char) and $(D_KEYWORD wchar) arrays are not considered
- * strings.
- *
- * Params:
- *  T = A Type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a wide string,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isNarrowString).
- */
-enum bool isWideString(T) = is(T : const dchar[]) && !isStaticArray!T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isWideString!(dchar[]));
-    static assert(!isWideString!(char[]));
-    static assert(!isWideString!(wchar[]));
-
-    static assert(isWideString!dstring);
-    static assert(!isWideString!string);
-    static assert(!isWideString!wstring);
-
-    static assert(isWideString!(const dstring));
-    static assert(!isWideString!(const string));
-    static assert(!isWideString!(const wstring));
-
-    static assert(isWideString!(shared dstring));
-    static assert(!isWideString!(shared string));
-    static assert(!isWideString!(shared wstring));
-
-    static assert(isWideString!(const(dchar)[]));
-    static assert(isWideString!(inout(dchar)[]));
-    static assert(!isWideString!(shared(const(dchar))[]));
-    static assert(!isWideString!(shared(dchar)[]));
-    static assert(!isWideString!(dchar[10]));
-}
-
-/**
- * Determines whether $(D_PARAM T) is a complex type.
- *
- * Complex types are:
- * $(UL
- *  $(LI cfloat)
- *  $(LI ifloat)
- *  $(LI cdouble)
- *  $(LI idouble)
- *  $(LI creal)
- *  $(LI ireal)
- * )
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a complex type,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isComplex(T) = is(Unqual!(OriginalType!T) == cfloat)
-                      || is(Unqual!(OriginalType!T) == ifloat)
-                      || is(Unqual!(OriginalType!T) == cdouble)
-                      || is(Unqual!(OriginalType!T) == idouble)
-                      || is(Unqual!(OriginalType!T) == creal)
-                      || is(Unqual!(OriginalType!T) == ireal);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isComplex!cfloat);
-    static assert(isComplex!ifloat);
-    static assert(isComplex!cdouble);
-    static assert(isComplex!idouble);
-    static assert(isComplex!creal);
-    static assert(isComplex!ireal);
-
-    static assert(!isComplex!float);
-    static assert(!isComplex!double);
-    static assert(!isComplex!real);
-}
-
-/*
- * Tests whether $(D_PARAM T) is an interface.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is an interface,
- *          $(D_KEYWORD false) otherwise.
- */
-private enum bool isInterface(T) = is(T == interface);
-
-/**
- * Determines whether $(D_PARAM T) is a polymorphic type, i.e. a
- * $(D_KEYWORD class) or an $(D_KEYWORD interface).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a $(D_KEYWORD class) or an
- *          $(D_KEYWORD interface), $(D_KEYWORD false) otherwise.
- */
-enum bool isPolymorphicType(T) = is(T == class) || is(T == interface);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    interface I
-    {
-    }
-    static assert(isPolymorphicType!Object);
-    static assert(isPolymorphicType!I);
-    static assert(!isPolymorphicType!short);
-}
-
-/**
- * Determines whether the type $(D_PARAM T) has a static method
- * named $(D_PARAM member).
- *
- * Params:
- *  T      = Aggregate type.
- *  member = Symbol name.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM member) is a static method of
- *          $(D_PARAM T), $(D_KEYWORD false) otherwise.
- */
-template hasStaticMember(T, string member)
-{
-    static if (hasMember!(T, member))
-    {
-        alias Member = Alias!(__traits(getMember, T, member));
-
-        static if (__traits(isStaticFunction, Member)
-                || (!isFunction!Member && is(typeof(&Member))))
-        {
-            enum bool hasStaticMember = true;
-        }
-        else
-        {
-            enum bool hasStaticMember = false;
-        }
-    }
-    else
-    {
-        enum bool hasStaticMember = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S
-    {
-         int member1;
-         void member2()
-         {
-         }
-         static int member3;
-         static void member4()
-         {
-         }
-         static void function() member5;
-    }
-    static assert(!hasStaticMember!(S, "member1"));
-    static assert(!hasStaticMember!(S, "member2"));
-    static assert(hasStaticMember!(S, "member3"));
-    static assert(hasStaticMember!(S, "member4"));
-    static assert(hasStaticMember!(S, "member5"));
-}
-
-/**
- * Determines whether $(D_PARAM T) is a floating point type.
- *
- * Floating point types are:
- * $(UL
- *  $(LI float)
- *  $(LI double)
- *  $(LI real)
- * )
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a floating point type,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isFloatingPoint(T) = is(Unqual!(OriginalType!T) == double)
-                            || is(Unqual!(OriginalType!T) == float)
-                            || is(Unqual!(OriginalType!T) == real);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isFloatingPoint!float);
-    static assert(isFloatingPoint!double);
-    static assert(isFloatingPoint!real);
-    static assert(isFloatingPoint!(const float));
-    static assert(isFloatingPoint!(shared float));
-    static assert(isFloatingPoint!(shared const float));
-    static assert(!isFloatingPoint!int);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a signed numeric type.
- *
- * Signed numeric types are:
- * $(UL
- *  $(LI byte)
- *  $(LI short)
- *  $(LI int)
- *  $(LI long)
- *  $(LI float)
- *  $(LI double)
- *  $(LI real)
- * )
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a signed numeric type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isUnsigned).
- */
-enum bool isSigned(T) = is(Unqual!(OriginalType!T) == byte)
-                     || is(Unqual!(OriginalType!T) == short)
-                     || is(Unqual!(OriginalType!T) == int)
-                     || is(Unqual!(OriginalType!T) == long)
-                     || isFloatingPoint!T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isSigned!byte);
-    static assert(isSigned!short);
-    static assert(isSigned!int);
-    static assert(isSigned!long);
-    static assert(isSigned!float);
-    static assert(isSigned!double);
-    static assert(isSigned!real);
-
-    static assert(!isSigned!ubyte);
-    static assert(!isSigned!ushort);
-    static assert(!isSigned!uint);
-    static assert(!isSigned!ulong);
-}
-
-/**
- * Determines whether $(D_PARAM T) is an unsigned numeric type.
- *
- * Unsigned numeric types are:
- * $(UL
- *  $(LI ubyte)
- *  $(LI ushort)
- *  $(LI uint)
- *  $(LI ulong)
- * )
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is an unsigned numeric type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isSigned).
- */
-enum bool isUnsigned(T) = is(Unqual!(OriginalType!T) == ubyte)
-                       || is(Unqual!(OriginalType!T) == ushort)
-                       || is(Unqual!(OriginalType!T) == uint)
-                       || is(Unqual!(OriginalType!T) == ulong);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isUnsigned!ubyte);
-    static assert(isUnsigned!ushort);
-    static assert(isUnsigned!uint);
-    static assert(isUnsigned!ulong);
-
-    static assert(!isUnsigned!byte);
-    static assert(!isUnsigned!short);
-    static assert(!isUnsigned!int);
-    static assert(!isUnsigned!long);
-    static assert(!isUnsigned!float);
-    static assert(!isUnsigned!double);
-    static assert(!isUnsigned!real);
-}
-
-/**
- * Determines whether $(D_PARAM T) is an integral type.
- *
- * Integral types are:
- * $(UL
- *  $(LI ubyte)
- *  $(LI ushort)
- *  $(LI uint)
- *  $(LI ulong)
- *  $(LI byte)
- *  $(LI short)
- *  $(LI int)
- *  $(LI long)
- * )
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is an integral type,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isIntegral(T) = isUnsigned!T
-                       || is(Unqual!(OriginalType!T) == byte)
-                       || is(Unqual!(OriginalType!T) == short)
-                       || is(Unqual!(OriginalType!T) == int)
-                       || is(Unqual!(OriginalType!T) == long);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isIntegral!ubyte);
-    static assert(isIntegral!byte);
-    static assert(!isIntegral!float);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a numeric (floating point, integral or
- * complex) type.
-*
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a numeric type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isIntegral!T),
- *           $(D_PSYMBOL isFloatingPoint),
- *           $(D_PSYMBOL isComplex).
- */
-enum bool isNumeric(T) = isIntegral!T || isFloatingPoint!T || isComplex!T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias F = float;
-    static assert(isNumeric!F);
-    static assert(!isNumeric!bool);
-    static assert(!isNumeric!char);
-    static assert(!isNumeric!wchar);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a boolean type, i.e. $(D_KEYWORD bool).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a boolean type,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isBoolean(T) = is(Unqual!(OriginalType!T) == bool);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isBoolean!bool);
-    static assert(isBoolean!(shared const bool));
-    static assert(!isBoolean!(ubyte));
-    static assert(!isBoolean!(byte));
-
-    enum E : bool
-    {
-        t = true,
-        f = false,
-    }
-    static assert(isBoolean!E);
-
-    static struct S1
-    {
-        bool b;
-        alias b this;
-    }
-    static assert(!isBoolean!S1);
-
-    static struct S2
-    {
-        bool opCast(T : bool)()
-        {
-            return true;
-        }
-    }
-    static assert(!isBoolean!S2);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a character type.
- *
- * Character types are:
- *
- * $(UL
- *  $(LI char)
- *  $(LI wchar)
- *  $(LI dchar)
- * )
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a character type,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isSomeChar(T) = is(Unqual!(OriginalType!T) == char)
-                       || is(Unqual!(OriginalType!T) == wchar)
-                       || is(Unqual!(OriginalType!T) == dchar);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isSomeChar!char);
-    static assert(isSomeChar!wchar);
-    static assert(isSomeChar!dchar);
-
-    static assert(!isSomeChar!byte);
-    static assert(!isSomeChar!ubyte);
-    static assert(!isSomeChar!short);
-    static assert(!isSomeChar!ushort);
-    static assert(!isSomeChar!int);
-    static assert(!isSomeChar!uint);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a scalar type.
- *
- * Scalar types are numbers, booleans and characters.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a scalar type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isNumeric),
- *           $(D_PSYMBOL isBoolean),
- *           $(D_PSYMBOL isSomeChar).
- */
-enum bool isScalarType(T) = isNumeric!T || isBoolean!T || isSomeChar!T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isScalarType!int);
-    static assert(!isScalarType!(int[]));
-}
-
-/**
- * Determines whether $(D_PARAM T) is a basic type.
- *
- * Basic types are scalar types and $(D_KEYWORD void).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a basic type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isScalarType).
- */
-enum bool isBasicType(T) = isScalarType!T || is(T : void);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S
-    {
-    }
-    class C
-    {
-    }
-    enum E : int
-    {
-        i = 0,
-    }
-
-    static assert(isBasicType!void);
-    static assert(isBasicType!(shared void));
-    static assert(isBasicType!E);
-    static assert(!isBasicType!(int*));
-    static assert(!isBasicType!(void function()));
-    static assert(!isBasicType!C);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a pointer type.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a pointer type,
- *          $(D_KEYWORD false) otherwise.
- */
-template isPointer(T)
-{
-    static if (is(T U : U*))
-    {
-        enum bool isPointer = !is(Unqual!(OriginalType!T) == typeof(null));
-    }
-    else
-    {
-        enum bool isPointer = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isPointer!(bool*));
-    static assert(isPointer!(const bool*));
-    static assert(isPointer!(const shared bool*));
-    static assert(!isPointer!bool);
-}
-
-// typeof(null) is not a pointer.
-@nogc nothrow pure @safe unittest
-{
-    static assert(!isPointer!(typeof(null)));
-    static assert(!isPointer!(const shared typeof(null)));
-
-    enum typeOfNull : typeof(null)
-    {
-        null_ = null,
-    }
-    static assert(!isPointer!typeOfNull);
-}
-
-/**
- * Determines whether $(D_PARAM T) is an array type (dynamic or static, but
- * not an associative one).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is an array type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isAssociativeArray).
- */
-template isArray(T)
-{
-    static if (is(T U : U[]))
-    {
-        enum bool isArray = true;
-    }
-    else
-    {
-        enum bool isArray = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isArray!(bool[]));
-    static assert(isArray!(const bool[]));
-    static assert(isArray!(shared bool[]));
-    static assert(isArray!(bool[8]));
-    static assert(!isArray!bool);
-    static assert(!isArray!(bool[string]));
-}
-
-/**
- * Determines whether $(D_PARAM T) is a static array type.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a static array type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isArray).
- */
-template isStaticArray(T)
-{
-    static if (is(T U : U[L], size_t L))
-    {
-        enum bool isStaticArray = true;
-    }
-    else
-    {
-        enum bool isStaticArray = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isStaticArray!(bool[8]));
-    static assert(isStaticArray!(const bool[8]));
-    static assert(isStaticArray!(shared bool[8]));
-    static assert(!isStaticArray!(bool[]));
-    static assert(!isStaticArray!bool);
-    static assert(!isStaticArray!(bool[string]));
-}
-
-/**
- * Determines whether $(D_PARAM T) is a dynamic array type.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a dynamic array type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isArray).
- */
-enum bool isDynamicArray(T) = isArray!T && !isStaticArray!T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isDynamicArray!(bool[]));
-    static assert(isDynamicArray!(const bool[]));
-    static assert(isDynamicArray!(shared bool[]));
-    static assert(!isDynamicArray!(bool[8]));
-    static assert(!isDynamicArray!bool);
-    static assert(!isDynamicArray!(bool[string]));
-}
-
-/**
- * Determines whether $(D_PARAM T) is an associative array type.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is an associative array type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isArray).
- */
-template isAssociativeArray(T)
-{
-    static if (is(T U : U[L], L))
-    {
-        enum bool isAssociativeArray = true;
-    }
-    else
-    {
-        enum bool isAssociativeArray = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isAssociativeArray!(bool[string]));
-    static assert(isAssociativeArray!(const bool[string]));
-    static assert(isAssociativeArray!(shared const bool[string]));
-    static assert(!isAssociativeArray!(bool[]));
-    static assert(!isAssociativeArray!(bool[8]));
-    static assert(!isAssociativeArray!bool);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a built-in type.
- *
- * Built-in types are all basic types and arrays.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a built-in type,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isBasicType!T),
- *           $(D_PSYMBOL isArray),
- *           $(D_PSYMBOL isAssociativeArray).
- */
-enum bool isBuiltinType(T) = isBasicType!T
-                          || isArray!T
-                          || isAssociativeArray!T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isBuiltinType!int);
-    static assert(isBuiltinType!(int[]));
-    static assert(isBuiltinType!(int[int]));
-    static assert(!isBuiltinType!(int*));
-}
-
-/**
- * Determines whether $(D_PARAM T) is an aggregate type.
- *
- * Aggregate types are:
- *
- * $(UL
- *  $(LI $(D_KEYWORD struct)s)
- *  $(LI $(D_KEYWORD class)es)
- *  $(LI $(D_KEYWORD interface)s)
- *  $(LI $(D_KEYWORD union)s)
- * )
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is an aggregate type,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isAggregateType(T) = is(T == struct)
-                            || is(T == class)
-                            || is(T == interface)
-                            || is(T == union);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S;
-    class C;
-    interface I;
-    union U;
-    enum E;
-
-    static assert(isAggregateType!S);
-    static assert(isAggregateType!C);
-    static assert(isAggregateType!I);
-    static assert(isAggregateType!U);
-    static assert(!isAggregateType!E);
-    static assert(!isAggregateType!void);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a narrow string, i.e. consists of
- * $(D_KEYWORD char) or $(D_KEYWORD wchar).
- *
- * The character type of the string can be qualified with $(D_KEYWORD const),
- * $(D_KEYWORD immutable) or $(D_KEYWORD inout), but an occurrence of
- * $(D_KEYWORD shared) in the character type results in returning
- * $(D_KEYWORD false).
- * The string itself (in contrast to its character type) can have any type
- * qualifiers.
- *
- * Static $(D_KEYWORD char) and $(D_KEYWORD wchar) arrays are not considered
- * strings.
- *
- * Params:
- *  T = A Type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a narrow string,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isWideString).
- */
-enum bool isNarrowString(T) = (is(T : const char[]) || is (T : const wchar[]))
-                           && !isStaticArray!T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isNarrowString!(char[]));
-    static assert(isNarrowString!(wchar[]));
-    static assert(!isNarrowString!(dchar[]));
-
-    static assert(isNarrowString!string);
-    static assert(isNarrowString!wstring);
-    static assert(!isNarrowString!dstring);
-
-    static assert(isNarrowString!(const string));
-    static assert(isNarrowString!(const wstring));
-    static assert(!isNarrowString!(const dstring));
-
-    static assert(isNarrowString!(shared string));
-    static assert(isNarrowString!(shared wstring));
-    static assert(!isNarrowString!(shared dstring));
-
-    static assert(isNarrowString!(const(char)[]));
-    static assert(isNarrowString!(inout(char)[]));
-    static assert(!isNarrowString!(shared(const(char))[]));
-    static assert(!isNarrowString!(shared(char)[]));
-    static assert(!isNarrowString!(char[10]));
-}
-
-/**
- * Determines whether $(D_PARAM T) is a string, i.e. consists of
- * $(D_KEYWORD char), $(D_KEYWORD wchar) or $(D_KEYWORD dchar).
- *
- * The character type of the string can be qualified with $(D_KEYWORD const),
- * $(D_KEYWORD immutable) or $(D_KEYWORD inout), but an occurrence of
- * $(D_KEYWORD shared) in the character type results in returning
- * $(D_KEYWORD false).
- * The string itself (in contrast to its character type) can have any type
- * qualifiers.
- *
- * Static character arrays are not considered strings.
- *
- * Params:
- *  T = A Type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a string,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isNarrowString), $(D_PSYMBOL isWideString).
- */
-enum bool isSomeString(T) = isNarrowString!T || isWideString!T;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isSomeString!(dchar[]));
-    static assert(isSomeString!(char[]));
-    static assert(isSomeString!(wchar[]));
-
-    static assert(isSomeString!dstring);
-    static assert(isSomeString!string);
-    static assert(isSomeString!wstring);
-
-    static assert(isSomeString!(const dstring));
-    static assert(isSomeString!(const string));
-    static assert(isSomeString!(const wstring));
-
-    static assert(isSomeString!(shared dstring));
-    static assert(isSomeString!(shared string));
-    static assert(isSomeString!(shared wstring));
-
-    static assert(isSomeString!(const(char)[]));
-    static assert(isSomeString!(inout(char)[]));
-    static assert(!isSomeString!(shared(const(char))[]));
-    static assert(!isSomeString!(shared(char)[]));
-    static assert(!isSomeString!(char[10]));
-}
-
-/**
- * Returns the minimum value of type $(D_PARAM T). In contrast to
- * $(D_INLINECODE T.min) this template works with floating point and complex
- * types as well.
- *
- * Params:
- *  T = Integral, boolean, floating point, complex or character type.
- *
- * Returns: The minimum value of $(D_PARAM T).
- *
- * See_Also: $(D_PSYMBOL isIntegral),
- *           $(D_PSYMBOL isBoolean),
- *           $(D_PSYMBOL isSomeChar),
- *           $(D_PSYMBOL isFloatingPoint),
- *           $(D_PSYMBOL isComplex).
- */
-template mostNegative(T)
-{
-    static if (isIntegral!T || isBoolean!T || isSomeChar!T)
-    {
-        enum T mostNegative = T.min;
-    }
-    else static if (isFloatingPoint!T || isComplex!T)
-    {
-        enum T mostNegative = -T.max;
-    }
-    else
-    {
-        static assert(false, T.stringof ~ " doesn't have the minimum value");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(mostNegative!char == char.min);
-    static assert(mostNegative!wchar == wchar.min);
-    static assert(mostNegative!dchar == dchar.min);
-
-    static assert(mostNegative!byte == byte.min);
-    static assert(mostNegative!ubyte == ubyte.min);
-    static assert(mostNegative!bool == bool.min);
-
-    static assert(mostNegative!float == -float.max);
-    static assert(mostNegative!double == -double.max);
-    static assert(mostNegative!real == -real.max);
-
-    static assert(mostNegative!ifloat == -ifloat.max);
-    static assert(mostNegative!cfloat == -cfloat.max);
-}
-
-/**
- * Determines whether the type $(D_PARAM T) is copyable.
- *
- * Only structs can be not copyable if their postblit constructor or the
- * postblit constructor of one of its fields is disabled, i.e. annotated with
- * $(D_KEYWORD @disable).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_PARAM true) if $(D_PARAM T) can be copied,
- *          $(D_PARAM false) otherwise.
- */
-enum bool isCopyable(T) = is(typeof({ T s1 = T.init; T s2 = s1; }));
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S1
-    {
-    }
-    static struct S2
-    {
-        this(this)
-        {
-        }
-    }
-    static struct S3
-    {
-        @disable this(this);
-    }
-    static struct S4
-    {
-        S3 s;
-    }
-    class C
-    {
-    }
-
-    static assert(isCopyable!S1);
-    static assert(isCopyable!S2);
-    static assert(!isCopyable!S3);
-    static assert(!isCopyable!S4);
-
-    static assert(isCopyable!C);
-    static assert(isCopyable!bool);
-}
-
-/**
- * Determines whether $(D_PARAM T) is an abstract class.
- *
- * Abstract class is a class marked as such or a class that has any abstract
- * methods or doesn't implement all methods of abstract base classes.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is an abstract class,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isAbstractFunction).
- */
-enum bool isAbstractClass(T) = __traits(isAbstractClass, T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class A
-    {
-    }
-    abstract class B
-    {
-    }
-    class C
-    {
-        abstract void func();
-    }
-    class D : C
-    {
-    }
-    class E : C
-    {
-        override void func()
-        {
-        }
-    }
-    static assert(!isAbstractClass!A);
-    static assert(isAbstractClass!B);
-    static assert(isAbstractClass!C);
-    static assert(isAbstractClass!D);
-    static assert(!isAbstractClass!E);
-}
-
-/**
- * Checks whether $(D_PARAM T) is a type, same as `is(T)` does.
- *
- * Params:
- *  T = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a type, $(D_KEYWORD false)
- *          otherwise.
- */
-enum bool isType(alias T) = is(T);
-
-/// ditto
-enum bool isType(T) = true;
-
-/**
- * Determines whether $(D_PARAM Args) contains only types.
- *
- * Params:
- *  Args = Alias sequence.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM Args) consists only of types,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isTypeTuple(Args...) = allSatisfy!(isType, Args);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isTypeTuple!(int, uint, Object));
-    static assert(isTypeTuple!());
-    static assert(!isTypeTuple!(int, 8, Object));
-    static assert(!isTypeTuple!(5, 8, 2));
-
-    class C
-    {
-    }
-    enum E : bool
-    {
-        t,
-        f,
-    }
-    union U
-    {
-    }
-    static struct T()
-    {
-    }
-
-    static assert(isTypeTuple!C);
-    static assert(isTypeTuple!E);
-    static assert(isTypeTuple!U);
-    static assert(isTypeTuple!void);
-    static assert(isTypeTuple!int);
-    static assert(!isTypeTuple!T);
-    static assert(isTypeTuple!(T!()));
-    static assert(!isTypeTuple!5);
-    static assert(!isTypeTuple!(tanya.meta.trait));
-}
-
-/**
- * Tells whether $(D_PARAM Args) contains only expressions.
- *
- * An expression is determined by applying $(D_KEYWORD typeof) to an argument:
- *
- * ---
- * static if (is(typeof(Args[i])))
- * {
- *  // Args[i] is an expression.
- * }
- * else
- * {
- *  // Args[i] is not an expression.
- * }
- * ---
- *
- * Params:
- *  Args = Alias sequence.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM Args) consists only of expressions,
- *          $(D_KEYWORD false) otherwise.
- */
-template isExpressions(Args...)
-{
-    static if (Args.length == 0)
-    {
-        enum bool isExpressions = true;
-    }
-    else static if (is(typeof(Args[0]) U))
-    {
-        enum bool isExpressions = !is(U == void)
-                               && isExpressions!(Args[1 .. $]);
-    }
-    else
-    {
-        enum bool isExpressions = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isExpressions!(5, 8, 2));
-    static assert(isExpressions!());
-    static assert(!isExpressions!(int, uint, Object));
-    static assert(!isExpressions!(int, 8, Object));
-
-    template T(U)
-    {
-    }
-    static assert(!isExpressions!T);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a final class.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is a final class,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isFinalFunction).
- */
-enum bool isFinalClass(T) = __traits(isFinalClass, T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    final class A
-    {
-    }
-    class B
-    {
-    }
-
-    static assert(isFinalClass!A);
-    static assert(!isFinalClass!B);
-}
-
-/**
- * Determines whether $(D_PARAM T) is an abstract method.
- *
- * Params:
- *  F = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM F) is an abstract method,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isAbstractClass).
- */
-enum bool isAbstractFunction(alias F) = __traits(isAbstractFunction, F);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class A
-    {
-        void func()
-        {
-        }
-    }
-    class B
-    {
-        abstract void func();
-    }
-    class C : B
-    {
-        override void func()
-        {
-        }
-    }
-    static assert(!isAbstractFunction!(A.func));
-    static assert(isAbstractFunction!(B.func));
-    static assert(!isAbstractFunction!(C.func));
-}
-
-/**
- * Determines whether $(D_PARAM T) is a final method.
- *
- * Params:
- *  F = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM F) is a final method,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isFinalClass).
- */
-enum bool isFinalFunction(alias F) = __traits(isFinalFunction, F);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class A
-    {
-        void virtualFunc()
-        {
-        }
-        final void finalFunc()
-        {
-        }
-    }
-
-    static assert(isFinalFunction!(A.finalFunc));
-    static assert(!isFinalFunction!(A.virtualFunc));
-}
-
-/**
- * Function pointer is a pointer to a function. So a simple function is not
- * a function pointer, but getting the address of such function returns a
- * function pointer.
- *
- * A function pointer doesn't save the context pointer, thus cannot have access
- * to its outer scope.
- *
- * Params:
- *  F = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM F) is a function pointer,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(LINK2 http://dlang.org/spec/function.html#closures,
- *                   Delegates, Function Pointers, and Closures).
- */
-template isFunctionPointer(F...)
-if (F.length == 1)
-{
-    static if ((is(typeof(F[0]) T : T*) && is(T == function))
-            || (is(F[0] T : T*) && is(T == function)))
-    {
-        enum bool isFunctionPointer = true;
-    }
-    else
-    {
-        enum bool isFunctionPointer = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isFunctionPointer!(void function()));
-    static assert(!isFunctionPointer!(void delegate()));
-
-    static assert(isFunctionPointer!(() {}));
-
-    void func()
-    {
-    }
-    static void staticFunc()
-    {
-    }
-    interface I
-    {
-        @property int prop();
-    }
-
-    static assert(!isFunctionPointer!func);
-    static assert(!isFunctionPointer!staticFunc);
-
-    auto functionPointer = &staticFunc;
-    auto dg = &func;
-
-    static assert(isFunctionPointer!functionPointer);
-    static assert(!isFunctionPointer!dg);
-
-    static assert(!isFunctionPointer!(I.prop));
-}
-
-/**
- * Delegate stores the function pointer and function context.
- *
- * Params:
- *  F = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM F) is a delegate,
- *          $(D_KEYWORD false) delegate.
- *
- * See_Also: $(LINK2 http://dlang.org/spec/function.html#closures,
- *                   Delegates, Function Pointers, and Closures).
- */
-template isDelegate(F...)
-if (F.length == 1)
-{
-    static if (is(F[0] == delegate)
-            || is(typeof(F[0]) == delegate))
-    {
-        enum bool isDelegate = true;
-    }
-    else
-    {
-        enum bool isDelegate = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isDelegate!(void delegate()));
-    static assert(!isDelegate!(void function()));
-
-    static assert(!isDelegate!(() {}));
-
-    void func()
-    {
-    }
-    static void staticFunc()
-    {
-    }
-    interface I
-    {
-        @property int prop();
-    }
-
-    static assert(!isDelegate!func);
-    static assert(!isDelegate!staticFunc);
-
-    auto functionPointer = &staticFunc;
-    auto dg = &func;
-
-    static assert(!isDelegate!functionPointer);
-    static assert(isDelegate!dg);
-
-    static assert(!isDelegate!(I.prop));
-}
-
-/**
- * $(D_PSYMBOL isFunction) returns $(D_KEYWORD true) only for plain functions,
- * not function pointers or delegates. Use $(D_PSYMBOL isFunctionPointer) or
- * $(D_PSYMBOL isDelegate) to detect them or $(D_PSYMBOL isSomeFunction)
- * for detecting a function of any type.
- *
- * Params:
- *  F = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM F) is a function,
- *          $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(LINK2 http://dlang.org/spec/function.html#closures,
- *                   Delegates, Function Pointers, and Closures).
- */
-template isFunction(F...)
-if (F.length == 1)
-{
-    static if (is(F[0] == function)
-            || is(typeof(&F[0]) T == delegate)
-            || (is(typeof(&F[0]) T : T*) && is(T == function)))
-    {
-        enum bool isFunction = true;
-    }
-    else
-    {
-        enum bool isFunction = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(!isFunction!(void function()));
-    static assert(!isFunction!(() {}));
-    static assert(!isFunction!(void delegate()));
-
-    void func()
-    {
-    }
-    static void staticFunc()
-    {
-    }
-    interface I
-    {
-        @property int prop();
-    }
-
-    static assert(isFunction!func);
-    static assert(isFunction!staticFunc);
-
-    auto functionPointer = &staticFunc;
-    auto dg = &func;
-
-    static assert(!isFunction!functionPointer);
-    static assert(!isFunction!dg);
-
-    static assert(isFunction!(I.prop));
-}
-
-/**
- * Params:
- *  F = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM F) is a function, function pointer
- *           or delegate, $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(D_PSYMBOL isFunction),
- *           $(D_PSYMBOL isDelegate),
- *           $(D_PSYMBOL isFunctionPointer).
- */
-template isSomeFunction(F...)
-if (F.length == 1)
-{
-    enum bool isSomeFunction = isFunctionPointer!F
-                            || isFunction!F
-                            || isDelegate!F;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isSomeFunction!(void function()));
-    static assert(isSomeFunction!(() {}));
-    static assert(isSomeFunction!(void delegate()));
-
-    void func()
-    {
-    }
-    static void staticFunc()
-    {
-    }
-
-    static assert(isSomeFunction!func);
-    static assert(isSomeFunction!staticFunc);
-
-    auto functionPointer = &staticFunc;
-    auto dg = &func;
-
-    static assert(isSomeFunction!functionPointer);
-    static assert(isSomeFunction!dg);
-
-    static assert(!isSomeFunction!int);
-}
-
-/**
- * Params:
- *  F = A symbol.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM F) is callable,
- *          $(D_KEYWORD false) otherwise.
- */
-template isCallable(F...)
-if (F.length == 1)
-{
-    static if (isSomeFunction!F
-            || (is(typeof(F[0].opCall)) && isFunction!(F[0].opCall)))
-    {
-        enum bool isCallable = true;
-    }
-    else
-    {
-        enum bool isCallable = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S
-    {
-        void opCall()
-        {
-        }
-    }
-    class C
-    {
-        static void opCall()
-        {
-        }
-    }
-    interface I
-    {
-    }
-    S s;
-
-    static assert(isCallable!s);
-    static assert(isCallable!C);
-    static assert(isCallable!S);
-    static assert(!isCallable!I);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static struct S
-    {
-        @property int opCall()
-        {
-            return 0;
-        }
-    }
-    S s;
-    static assert(isCallable!S);
-    static assert(isCallable!s);
-}
-
-/**
- * Determines whether $(D_PARAM T) defines a symbol $(D_PARAM member).
- *
- * Params:
- *  T      = Aggregate type.
- *  member = Symbol name.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) defines a symbol
- *          $(D_PARAM member), $(D_KEYWORD false) otherwise.
- */
-enum bool hasMember(T, string member) = __traits(hasMember, T, member);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S
-    {
-         int member1;
-         void member2()
-         {
-         }
-         static int member3;
-         static void member4()
-         {
-         }
-    }
-    static assert(hasMember!(S, "member1"));
-    static assert(hasMember!(S, "member2"));
-    static assert(hasMember!(S, "member3"));
-    static assert(hasMember!(S, "member4"));
-    static assert(!hasMember!(S, "member6"));
-}
-
-/**
- * Determines whether $(D_PARAM T) is mutable, i.e. has one of the following
- * qualifiers or a combination of them:
- *
- * $(UL
- *  $(LI $(D_KEYWORD const))
- *  $(LI $(D_KEYWORD immutable))
- *  $(LI $(D_KEYWORD const))
- * )
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) is mutable,
- *          $(D_KEYWORD false) otherwise.
- */
-template isMutable(T)
-{
-    static if (is(T U == const U)
-            || is(T U == inout U)
-            || is(T U == inout const U)
-            || is(T U == immutable U)
-            || is(T U == shared const U)
-            || is(T U == shared inout U)
-            || is(T U == shared inout const U))
-    {
-        enum bool isMutable = false;
-    }
-    else
-    {
-        enum bool isMutable = true;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S
-    {
-        void method()
-        {
-            static assert(isMutable!(typeof(this)));
-        }
-
-        void method() inout
-        {
-            static assert(!isMutable!(typeof(this)));
-        }
-
-        void immMethod() const
-        {
-            static assert(!isMutable!(typeof(this)));
-        }
-        void immMethod() immutable
-        {
-            static assert(!isMutable!(typeof(this)));
-        }
-    }
-}
-
-/**
- * Determines whether $(D_PARAM T) is a nested type, i.e. $(D_KEYWORD class),
- * $(D_KEYWORD struct) or $(D_KEYWORD union), which internally stores a context
- * pointer.
- *
- * Params:
- *  T = $(D_KEYWORD class), $(D_KEYWORD struct) or $(D_KEYWORD union) type.
- *
- * Returns: $(D_KEYWORD true) if the argument is a nested type which internally
- *          stores a context pointer, $(D_KEYWORD false) otherwise.
- */
-template isNested(T)
-if (is(T == class) || is(T == struct) || is(T == union))
-{
-    enum bool isNested = __traits(isNested, T);
-}
-
-///
-@nogc pure nothrow @safe unittest
-{
-    static struct S
-    {
-    }
-    static assert(!isNested!S);
-
-    class C
-    {
-        void method()
-        {
-        }
-    }
-    static assert(isNested!C);
-}
-
-/**
- * Determines whether $(D_PARAM T) is a nested function.
- *
- * Params:
- *  F = A function.
- *
- * Returns $(D_KEYWORD true) if the $(D_PARAM T) is a nested function,
- *         $(D_KEYWORD false) otherwise.
- */
-enum bool isNestedFunction(alias F) = __traits(isNested, F);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    void func()
-    {
-        void nestedFunc()
-        {
-        }
-        static assert(isNestedFunction!nestedFunc);
-    }
-}
-
-/**
- * Determines the type of the callable $(D_PARAM F).
- *
- * Params:
- *  F = A function.
- *
- * Returns: Type of the function $(D_PARAM F).
- */
-template FunctionTypeOf(F...)
-if (isCallable!F)
-{
-    static if ((is(typeof(F[0]) T : T*) && is(T == function))
-            || (is(F[0] T : T*) && is(T == function))
-            || is(F[0] T == delegate)
-            || is(typeof(F[0]) T == delegate)
-            || is(F[0] T == function)
-            || is(typeof(&F[0]) T == delegate)
-            || (is(typeof(&F[0]) T : T*) && is(T == function)))
-    {
-        alias FunctionTypeOf = T;
-    }
-    else
-    {
-        alias FunctionTypeOf = FunctionTypeOf!(F[0].opCall);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(FunctionTypeOf!(void function()) == function));
-    static assert(is(FunctionTypeOf!(() {}) == function));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(FunctionTypeOf!(void delegate()) == function));
-
-    static void staticFunc()
-    {
-    }
-    auto functionPointer = &staticFunc;
-    static assert(is(FunctionTypeOf!staticFunc == function));
-    static assert(is(FunctionTypeOf!functionPointer == function));
-
-    void func()
-    {
-    }
-    auto dg = &func;
-    static assert(is(FunctionTypeOf!func == function));
-    static assert(is(FunctionTypeOf!dg == function));
-
-    interface I
-    {
-        @property int prop();
-    }
-    static assert(is(FunctionTypeOf!(I.prop) == function));
-
-    static struct S
-    {
-        void opCall()
-        {
-        }
-    }
-    class C
-    {
-        static void opCall()
-        {
-        }
-    }
-    S s;
-
-    static assert(is(FunctionTypeOf!s == function));
-    static assert(is(FunctionTypeOf!C == function));
-    static assert(is(FunctionTypeOf!S == function));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static struct S2
-    {
-        @property int opCall()
-        {
-            return 0;
-        }
-    }
-    S2 s2;
-    static assert(is(FunctionTypeOf!S2 == function));
-    static assert(is(FunctionTypeOf!s2 == function));
-}
-
-/**
- * Determines the return type of the callable $(D_PARAM F).
- *
- * Params:
- *  F = A callable object.
- *
- * Returns: Return type of $(D_PARAM F).
- */
-template ReturnType(F...)
-if (isCallable!F)
-{
-    static if (is(FunctionTypeOf!(F[0]) T == return))
-    {
-        alias ReturnType = T;
-    }
-    else
-    {
-        static assert(false, "Argument is not a callable");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ReturnType!(int delegate()) == int));
-    static assert(is(ReturnType!(bool function()) == bool));
-}
-
-/**
- * Determines the template $(D_PARAM T) is an instance of.
- *
- * Params:
- *  T = Template instance.
- *
- * Returns: Template $(D_PARAM T) is an instance of.
- */
-alias TemplateOf(alias T : Base!Args, alias Base, Args...) = Base;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S(T)
-    {
-    }
-    static assert(__traits(isSame, TemplateOf!(S!int), S));
-
-    static void func(T)()
-    {
-    }
-    static assert(__traits(isSame, TemplateOf!(func!int), func));
-
-    template T(U)
-    {
-    }
-    static assert(__traits(isSame, TemplateOf!(T!int), T));
-}
-
-/**
- * Returns the mangled name of the symbol $(D_PARAM T).
- *
- * Params:
- *  T = A symbol.
- *
- * Returns: Mangled name of $(D_PARAM T).
- */
-enum string mangledName(T) = T.mangleof;
-
-///
-enum string mangledName(alias T) = T.mangleof;
-
-/**
- * Tests whether $(D_PARAM I) is an instance of template $(D_PARAM T).
- *
- * Params:
- *  T = Template.
- *  I = Template instance.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM I) is an instance of $(D_PARAM T),
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isInstanceOf(alias T, I) = is(I == T!Args, Args...);
-
-template isInstanceOf(alias T, alias I)
-{
-    static if (is(typeof(TemplateOf!I)))
-    {
-        enum bool isInstanceOf = __traits(isSame, TemplateOf!I, T);
-    }
-    else
-    {
-        enum bool isInstanceOf = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S(T)
-    {
-    }
-    static assert(isInstanceOf!(S, S!int));
-
-    static void func(T)();
-    static assert(isInstanceOf!(func, func!int));
-
-    template T(U)
-    {
-    }
-    static assert(isInstanceOf!(T, T!int));
-}
-
-/**
- * Checks whether $(D_PARAM From) is implicitly (without explicit
- * $(D_KEYWORD cast)) to $(D_PARAM To).
- *
- * Params:
- *  From = Source type.
- *  To   = Conversion target type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM From) is implicitly convertible to
- *          $(D_PARAM To), $(D_KEYWORD false) if not.
- */
-enum bool isImplicitlyConvertible(From, To) = is(From : To);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isImplicitlyConvertible!(const(byte), byte));
-    static assert(isImplicitlyConvertible!(byte, char));
-    static assert(isImplicitlyConvertible!(byte, short));
-    static assert(!isImplicitlyConvertible!(short, byte));
-    static assert(isImplicitlyConvertible!(string, const(char)[]));
-}
-
-/**
- * Returns a tuple of base classes and interfaces of $(D_PARAM T).
- *
- * $(D_PSYMBOL BaseTypeTuple) returns only classes and interfaces $(D_PARAM T)
- * directly inherits from, but not the base classes and interfaces of its parents.
- *
- * Params:
- *  T = Class or interface type.
- *
- * Returns: A tuple of base classes or interfaces of ($D_PARAM T).
- *
- * See_Also: $(D_PSYMBOL TransitiveBaseTypeTuple).
- */
-template BaseTypeTuple(T)
-if (is(T == class) || (is(T == interface)))
-{
-    static if (is(T Tuple == super))
-    {
-        alias BaseTypeTuple = Tuple;
-    }
-    else
-    {
-        static assert(false, "Argument isn't a class or interface");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    interface I1
-    {
-    }
-    interface I2
-    {
-    }
-    interface I3 : I1, I2
-    {
-    }
-    interface I4
-    {
-    }
-    class A : I3, I4
-    {
-    }
-    static assert(is(BaseTypeTuple!A == AliasSeq!(Object, I3, I4)));
-    static assert(BaseTypeTuple!Object.length == 0);
-}
-
-/**
- * Returns a tuple of all base classes and interfaces of $(D_PARAM T).
- *
- * $(D_PSYMBOL TransitiveBaseTypeTuple) returns first the parent class, then
- * grandparent and so on. The last class is $(D_PSYMBOL Object). Then the interfaces
- * follow.
- *
- * Params:
- *  T = Class or interface type.
- *
- * Returns: A tuple of all base classes and interfaces of ($D_PARAM T).
- *
- * See_Also: $(D_PSYMBOL BaseTypeTuple).
- */
-template TransitiveBaseTypeTuple(T)
-if (is(T == class) || is(T == interface))
-{
-    private template Impl(T...)
-    {
-        static if (T.length == 0)
-        {
-            alias Impl = AliasSeq!();
-        }
-        else
-        {
-            alias Impl = AliasSeq!(BaseTypeTuple!(T[0]),
-                                   Map!(ImplCopy, BaseTypeTuple!(T[0])));
-        }
-    }
-    private alias ImplCopy = Impl; // To avoid recursive template expansion.
-    private enum bool cmp(A, B) = is(B == interface) && is(A == class);
-
-    alias TransitiveBaseTypeTuple = NoDuplicates!(Sort!(cmp, Impl!T));
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    interface I1
-    {
-    }
-    interface I2 : I1
-    {
-    }
-    class A : I2
-    {
-    }
-    class B : A, I1
-    {
-    }
-    class C : B, I2
-    {
-    }
-    alias Expected = AliasSeq!(B, A, Object, I2, I1);
-    static assert(is(TransitiveBaseTypeTuple!C == Expected));
-
-    static assert(is(TransitiveBaseTypeTuple!Object == AliasSeq!()));
-    static assert(is(TransitiveBaseTypeTuple!I2 == AliasSeq!(I1)));
-}
-
-/**
- * Returns all the base classes of $(D_PARAM T), the direct parent class comes
- * first, $(D_PSYMBOL Object) ist the last one.
- *
- * The only type that doesn't have any base class is $(D_PSYMBOL Object).
- *
- * Params:
- *  T = Class type.
- *
- * Returns: Base classes of $(D_PARAM T).
- */
-template BaseClassesTuple(T)
-if (is(T == class))
-{
-    static if (is(T == Object))
-    {
-        alias BaseClassesTuple = AliasSeq!();
-    }
-    else
-    {
-        private alias Parents = BaseTypeTuple!T;
-        alias BaseClassesTuple = AliasSeq!(Parents[0], BaseClassesTuple!(Parents[0]));
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    interface I1
-    {
-    }
-    interface I2
-    {
-    }
-    class A : I1, I2
-    {
-    }
-    class B : A, I1
-    {
-    }
-    class C : B, I2
-    {
-    }
-    static assert(is(BaseClassesTuple!C == AliasSeq!(B, A, Object)));
-    static assert(BaseClassesTuple!Object.length == 0);
-}
-
-/**
- * Returns all the interfaces $(D_PARAM T) inherits from.
- *
- * Params:
- *  T = Class or interface type.
- *
- * Returns: Interfaces $(D_PARAM T) inherits from.
- */
-template InterfacesTuple(T)
-if (is(T == class) || is(T == interface))
-{
-    alias InterfacesTuple = Filter!(isInterface, TransitiveBaseTypeTuple!T);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    interface I1
-    {
-    }
-    interface I2 : I1
-    {
-    }
-    class A : I2
-    {
-    }
-    class B : A, I1
-    {
-    }
-    class C : B, I2
-    {
-    }
-    static assert(is(InterfacesTuple!C == AliasSeq!(I2, I1)));
-
-    static assert(is(InterfacesTuple!Object == AliasSeq!()));
-    static assert(is(InterfacesTuple!I1 == AliasSeq!()));
-}
-
-/**
- * Tests whether a value of type $(D_PARAM Rhs) can be assigned to a variable
- * of type $(D_PARAM Lhs).
- *
- * If $(D_PARAM Rhs) isn't specified, $(D_PSYMBOL isAssignable) tests whether a
- * value of type $(D_PARAM Lhs) can be assigned to a variable of the same type.
- *
- * $(D_PSYMBOL isAssignable) tells whether $(D_PARAM Rhs) can be assigned by
- * value as well by reference.
- *
- * Params:
- *  Lhs = Variable type.
- *  Rhs = Expression type.
- *
- * Returns: $(D_KEYWORD true) if a value of type $(D_PARAM Rhs) can be assigned
- *          to a variable of type $(D_PARAM Lhs), $(D_KEYWORD false) otherwise.
- */
-template isAssignable(Lhs, Rhs = Lhs)
-{
-    enum bool isAssignable = is(typeof({
-        Lhs lhs = Lhs.init;
-        Rhs rhs = Rhs.init;
-        lhs = ((inout ref Rhs) => Rhs.init)(rhs);
-    }));
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct S1
-    {
-        @disable this();
-        @disable this(this);
-    }
-    static struct S2
-    {
-        void opAssign(S1 s) pure nothrow @safe @nogc
-        {
-        }
-    }
-    static struct S3
-    {
-        void opAssign(ref S1 s) pure nothrow @safe @nogc
-        {
-        }
-    }
-    static assert(isAssignable!(S2, S1));
-    static assert(!isAssignable!(S3, S1));
-
-    static assert(isAssignable!(const(char)[], string));
-    static assert(!isAssignable!(string, char[]));
-
-    static assert(isAssignable!int);
-    static assert(!isAssignable!(const int, int));
-}
-
-/**
- * Returns template parameters of $(D_PARAM T).
- *
- * Params:
- *  T = Template instance.
- *
- * Returns: Template parameters of $(D_PARAM T).
- */
-alias TemplateArgsOf(alias T : Base!Args, alias Base, Args...) = Args;
-
-///
-@nogc nothrow pure @safe unittest
-{
-    template T(A, B)
-    {
-    }
-    static assert(is(TemplateArgsOf!(T!(int, uint)) == AliasSeq!(int, uint)));
-}
-
-/**
- * Returns a tuple with parameter types of a function.
- *
- * Params:
- *  F = A function.
- *
- * Returns: Tuple with parameter types of a function.
- */
-template Parameters(F...)
-if (isCallable!F)
-{
-    static if (is(FunctionTypeOf!F T == function))
-    {
-        alias Parameters = T;
-    }
-    else
-    {
-        static assert(false, "Function has no parameters");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    int func(Object, uint[]);
-    static assert(is(Parameters!func == AliasSeq!(Object, uint[])));
-}
-
-/**
- * Returns a string array with all parameter names of a function.
- *
- * If a parameter has no name, an empty string is placed into array.
- *
- * Params:
- *  F = A function.
- *
- * Returns: Function parameter names.
- */
-template ParameterIdentifierTuple(F...)
-if (isCallable!F)
-{
-    static if (is(FunctionTypeOf!F Params == __parameters))
-    {
-        string[] Impl()
-        {
-            string[] tuple;
-
-            foreach (k, P; Params)
-            {
-                static if (is(typeof(__traits(identifier, Params[k .. $]))))
-                {
-                    tuple ~= __traits(identifier, Params[k .. $]);
-                }
-                else
-                {
-                    tuple ~= "";
-                }
-            }
-
-            return tuple;
-        }
-        enum string[] ParameterIdentifierTuple = Impl();
-    }
-    else
-    {
-        static assert(false, "Function has no parameters");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    int func(ref Object stuff, uint[] = null, scope uint k = 1);
-    alias P = ParameterIdentifierTuple!func;
-    static assert(P[0] == "stuff");
-    static assert(P[1] == "");
-    static assert(P[2] == "k");
-}
-
-/// Attributes can be attached to a function.
-enum FunctionAttribute : uint
-{
-    none = 0x0000,
-    pure_ = 0x0001,
-    nothrow_ = 0x0002,
-    ref_ = 0x0004,
-    property = 0x0008,
-    trusted = 0x0010,
-    safe = 0x0020,
-    nogc = 0x0040,
-    system = 0x0080,
-    const_ = 0x0100,
-    immutable_ = 0x0200,
-    inout_ = 0x0400,
-    shared_ = 0x0800,
-    return_ = 0x1000,
-    scope_ = 0x2000,
-}
-
-/**
- * Retrieves the attributes of the function $(D_PARAM F).
- *
- * The attributes are returned as a bit-mask of
- * $(D_PSYMBOL FunctionAttribute) values.
- *
- * Params: A function.
- *
- * Returns: Attributes of the function $(D_PARAM F).
- *
- * See_Also: $(D_PSYMBOL FunctionAttribute).
- */
-template functionAttributes(F...)
-if (isCallable!F)
-{
-    uint Impl()
-    {
-        uint attrs = FunctionAttribute.none;
-        foreach (a; __traits(getFunctionAttributes, F[0]))
-        {
-            static if (a == "const")
-            {
-                attrs |= FunctionAttribute.const_;
-            }
-            else static if (a == "immutable")
-            {
-                attrs |= FunctionAttribute.immutable_;
-            }
-            else static if (a == "inout")
-            {
-                attrs |= FunctionAttribute.inout_;
-            }
-            else static if (a == "@nogc")
-            {
-                attrs |= FunctionAttribute.nogc;
-            }
-            else static if (a == "nothrow")
-            {
-                attrs |= FunctionAttribute.nothrow_;
-            }
-            else static if (a == "@property")
-            {
-                attrs |= FunctionAttribute.property;
-            }
-            else static if (a == "pure")
-            {
-                attrs |= FunctionAttribute.pure_;
-            }
-            else static if (a == "ref")
-            {
-                attrs |= FunctionAttribute.ref_;
-            }
-            else static if (a == "return")
-            {
-                attrs |= FunctionAttribute.return_;
-            }
-            else static if (a == "@safe")
-            {
-                attrs |= FunctionAttribute.safe;
-            }
-            else static if (a == "scope")
-            {
-                attrs |= FunctionAttribute.scope_;
-            }
-            else static if (a == "shared")
-            {
-                attrs |= FunctionAttribute.shared_;
-            }
-            else static if (a == "@system")
-            {
-                attrs |= FunctionAttribute.system;
-            }
-            else static if (a == "@trusted")
-            {
-                attrs |= FunctionAttribute.trusted;
-            }
-        }
-        return attrs;
-    }
-    enum uint functionAttributes = Impl();
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    @property ref int func1() pure nothrow @safe @nogc shared scope;
-    static assert((functionAttributes!func1 & FunctionAttribute.pure_)
-               == FunctionAttribute.pure_);
-    static assert((functionAttributes!func1 & FunctionAttribute.nothrow_)
-               == FunctionAttribute.nothrow_);
-    static assert((functionAttributes!func1 & FunctionAttribute.safe)
-               == FunctionAttribute.safe);
-    static assert((functionAttributes!func1 & FunctionAttribute.nogc)
-               == FunctionAttribute.nogc);
-    static assert((functionAttributes!func1 & FunctionAttribute.shared_)
-               == FunctionAttribute.shared_);
-    static assert((functionAttributes!func1 & FunctionAttribute.ref_)
-               == FunctionAttribute.ref_);
-    static assert((functionAttributes!func1 & FunctionAttribute.property)
-               == FunctionAttribute.property);
-    static assert((functionAttributes!func1 & FunctionAttribute.scope_)
-               == FunctionAttribute.scope_);
-    static assert((functionAttributes!func1 & FunctionAttribute.system) == 0);
-    static assert((functionAttributes!func1 & FunctionAttribute.trusted) == 0);
-    static assert((functionAttributes!func1 & FunctionAttribute.return_) == 0);
-}
-
-/**
- * Returns a tuple with default values of the parameters to $(D_PARAM F).
- *
- * If a parameter doesn't have a default value, $(D_KEYWORD void) is returned.
- *
- * Params:
- *  F = A function.
- *
- * Returns: Default values of the parameters to $(D_PARAM F).
- */
-template ParameterDefaults(F...)
-if (isCallable!F)
-{
-    static if (is(FunctionTypeOf!F T == __parameters))
-    {
-        private template GetDefault(size_t i)
-        {
-            static if (i == T.length)
-            {
-                alias GetDefault = AliasSeq!();
-            }
-            else
-            {
-                enum getDefault(T[i .. i + 1] name)
-                {
-                    return name[0];
-                }
-                static if (is(typeof(getDefault())))
-                {
-                    alias Default = Alias!(getDefault());
-                }
-                else
-                {
-                    alias Default = void;
-                }
-                alias GetDefault = AliasSeq!(Default, GetDefault!(i + 1));
-            }
-        }
-
-        alias ParameterDefaults = GetDefault!0;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    void func1(int k, uint b = 5, int[] = [1, 2]);
-    alias Defaults = ParameterDefaults!func1;
-    static assert(is(Defaults[0] == void));
-    static assert(Defaults[1 .. 3] == AliasSeq!(5, [1, 2]));
-}
-
-/**
- * Determines whether $(D_PARAM T) has an elaborate destructor.
- *
- * Only $(D_KEYWORD struct)s and static arrays of $(D_KEYWORD struct)s with the
- * length greater than`0` can have elaborate destructors, for all other types
- * $(D_PSYMBOL hasElaborateDestructor) evaluates to $(D_KEYWORD false).
- *
- * An elaborate destructor is an explicitly defined destructor or one generated
- * by the compiler. The compiler generates a destructor for a
- * $(D_KEYWORD struct) if it has members with an elaborate destructor.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) has an elaborate destructor,
- *          $(D_KEYWORD false) otherwise.
- */
-template hasElaborateDestructor(T)
-{
-    static if (is(T E : E[L], size_t L))
-    {
-        enum bool hasElaborateDestructor = L > 0 && hasElaborateDestructor!E;
-    }
-    else
-    {
-        enum bool hasElaborateDestructor = is(T == struct)
-                                        && hasMember!(T, "__xdtor");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class C
-    {
-        ~this()
-        {
-        }
-    }
-    static assert(!hasElaborateDestructor!C);
-
-    static struct S
-    {
-        ~this()
-        {
-        }
-    }
-    static struct S1
-    {
-        S s;
-    }
-    static struct S2
-    {
-    }
-    static assert(hasElaborateDestructor!S); // Explicit destructor.
-    static assert(hasElaborateDestructor!S1); // Compiler-generated destructor.
-    static assert(!hasElaborateDestructor!S2); // No destructor.
-
-    static assert(hasElaborateDestructor!(S[1]));
-    static assert(!hasElaborateDestructor!(S[0]));
-}
-
-/**
- * Determines whether $(D_PARAM T) has an elaborate postblit constructor.
- *
- * Only $(D_KEYWORD struct)s and static arrays of $(D_KEYWORD struct)s with the
- * length greater than`0` can have elaborate postblit constructors, for all
- * other types $(D_PSYMBOL hasElaborateCopyConstructor) evaluates to
- * $(D_KEYWORD false).
- *
- * An elaborate postblit constructor is an explicitly defined postblit
- * constructor or one generated by the compiler. The compiler generates a
- * postblit constructor for a
- * $(D_KEYWORD struct) if it has members with an elaborate postblit
- * constructor.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) has an elaborate postblit
- *          constructor, $(D_KEYWORD false) otherwise.
- */
-template hasElaborateCopyConstructor(T)
-{
-    static if (is(T E : E[L], size_t L))
-    {
-        enum bool hasElaborateCopyConstructor = L > 0
-                                             && hasElaborateCopyConstructor!E;
-    }
-    else
-    {
-        enum bool hasElaborateCopyConstructor = is(T == struct)
-                                             && hasMember!(T, "__xpostblit");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(!hasElaborateCopyConstructor!int);
-
-    static struct S
-    {
-        this(this)
-        {
-        }
-    }
-    static struct S1
-    {
-        S s;
-    }
-    static struct S2
-    {
-    }
-    static assert(hasElaborateCopyConstructor!S); // Explicit destructor.
-    static assert(hasElaborateCopyConstructor!S1); // Compiler-generated destructor.
-    static assert(!hasElaborateCopyConstructor!S2); // No destructor.
-    static assert(hasElaborateCopyConstructor!(S[1]));
-    static assert(!hasElaborateCopyConstructor!(S[0]));
-}
-
-/**
- * Determines whether $(D_PARAM T) has an elaborate assign.
- *
- * Only $(D_KEYWORD struct)s and static arrays of $(D_KEYWORD struct)s with the
- * length greater than`0` can have an elaborate assign, for all
- * other types $(D_PSYMBOL hasElaborateAssign) evaluates to $(D_KEYWORD false).
- *
- * An elaborate assign is defined with $(D_INLINECODE opAssign(typeof(this)))
- * or $(D_INLINECODE opAssign(ref typeof(this))). An elaborate assign can be
- * generated for a $(D_KEYWORD struct) by the compiler if one of the members of
- * this $(D_KEYWORD struct) has an elaborate assign.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) has an elaborate assign,
- *          $(D_KEYWORD false) otherwise.
- */
-template hasElaborateAssign(T)
-{
-    static if (is(T E : E[L], size_t L))
-    {
-        enum bool hasElaborateAssign = L > 0 && hasElaborateAssign!E;
-    }
-    else static if (is(T == struct))
-    {
-        private enum bool valueAssign = is(typeof({ T.init.opAssign(T()); }));
-        enum bool hasElaborateAssign = valueAssign || is(typeof({
-            T s;
-            s.opAssign(s);
-        }));
-    }
-    else
-    {
-        enum bool hasElaborateAssign = false;
-    }
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(!hasElaborateAssign!int);
-
-    static struct S1
-    {
-        void opAssign(S1)
-        {
-        }
-    }
-    static struct S2
-    {
-        void opAssign(int)
-        {
-        }
-    }
-    static struct S3
-    {
-        S1 s;
-        alias s this;
-    }
-    static assert(hasElaborateAssign!S1);
-    static assert(!hasElaborateAssign!(const S1));
-    static assert(hasElaborateAssign!(S1[1]));
-    static assert(!hasElaborateAssign!(S1[0]));
-    static assert(!hasElaborateAssign!S2);
-    static assert(hasElaborateAssign!S3);
-
-    static struct S4
-    {
-        void opAssign(S4)
-        {
-        }
-        @disable this(this);
-    }
-    static assert(hasElaborateAssign!S4);
-}
-
-/**
- * Returns all members of $(D_KEYWORD enum) $(D_PARAM T).
- *
- * The members of $(D_PARAM T) are typed as $(D_PARAM T), not as a base type
- * of the enum.
- *
- * $(D_PARAM EnumMembers) returns all members of $(D_PARAM T), also if there
- * are some duplicates.
- *
- * Params:
- *  T = A $(D_KEYWORD enum).
- *
- * Returns: All members of $(D_PARAM T).
- */
-template EnumMembers(T)
-if (is(T == enum))
-{
-    private template getEnumMembers(Args...)
-    {
-        static if (Args.length == 1)
-        {
-            enum T getEnumMembers = __traits(getMember, T, Args[0]);
-        }
-        else
-        {
-            alias getEnumMembers = AliasSeq!(__traits(getMember, T, Args[0]),
-                                             getEnumMembers!(Args[1 .. $]));
-        }
-    }
-    private alias allMembers = AliasSeq!(__traits(allMembers, T));
-    static if (allMembers.length == 1)
-    {
-        alias EnumMembers = AliasSeq!(__traits(getMember, T, allMembers));
-    }
-    else
-    {
-        alias EnumMembers = getEnumMembers!allMembers;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum E : int
-    {
-        one,
-        two,
-        three,
-    }
-    static assert([EnumMembers!E] == [E.one, E.two, E.three]);
-}
-
-// Produces a tuple for an enum with only one member
-@nogc nothrow pure @safe unittest
-{
-    enum E : int
-    {
-        one = 0,
-    }
-    static assert(EnumMembers!E == AliasSeq!0);
-}
-
-/**
- * Different than $(D_INLINECODE T.alignof), which is the same for all class
- * types,  $(D_PSYMBOL classInstanceOf) determines the alignment of the class
- * instance and not of its reference.
- *
- * Params:
- *  T = A class.
- *
- * Returns: Alignment of an instance of the class $(D_PARAM T).
- */
-template classInstanceAlignment(T)
-if (is(T == class))
-{
-    private enum ptrdiff_t pred(U1, U2) = U1.alignof - U2.alignof;
-    private alias Fields = typeof(T.tupleof);
-    enum size_t classInstanceAlignment = Max!(pred, T, Fields).alignof;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class C1
-    {
-    }
-    static assert(classInstanceAlignment!C1 == C1.alignof);
-
-    static struct S
-    {
-        align(8)
-        uint s;
-
-        int i;
-    }
-    class C2
-    {
-        S s;
-    }
-    static assert(classInstanceAlignment!C2 == S.alignof);
-}
-
-/**
- * Tests whether $(D_INLINECODE pred(T)) can be used as condition in an
- * $(D_KEYWORD if)-statement or a ternary operator.
- *
- * $(D_PARAM pred) is an optional parameter. By default $(D_PSYMBOL ifTestable)
- * tests whether $(D_PARAM T) itself is usable as condition in an
- * $(D_KEYWORD if)-statement or a ternary operator, i.e. if it a value of type
- * $(D_PARAM T) can be converted to a boolean.
- *
- * Params:
- *  T    = A type.
- *  pred = Function with one argument.
- *
- * Returns: $(D_KEYWORD true) if $(D_INLINECODE pred(T)) can be used as
- *          condition in an $(D_KEYWORD if)-statement or a ternary operator.
- */
-template ifTestable(T, alias pred = a => a)
-{
-    enum bool ifTestable = is(typeof(pred(T.init) ? true : false));
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(ifTestable!int);
-
-    static struct S1
-    {
-    }
-    static assert(!ifTestable!S1);
-
-    static struct S2
-    {
-        bool opCast(T : bool)()
-        {
-            return true;
-        }
-    }
-    static assert(ifTestable!S2);
-}
-
-/**
- * Returns a compile-time tuple of user-defined attributes (UDA) attached to
- * $(D_PARAM symbol).
- *
- * $(D_PARAM symbol) can be:
- *
- * $(DL
- *  $(DT Template)
- *  $(DD The attribute is matched if it is an instance of the template
- *       $(D_PARAM attr).)
- *  $(DT Type)
- *  $(DD The attribute is matched if it its type is $(D_PARAM attr).)
- *  $(DT Expression)
- *  $(DD The attribute is matched if it equals to $(D_PARAM attr).)
- * )
- *
- * If $(D_PARAM attr) isn't given, all user-defined attributes of
- * $(D_PARAM symbol) are returned.
- *
- * Params:
- *  symbol = A symbol.
- *  attr   = User-defined attribute.
- *
- * Returns: A tuple of user-defined attributes attached to $(D_PARAM symbol)
- *          and matching $(D_PARAM attr).
- *
- * See_Also: $(LINK2 https://dlang.org/spec/attribute.html#uda,
- *                   User Defined Attributes).
- */
-template getUDAs(alias symbol, alias attr)
-{
-    private template FindUDA(T...)
-    {
-        static if (T.length == 0)
-        {
-            alias FindUDA = AliasSeq!();
-        }
-        else static if ((isTypeTuple!attr && is(TypeOf!(T[0]) == attr))
-                     || (is(typeof(T[0] == attr)) && (T[0] == attr))
-                     || isInstanceOf!(attr, TypeOf!(T[0])))
-        {
-            alias FindUDA = AliasSeq!(T[0], FindUDA!(T[1 .. $]));
-        }
-        else
-        {
-            alias FindUDA = FindUDA!(T[1 .. $]);
-        }
-    }
-    alias getUDAs = FindUDA!(__traits(getAttributes, symbol));
-}
-
-///
-alias getUDAs(alias symbol) = AliasSeq!(__traits(getAttributes, symbol));
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct Attr
-    {
-        int i;
-    }
-    @Attr int a;
-    static assert(getUDAs!(a, Attr).length == 1);
-
-    @Attr(8) int b;
-    static assert(getUDAs!(b, Attr).length == 1);
-    static assert(getUDAs!(b, Attr)[0].i == 8);
-    static assert(getUDAs!(b, Attr(8)).length == 1);
-    static assert(getUDAs!(b, Attr(7)).length == 0);
-
-    @("string", 5) int c;
-    static assert(getUDAs!(c, "string").length == 1);
-    static assert(getUDAs!(c, 5).length == 1);
-    static assert(getUDAs!(c, "String").length == 0);
-    static assert(getUDAs!(c, 4).length == 0);
-
-    static struct T(U)
-    {
-        enum U s = 7;
-        U i;
-    }
-    @T!int @T!int(8) int d;
-    static assert(getUDAs!(d, T).length == 2);
-    static assert(getUDAs!(d, T)[0].s == 7);
-    static assert(getUDAs!(d, T)[1].i == 8);
-
-    @T int e;
-    static assert(getUDAs!(e, T).length == 0);
-}
-
-/**
- * Determines whether $(D_PARAM symbol) has user-defined attribute
- * $(D_PARAM attr) attached to it.
- *
- * Params:
- *  symbol = A symbol.
- *  attr   = User-defined attribute.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM symbol) has user-defined attribute
- *          $(D_PARAM attr), $(D_KEYWORD false) otherwise.
- *
- * See_Also: $(LINK2 https://dlang.org/spec/attribute.html#uda,
- *                   User Defined Attributes).
- */
-template hasUDA(alias symbol, alias attr)
-{
-    enum bool hasUDA = getUDAs!(symbol, attr).length != 0;
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct Attr1
-    {
-    }
-    static struct Attr2
-    {
-    }
-    @Attr1 int a;
-    static assert(hasUDA!(a, Attr1));
-    static assert(!hasUDA!(a, Attr2));
-}
-
-/**
- * If $(D_PARAM T) is a type, constructs its default value, otherwise
- * $(D_PSYMBOL evalUDA) aliases itself to $(D_PARAM T).
- *
- * This template is useful when working with UDAs with default parameters,
- * i.e. if an attribute can be given as `@Attr` or `@Attr("param")`,
- * $(D_PSYMBOL evalUDA) makes `@Attr()` from `@Attr`, but returns
- * `@Attr("param")` as is.
- *
- * $(D_PARAM T) (or its type if it isn't a type already) should have a default
- * constructor.
- *
- * Params:
- *  T = User Defined Attribute.
- */
-alias evalUDA(alias T) = T;
-
-/// ditto
-alias evalUDA(T) = Alias!(T());
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct Length
-    {
-        size_t length = 8;
-    }
-    @Length @Length(0) int i;
-    alias uda = AliasSeq!(__traits(getAttributes, i));
-
-    alias attr1 = evalUDA!(uda[0]);
-    alias attr2 = evalUDA!(uda[1]);
-
-    static assert(is(typeof(attr1) == Length));
-    static assert(is(typeof(attr2) == Length));
-
-    static assert(attr1.length == 8);
-    static assert(attr2.length == 0);
-}
-
-/**
- * Tests whether $(D_PARAM T) is an inner class, i.e. a class nested inside
- * another class.
- *
- * All inner classes get `outer` propery automatically generated, which points
- * to its parent class, though it can be explicitly defined to be something
- * different. If $(D_PARAM T) does this, $(D_PSYMBOL isInnerClass)
- * evaluates to $(D_KEYWORD false).
- *
- * Params:
- *  T = Class to be tested.
- *
- * Returns $(D_KEYWORD true) if $(D_PARAM T) is an inner class,
- *         $(D_KEYWORD false) otherwise.
- */
-template isInnerClass(T)
-{
-    static if (is(T == class) && is(typeof(T.outer) == class))
-    {
-        enum bool isInnerClass = !canFind!("outer", __traits(allMembers, T));
-    }
-    else
-    {
-        enum bool isInnerClass = false;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    class A
-    {
-    }
-    class O
-    {
-        class I
-        {
-        }
-        class Fake
-        {
-            bool outer;
-        }
-    }
-    static assert(!isInnerClass!(O));
-    static assert(isInnerClass!(O.I));
-    static assert(!isInnerClass!(O.Fake));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    class RefCountedStore(T)
-    {
-    }
-    static assert(!isInnerClass!(RefCountedStore!int));
-}
-
-/**
- * Returns the types of all members of $(D_PARAM T).
- *
- * If $(D_PARAM T) is a $(D_KEYWORD struct) or $(D_KEYWORD union) or
- * $(D_KEYWORD class), returns the types of all its fields. It is actually the
- * same as `T.tupleof`, but the content pointer for the nested type isn't
- * included.
- *
- * If $(D_PARAM T) is neither a $(D_KEYWORD struct) nor $(D_KEYWORD union) nor
- * $(D_KEYWORD class), $(D_PSYMBOL Fields) returns an $(D_PSYMBOL AliasSeq)
- * with the single element $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_PARAM T)'s fields.
- */
-template Fields(T)
-{
-    static if ((is(T == struct) || is(T == union)) && isNested!T)
-    {
-        // The last element of .tupleof of a nested struct or union is "this",
-        // the context pointer, type "void*".
-        alias Fields = typeof(T.tupleof[0 .. $ - 1]);
-    }
-    else static if (is(T == class) || is(T == struct) || is(T == union))
-    {
-        alias Fields = typeof(T.tupleof);
-    }
-    else
-    {
-        alias Fields = AliasSeq!T;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    struct Nested
-    {
-        int i;
-
-        void func()
-        {
-        }
-    }
-    static assert(is(Fields!Nested == AliasSeq!int));
-
-    class C
-    {
-        uint u;
-    }
-    static assert(is(Fields!C == AliasSeq!uint));
-
-    static assert(is(Fields!short == AliasSeq!short));
-}
-
-/**
- * Determines whether all $(D_PARAM Types) are the same.
- *
- * If $(D_PARAM Types) is empty, returns $(D_KEYWORD true).
- *
- * Params:
- *  Types = Type sequence.
- *
- * Returns: $(D_KEYWORD true) if all $(D_PARAM Types) are the same,
- *          $(D_KEYWORD false) otherwise.
- */
-template allSameType(Types...)
-{
-    static if (Types.length == 0)
-    {
-        enum bool allSameType = true;
-    }
-    else
-    {
-        private enum bool sameType(T) = is(T == Types[0]);
-
-        enum bool allSameType = allSatisfy!(sameType, Types[1 .. $]);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(allSameType!());
-    static assert(allSameType!int);
-    static assert(allSameType!(int, int, int));
-    static assert(!allSameType!(int, uint, int));
-    static assert(!allSameType!(int, uint, short));
-}
-
-/**
- * Determines whether values of type $(D_PARAM T) can be compared for equality,
- * i.e. using `==` or `!=` binary operators.
- *
- * Params:
- *  T = Type to test.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) can be compared for equality,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isEqualityComparable(T) = ifTestable!(T, a => a == a);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isEqualityComparable!int);
-}
-
-/**
- * Determines whether values of type $(D_PARAM T) can be compared for ordering,
- * i.e. using `>`, `>=`, `<` or `<=` binary operators.
- *
- * Params:
- *  T = Type to test.
- *
- * Returns: $(D_KEYWORD true) if $(D_PARAM T) can be compared for ordering,
- *          $(D_KEYWORD false) otherwise.
- */
-enum bool isOrderingComparable(T) = ifTestable!(T, a => a > a);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(isOrderingComparable!int);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static struct DisabledOpEquals
-    {
-        @disable bool opEquals(typeof(this)) @nogc nothrow pure @safe;
-
-        int opCmp(typeof(this)) @nogc nothrow pure @safe
-        {
-            return 0;
-        }
-    }
-    static assert(!isEqualityComparable!DisabledOpEquals);
-    static assert(isOrderingComparable!DisabledOpEquals);
-
-    static struct OpEquals
-    {
-        bool opEquals(typeof(this)) @nogc nothrow pure @safe
-        {
-            return true;
-        }
-    }
-    static assert(isEqualityComparable!OpEquals);
-    static assert(!isOrderingComparable!OpEquals);
-}
diff --git a/meta/source/tanya/meta/transform.d b/meta/source/tanya/meta/transform.d
deleted file mode 100644
index 5697e69..0000000
--- a/meta/source/tanya/meta/transform.d
+++ /dev/null
@@ -1,981 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
- * Type transformations.
- *
- * Templates in this module can be used to modify type qualifiers or transform
- * types. They take some type as argument and return a different type after
- * perfoming the specified transformation.
- *
- * Copyright: Eugene Wissner 2017-2018.
- * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
- *                  Mozilla Public License, v. 2.0).
- * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
- * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/meta/transform.d,
- *                 tanya/meta/transform.d)
- */
-module tanya.meta.transform;
-
-import tanya.meta.metafunction;
-import tanya.meta.trait;
-
-/**
- * Removes any type qualifiers from $(D_PARAM T).
- *
- * Removed qualifiers are:
- * $(UL
- *  $(LI const)
- *  $(LI immutable)
- *  $(LI inout)
- *  $(LI shared)
- * )
- * and combinations of these.
- *
- * If the type $(D_PARAM T) doesn't have any qualifieres,
- * $(D_INLINECODE Unqual!T) becomes an alias for $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_PARAM T) without any type qualifiers.
- */
-template Unqual(T)
-{
-    static if (is(T U == const U)
-            || is(T U == immutable U)
-            || is(T U == inout U)
-            || is(T U == inout const U)
-            || is(T U == shared U)
-            || is(T U == shared const U)
-            || is(T U == shared inout U)
-            || is(T U == shared inout const U))
-    {
-        alias Unqual = U;
-    }
-    else
-    {
-        alias Unqual = T;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Unqual!bool == bool));
-    static assert(is(Unqual!(immutable bool) == bool));
-    static assert(is(Unqual!(inout bool) == bool));
-    static assert(is(Unqual!(inout const bool) == bool));
-    static assert(is(Unqual!(shared bool) == bool));
-    static assert(is(Unqual!(shared const bool) == bool));
-    static assert(is(Unqual!(shared inout const bool) == bool));
-}
-
-/**
- * If $(D_PARAM T) is an $(D_KEYWORD enum), $(D_INLINECODE OriginalType!T)
- * evaluates to the most base type of that $(D_KEYWORD enum) and to
- * $(D_PARAM T) otherwise.
- *
- * Params:
- *  T = A type.
- *
- * Returns: Base type of the $(D_KEYWORD enum) $(D_PARAM T) or $(D_PARAM T)
- *          itself.
- */
-template OriginalType(T)
-{
-    static if (is(T U == enum))
-    {
-        alias OriginalType = OriginalType!U;
-    }
-    else
-    {
-        alias OriginalType = T;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    enum E1 : const(int)
-    {
-        n = 0,
-    }
-    enum E2 : bool
-    {
-        t = true,
-    }
-    enum E3 : E2
-    {
-        t = E2.t,
-    }
-    enum E4 : const(E2)
-    {
-        t = E2.t,
-    }
-
-    static assert(is(OriginalType!E1 == const int));
-    static assert(is(OriginalType!E2 == bool));
-    static assert(is(OriginalType!E3 == bool));
-    static assert(is(OriginalType!E4 == bool));
-    static assert(is(OriginalType!(const E4) == bool));
-}
-
-/**
- * Copies constness of $(D_PARAM From) to $(D_PARAM To).
- *
- * The following type qualifiers affect the constness and hence are copied:
- * $(UL
- *  $(LI const)
- *  $(LI immutable)
- *  $(LI inout)
- *  $(LI inout const)
- * )
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *
- * Returns: $(D_PARAM To) with the constness of $(D_PARAM From).
- *
- * See_Also: $(D_PSYMBOL CopyTypeQualifiers).
- */
-template CopyConstness(From, To)
-{
-    static if (is(From T == immutable T))
-    {
-        alias CopyConstness = immutable To;
-    }
-    else static if (is(From T == const T) || is(From T == shared const T))
-    {
-        alias CopyConstness = const To;
-    }
-    else static if (is(From T == inout T) || is(From T == shared inout T))
-    {
-        alias CopyConstness = inout To;
-    }
-    else static if (is(From T == inout const T)
-                 || is(From T == shared inout const T))
-    {
-        alias CopyConstness = inout const To;
-    }
-    else
-    {
-        alias CopyConstness = To;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(CopyConstness!(int, char) == char));
-    static assert(is(CopyConstness!(const int, char) == const char));
-    static assert(is(CopyConstness!(immutable int, char) == immutable char));
-    static assert(is(CopyConstness!(inout int, char) == inout char));
-    static assert(is(CopyConstness!(inout const int, char) == inout const char));
-
-    static assert(is(CopyConstness!(shared int, char) == char));
-    static assert(is(CopyConstness!(shared const int, char) == const char));
-    static assert(is(CopyConstness!(shared inout int, char) == inout char));
-    static assert(is(CopyConstness!(shared inout const int, char) == inout const char));
-
-    static assert(is(CopyConstness!(const int, shared char) == shared const char));
-    static assert(is(CopyConstness!(const int, immutable char) == immutable char));
-    static assert(is(CopyConstness!(immutable int, const char) == immutable char));
-}
-
-/**
- * Copies type qualifiers of $(D_PARAM From) to $(D_PARAM To).
- *
- * Type qualifiers copied are:
- * $(UL
- *  $(LI const)
- *  $(LI immutable)
- *  $(LI inout)
- *  $(LI shared)
- * )
- * and combinations of these.
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *
- * Returns: $(D_PARAM To) with the type qualifiers of $(D_PARAM From).
- *
- * See_Also: $(D_PSYMBOL CopyConstness).
- */
-template CopyTypeQualifiers(From, To)
-{
-    static if (is(From T == immutable T))
-    {
-        alias CopyTypeQualifiers = immutable To;
-    }
-    else static if (is(From T == const T))
-    {
-        alias CopyTypeQualifiers = const To;
-    }
-    else static if (is(From T == shared T))
-    {
-        alias CopyTypeQualifiers = shared To;
-    }
-    else static if (is(From T == shared const T))
-    {
-        alias CopyTypeQualifiers = shared const To;
-    }
-    else static if (is(From T == inout T))
-    {
-        alias CopyTypeQualifiers = inout To;
-    }
-    else static if (is(From T == shared inout T))
-    {
-        alias CopyTypeQualifiers = shared inout To;
-    }
-    else static if (is(From T == inout const T))
-    {
-        alias CopyTypeQualifiers = inout const To;
-    }
-    else static if (is(From T == shared inout const T))
-    {
-        alias CopyTypeQualifiers = shared inout const To;
-    }
-    else
-    {
-        alias CopyTypeQualifiers = To;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(CopyTypeQualifiers!(int, char) == char));
-    static assert(is(CopyTypeQualifiers!(const int, char) == const char));
-    static assert(is(CopyTypeQualifiers!(immutable int, char) == immutable char));
-    static assert(is(CopyTypeQualifiers!(inout int, char) == inout char));
-    static assert(is(CopyTypeQualifiers!(inout const int, char) == inout const char));
-
-    static assert(is(CopyTypeQualifiers!(shared int, char) == shared char));
-    static assert(is(CopyTypeQualifiers!(shared const int, char) == shared const char));
-    static assert(is(CopyTypeQualifiers!(shared inout int, char) == shared inout char));
-    static assert(is(CopyTypeQualifiers!(shared inout const int, char) == shared inout const char));
-}
-
-/**
- * Evaluates to the unsigned counterpart of the integral type $(D_PARAM T) preserving all type qualifiers.
- * If $(D_PARAM T) is already unsigned, $(D_INLINECODE Unsigned!T) aliases $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: Unsigned counterpart of $(D_PARAM T).
- *
- * See_Also: $(D_PSYMBOL isSigned).
- */
-template Unsigned(T)
-if (isIntegral!T)
-{
-    alias UnqualedType = Unqual!(OriginalType!T);
-    static if (is(UnqualedType == byte))
-    {
-        alias Unsigned = CopyTypeQualifiers!(T, ubyte);
-    }
-    else static if (is(UnqualedType == short))
-    {
-        alias Unsigned = CopyTypeQualifiers!(T, ushort);
-    }
-    else static if (is(UnqualedType == int))
-    {
-        alias Unsigned = CopyTypeQualifiers!(T, uint);
-    }
-    else static if (is(UnqualedType == long))
-    {
-        alias Unsigned = CopyTypeQualifiers!(T, ulong);
-    }
-    else
-    {
-        alias Unsigned = T;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Unsigned!byte == ubyte));
-    static assert(is(Unsigned!short == ushort));
-    static assert(is(Unsigned!int == uint));
-    static assert(is(Unsigned!long == ulong));
-
-    static assert(is(Unsigned!(const byte) == const ubyte));
-    static assert(is(Unsigned!(shared byte) == shared ubyte));
-    static assert(is(Unsigned!(shared const byte) == shared const ubyte));
-
-    static assert(!is(Unsigned!float));
-    static assert(is(Unsigned!ubyte == ubyte));
-}
-
-/**
- * Evaluates to the signed counterpart of the integral type $(D_PARAM T) preserving all type qualifiers.
- * If $(D_PARAM T) is already signed, $(D_INLINECODE Signed!T) aliases $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: Signed counterpart of $(D_PARAM T).
- *
- * See_Also: $(D_PSYMBOL isUnsigned).
- */
-template Signed(T)
-if (isIntegral!T)
-{
-    alias UnqualedType = Unqual!(OriginalType!T);
-    static if (is(UnqualedType == ubyte))
-    {
-        alias Signed = CopyTypeQualifiers!(T, byte);
-    }
-    else static if (is(UnqualedType == ushort))
-    {
-        alias Signed = CopyTypeQualifiers!(T, short);
-    }
-    else static if (is(UnqualedType == uint))
-    {
-        alias Signed = CopyTypeQualifiers!(T, int);
-    }
-    else static if (is(UnqualedType == ulong))
-    {
-        alias Signed = CopyTypeQualifiers!(T, long);
-    }
-    else
-    {
-        alias Signed = T;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Signed!ubyte == byte));
-    static assert(is(Signed!ushort == short));
-    static assert(is(Signed!uint == int));
-    static assert(is(Signed!ulong == long));
-
-    static assert(is(Signed!(const ubyte) == const byte));
-    static assert(is(Signed!(shared ubyte) == shared byte));
-    static assert(is(Signed!(shared const ubyte) == shared const byte));
-
-    static assert(!is(Signed!float));
-    static assert(is(Signed!byte == byte));
-}
-
-/**
- * Retrieves the target type `U` of a pointer `U*`.
- *
- * Params:
- *  T = Pointer type.
- *
- * Returns: Pointer target type.
- */
-template PointerTarget(T)
-{
-    static if (is(T U : U*))
-    {
-        alias PointerTarget = U;
-    }
-    else
-    {
-        static assert(T.stringof ~ " isn't a pointer type");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(PointerTarget!(bool*) == bool));
-    static assert(is(PointerTarget!(const bool*) == const bool));
-    static assert(is(PointerTarget!(const shared bool*) == const shared bool));
-    static assert(!is(PointerTarget!bool));
-}
-
-/**
- * Params:
- *  T = The type of the associative array.
- *
- * Returns: The key type of the associative array $(D_PARAM T).
- */
-template KeyType(T)
-{
-    static if (is(T V : V[K], K))
-    {
-        alias KeyType = K;
-    }
-    else
-    {
-        static assert(false, T.stringof ~ " isn't an associative array");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(KeyType!(int[string]) == string));
-    static assert(!is(KeyType!(int[15])));
-}
-
-/**
- * Params:
- *  T = The type of the associative array.
- *
- * Returns: The value type of the associative array $(D_PARAM T).
- */
-template ValueType(T)
-{
-    static if (is(T V : V[K], K))
-    {
-        alias ValueType = V;
-    }
-    else
-    {
-        static assert(false, T.stringof ~ " isn't an associative array");
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ValueType!(int[string]) == int));
-    static assert(!is(ValueType!(int[15])));
-}
-
-/**
- * Params:
- *  T = Scalar type.
- *
- * Returns: The type $(D_PARAM T) will promote to.
- *
- * See_Also: $(LINK2 https://dlang.org/spec/type.html#integer-promotions,
- *                   Integer Promotions).
- */
-template Promoted(T)
-if (isScalarType!T)
-{
-    alias Promoted = CopyTypeQualifiers!(T, typeof(T.init + T.init));
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Promoted!bool == int));
-    static assert(is(Promoted!byte == int));
-    static assert(is(Promoted!ubyte == int));
-    static assert(is(Promoted!short == int));
-    static assert(is(Promoted!ushort == int));
-    static assert(is(Promoted!char == int));
-    static assert(is(Promoted!wchar == int));
-    static assert(is(Promoted!dchar == uint));
-
-    static assert(is(Promoted!(const bool) == const int));
-    static assert(is(Promoted!(shared bool) == shared int));
-}
-
-/**
- * Adds $(D_KEYWORD inout) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(T)).
- */
-alias InoutOf(T) = inout(T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(InoutOf!int == inout int));
-}
-
-/**
- * Adds $(D_KEYWORD inout) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(T)).
- */
-alias ConstOf(T) = const(T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ConstOf!int == const int));
-}
-
-/**
- * Adds $(D_KEYWORD inout) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(T)).
- */
-alias SharedOf(T) = shared(T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SharedOf!int == shared int));
-}
-
-/**
- * Adds $(D_KEYWORD inout) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(T)).
- */
-alias SharedInoutOf(T) = shared(inout T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SharedInoutOf!int == shared inout int));
-}
-
-/**
- * Adds $(D_KEYWORD shared const) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE shared(const T)).
- */
-alias SharedConstOf(T) = shared(const T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SharedConstOf!int == shared const int));
-}
-
-/**
- * Adds $(D_KEYWORD immutable) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE immutable(T)).
- */
-alias ImmutableOf(T) = immutable(T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(ImmutableOf!int == immutable int));
-}
-
-/**
- * Adds $(D_KEYWORD inout const) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE inout(const T)).
- */
-alias InoutConstOf(T) = inout(const T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(InoutConstOf!int == inout const int));
-}
-
-/**
- * Adds $(D_KEYWORD shared inout const) qualifier to the type $(D_PARAM T).
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE shared(inout const T)).
- */
-alias SharedInoutConstOf(T) = shared(inout const T);
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(SharedInoutConstOf!int == shared inout const int));
-}
-
-/**
- * Returns a template with one argument which applies all qualifiers of
- * $(D_PARAM T) on its argument if instantiated.
- *
- * Params:
- *  T = A type.
- *
- * Returns: $(D_INLINECODE shared(inout const T)).
- */
-template QualifierOf(T)
-{
-    static if (is(T U == const U))
-    {
-        alias QualifierOf = ConstOf;
-    }
-    else static if (is(T U == immutable U))
-    {
-        alias QualifierOf = ImmutableOf;
-    }
-    else static if (is(T U == inout U))
-    {
-        alias QualifierOf = InoutOf;
-    }
-    else static if (is(T U == inout const U))
-    {
-        alias QualifierOf = InoutConstOf;
-    }
-    else static if (is(T U == shared U))
-    {
-        alias QualifierOf = SharedOf;
-    }
-    else static if (is(T U == shared const U))
-    {
-        alias QualifierOf = SharedConstOf;
-    }
-    else static if (is(T U == shared inout U))
-    {
-        alias QualifierOf = SharedInoutOf;
-    }
-    else static if (is(T U == shared inout const U))
-    {
-        alias QualifierOf = SharedInoutConstOf;
-    }
-    else
-    {
-        alias QualifierOf(T) = T;
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    alias MutableOf = QualifierOf!int;
-    static assert(is(MutableOf!uint == uint));
-
-    alias ConstOf = QualifierOf!(const int);
-    static assert(is(ConstOf!uint == const uint));
-
-    alias InoutOf = QualifierOf!(inout int);
-    static assert(is(InoutOf!uint == inout uint));
-
-    alias InoutConstOf = QualifierOf!(inout const int);
-    static assert(is(InoutConstOf!uint == inout const uint));
-
-    alias ImmutableOf = QualifierOf!(immutable int);
-    static assert(is(ImmutableOf!uint == immutable uint));
-
-    alias SharedOf = QualifierOf!(shared int);
-    static assert(is(SharedOf!uint == shared uint));
-
-    alias SharedConstOf = QualifierOf!(shared const int);
-    static assert(is(SharedConstOf!uint == shared const uint));
-
-    alias SharedInoutOf = QualifierOf!(shared inout int);
-    static assert(is(SharedInoutOf!uint == shared inout uint));
-
-    alias SharedInoutConstOf = QualifierOf!(shared inout const int);
-    static assert(is(SharedInoutConstOf!uint == shared inout const uint));
-}
-
-/**
- * Determines the type of $(D_PARAM T). If $(D_PARAM T) is already a type,
- * $(D_PSYMBOL TypeOf) aliases itself to $(D_PARAM T).
- *
- * $(D_PSYMBOL TypeOf) evaluates to $(D_KEYWORD void) for template arguments.
- *
- * The symbols that don't have a type and aren't types cannot be used as
- * arguments to $(D_PSYMBOL TypeOf).
- *
- * Params:
- *  T = Expression, type or template.
- *
- * Returns: The type of $(D_PARAM T).
- */
-alias TypeOf(T) = T;
-
-/// ditto
-template TypeOf(alias T)
-if (isExpressions!T || __traits(isTemplate, T))
-{
-    alias TypeOf = typeof(T);
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    struct S(T)
-    {
-    }
-    static assert(is(TypeOf!S == void));
-    static assert(is(TypeOf!int == int));
-    static assert(is(TypeOf!true == bool));
-    static assert(!is(TypeOf!(tanya.meta)));
-}
-
-// e.g. returns int for int**.
-private template FinalPointerTarget(T)
-{
-    static if (isPointer!T)
-    {
-        alias FinalPointerTarget = FinalPointerTarget!(PointerTarget!T);
-    }
-    else
-    {
-        alias FinalPointerTarget = T;
-    }
-}
-
-// Returns true if T1 is void* and T2 is some pointer.
-private template voidAndPointer(T1, T2)
-{
-    enum bool voidAndPointer = is(Unqual!(PointerTarget!T1) == void)
-                            && isPointer!T2;
-}
-
-// Type returned by the ternary operator.
-private alias TernaryType(T, U) = typeof(true ? T.init : U.init);
-
-/**
- * Determines the type all $(D_PARAM Args) can be implicitly converted to.
- *
- * $(OL
- *  $(LI If one of the arguments is $(D_KEYWORD void), the common type is
- *       $(D_KEYWORD void).)
- *  $(LI The common type of integers with the same sign is the type with a
- *       larger size. Signed and unsigned integers don't have a common type.
- *       Type qualifiers are only preserved if all arguments are the same
- *       type.)
- *  $(LI The common type of floating point numbers is the type with more
- *       precision. Type qualifiers are only preserved if all arguments are
- *       the same type.)
- *  $(LI The common type of polymorphic objects is the next, more generic type
- *       both objects inherit from, e.g. $(D_PSYMBOL Object).)
- *  $(LI `void*` is concerned as a common type of pointers only if one of the
- *       arguments is a void pointer.)
- *  $(LI Other types have a common type only if their pointers have a common
- *       type. It means that for example $(D_KEYWORD bool) and $(D_KEYWORD int)
-         don't have a common type. If the types fullfill this condition, the
-         common type is determined with the ternary operator, i.e.
-         `typeof(true ? T1.init : T2.init)` is evaluated.)
- * )
- *
- * If $(D_PARAM Args) don't have a common type, $(D_PSYMBOL CommonType) is
- * $(D_KEYWORD void).
- *
- * Params:
- *  Args = Type list.
- *
- * Returns: Common type for $(D_PARAM Args) or $(D_KEYWORD void) if
- *          $(D_PARAM Args) don't have a common type.
- */
-template CommonType(Args...)
-if (allSatisfy!(isType, Args))
-{
-    static if (Args.length == 0
-            || is(Unqual!(Args[0]) == void)
-            || is(Unqual!(Args[1]) == void))
-    {
-        alias CommonType = void;
-    }
-    else static if (Args.length == 1)
-    {
-        alias CommonType = Args[0];
-    }
-    else
-    {
-        private alias Pair = Args[0 .. 2];
-        private enum bool sameSigned = allSatisfy!(isIntegral, Pair)
-                                    && isSigned!(Args[0]) == isSigned!(Args[1]);
-
-        static if (is(Args[0] == Args[1]))
-        {
-            alias CommonType = CommonType!(Args[0], Args[2 .. $]);
-        }
-        else static if (sameSigned || allSatisfy!(isFloatingPoint, Pair))
-        {
-            alias CommonType = CommonType!(Unqual!(Largest!Pair),
-                                           Args[2 .. $]);
-        }
-        else static if (voidAndPointer!Pair
-                     || voidAndPointer!(Args[1], Args[0]))
-        {
-            // Workaround for https://issues.dlang.org/show_bug.cgi?id=15557.
-            // Determine the qualifiers returned by the ternary operator as if
-            // both pointers were int*. Then copy the qualifiers to void*.
-            alias P1 = CopyTypeQualifiers!(FinalPointerTarget!(Args[0]), int)*;
-            alias P2 = CopyTypeQualifiers!(FinalPointerTarget!(Args[1]), int)*;
-            static if (is(TernaryType!(P1, P2) U))
-            {
-                alias CommonType = CopyTypeQualifiers!(PointerTarget!U, void)*;
-            }
-            else
-            {
-                alias CommonType = void;
-            }
-        }
-        else static if ((isPointer!(Args[0]) || isPolymorphicType!(Args[0]))
-                     && is(TernaryType!Pair U))
-        {
-            alias CommonType = CommonType!(U, Args[2 .. $]);
-        }
-        else static if (is(TernaryType!(Args[0]*, Args[1]*)))
-        {
-            alias CommonType = CommonType!(TernaryType!Pair, Args[2 .. $]);
-        }
-        else
-        {
-            alias CommonType = void;
-        }
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(CommonType!(int, int, int) == int));
-    static assert(is(CommonType!(ubyte, ushort, uint) == uint));
-    static assert(is(CommonType!(int, uint) == void));
-
-    static assert(is(CommonType!(int, const int) == int));
-    static assert(is(CommonType!(const int, const int) == const int));
-
-    static assert(is(CommonType!(int[], const(int)[]) == const(int)[]));
-    static assert(is(CommonType!(string, char[]) == const(char)[]));
-
-    class A
-    {
-    }
-    static assert(is(CommonType!(const A, Object) == const Object));
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(CommonType!(void*, int*) == void*));
-    static assert(is(CommonType!(void*, const(int)*) == const(void)*));
-    static assert(is(CommonType!(void*, const(void)*) == const(void)*));
-    static assert(is(CommonType!(int*, void*) == void*));
-    static assert(is(CommonType!(const(int)*, void*) == const(void)*));
-    static assert(is(CommonType!(const(void)*, void*) == const(void)*));
-
-    static assert(is(CommonType!() == void));
-    static assert(is(CommonType!(int*, const(int)*) == const(int)*));
-    static assert(is(CommonType!(int**, const(int)**) == const(int*)*));
-
-    static assert(is(CommonType!(float, double) == double));
-    static assert(is(CommonType!(float, int) == void));
-
-    static assert(is(CommonType!(bool, const bool) == bool));
-    static assert(is(CommonType!(int, bool) == void));
-    static assert(is(CommonType!(int, void) == void));
-    static assert(is(CommonType!(Object, void*) == void));
-
-    class A
-    {
-    }
-    static assert(is(CommonType!(A, Object) == Object));
-    static assert(is(CommonType!(const(A)*, Object*) == const(Object)*));
-    static assert(is(CommonType!(A, typeof(null)) == A));
-
-    class B : A
-    {
-    }
-    class C : A
-    {
-    }
-    static assert(is(CommonType!(B, C) == A));
-
-    static struct S
-    {
-        int opCast(T : int)()
-        {
-            return 1;
-        }
-    }
-    static assert(is(CommonType!(S, int) == void));
-    static assert(is(CommonType!(const S, S) == const S));
-}
-
-/**
- * Finds the type with the smallest size in the $(D_PARAM Args) list. If
- * several types have the same type, the leftmost is returned.
- *
- * Params:
- *  Args = Type list.
- *
- * Returns: The smallest type.
- *
- * See_Also: $(D_PSYMBOL Largest).
- */
-template Smallest(Args...)
-if (Args.length >= 1)
-{
-    static assert(is(Args[0]), T.stringof ~ " doesn't have .sizeof property");
-
-    static if (Args.length == 1)
-    {
-        alias Smallest = Args[0];
-    }
-    else static if (Smallest!(Args[1 .. $]).sizeof < Args[0].sizeof)
-    {
-        alias Smallest = Smallest!(Args[1 .. $]);
-    }
-    else
-    {
-        alias Smallest = Args[0];
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Smallest!(int, ushort, uint, short) == ushort));
-    static assert(is(Smallest!(short) == short));
-    static assert(is(Smallest!(ubyte[8], ubyte[5]) == ubyte[5]));
-    static assert(!is(Smallest!(short, 5)));
-}
-
-/**
- * Finds the type with the largest size in the $(D_PARAM Args) list. If several
- * types have the same type, the leftmost is returned.
- *
- * Params:
- *  Args = Type list.
- *
- * Returns: The largest type.
- *
- * See_Also: $(D_PSYMBOL Smallest).
- */
-template Largest(Args...)
-if (Args.length >= 1)
-{
-    static assert(is(Args[0]), T.stringof ~ " doesn't have .sizeof property");
-
-    static if (Args.length == 1)
-    {
-        alias Largest = Args[0];
-    }
-    else static if (Largest!(Args[1 .. $]).sizeof > Args[0].sizeof)
-    {
-        alias Largest = Largest!(Args[1 .. $]);
-    }
-    else
-    {
-        alias Largest = Args[0];
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(Largest!(int, short, uint) == int));
-    static assert(is(Largest!(short) == short));
-    static assert(is(Largest!(ubyte[8], ubyte[5]) == ubyte[8]));
-    static assert(!is(Largest!(short, 5)));
-}