diff --git a/source/tanya/meta/metafunction.d b/source/tanya/meta/metafunction.d
index ac25768..6c46acf 100644
--- a/source/tanya/meta/metafunction.d
+++ b/source/tanya/meta/metafunction.d
@@ -15,9 +15,40 @@
  */
 module tanya.meta.metafunction;
 
+import tanya.meta.trait;
+
 version (unittest)
 {
-    import tanya.meta.trait;
+    import tanya.meta.transform;
+}
+
+// Used for sorting.
+private template lessEqual(alias cmp, Args...)
+if (Args.length == 2)
+{
+    enum result = cmp!(Args[1], Args[0]);
+    static if (is(typeof(result) == bool))
+    {
+        enum bool lessEqual = !result;
+    }
+    else
+    {
+        enum bool lessEqual = result >= 0;
+    }
+}
+
+private template equalTo(Args...)
+if (Args.length == 2)
+{
+    static if ((is(typeof(Args[0] == Args[1])) && (Args[0] == Args[1]))
+            || is(Args[0] == Args[1]))
+    {
+        enum bool equalTo = true;
+    }
+    else
+    {
+        enum bool equalTo = false;
+    }
 }
 
 /**
@@ -165,8 +196,7 @@ if (Args.length > 0)
     {
         enum ptrdiff_t indexOf = -1;
     }
-    else static if (is(Args[0] == Args[1])
-                 || (is(typeof(Args[0] == Args[1])) && (Args[0] == Args[1])))
+    else static if (equalTo!(Args[0 .. 2]))
     {
         enum ptrdiff_t indexOf = i;
     }
@@ -185,7 +215,7 @@ if (Args.length > 0)
  *  T = The type to search for.
  *  L = Type list.
  *
- * Returns: The index of the first occurence of $(D_PARAM T) in $(D_PARAM L).
+ * Returns: The index of the first occurrence of $(D_PARAM T) in $(D_PARAM L).
  */
 template staticIndexOf(T, L...)
 {
@@ -346,8 +376,8 @@ pure nothrow @safe @nogc unittest
  * )
  *
  * Params:
- *  cmp = Comparison template.
- *  L   = Arguments.
+ *  cmp = Sorting template predicate.
+ *  L   = Elements to be tested.
  *
  * Returns: $(D_KEYWORD true) if $(D_PARAM L) is sorted, $(D_KEYWORD false)
  *          if not.
@@ -360,19 +390,10 @@ template staticIsSorted(alias cmp, L...)
     }
     else
     {
-        // `L` is sorted if the both halves are sorted.
-        enum bool halves = staticIsSorted!(cmp, L[0 .. $ / 2])
-                        && staticIsSorted!(cmp, L[$ / 2 .. $]);
-        // Compare the boundary values of the havles.
-        enum result = cmp!(L[$ / 2], L[$ / 2 - 1]);
-        static if (is(typeof(result) == bool))
-        {
-            enum bool staticIsSorted = !result && halves;
-        }
-        else
-        {
-            enum bool staticIsSorted = result >= 0 && halves;
-        }
+        // `L` is sorted if the both halves and the boundary values are sorted.
+        enum bool staticIsSorted = lessEqual!(cmp, L[$ / 2 - 1], L[$ / 2])
+                                && staticIsSorted!(cmp, L[0 .. $ / 2])
+                                && staticIsSorted!(cmp, L[$ / 2 .. $]);
     }
 }
 
@@ -451,3 +472,541 @@ pure nothrow @safe @nogc unittest
     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));
+    }
+}
+
+///
+pure nothrow @safe @nogc 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 (equalTo!(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);
+}
+
+///
+pure nothrow @safe @nogc 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 (equalTo!(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);
+}
+
+///
+pure nothrow @safe @nogc 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]));
+    }
+}
+
+///
+pure nothrow @safe @nogc 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 staticMap(alias F, T...)
+{
+    static if (T.length == 0)
+    {
+        alias staticMap = AliasSeq!();
+    }
+    else
+    {
+        alias staticMap = AliasSeq!(F!(T[0]), staticMap!(F, T[1 .. $]));
+    }
+}
+
+///
+pure nothrow @safe @nogc unittest
+{
+    static assert(is(staticMap!(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 staticSort(alias cmp, L...)
+{
+    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 && lessEqual!(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 staticSort = L;
+    }
+    else
+    {
+        private alias Left = staticSort!(cmp, L[0 .. $ / 2]);
+        private alias Right = staticSort!(cmp, L[$ / 2 .. $]);
+        alias staticSort = merge!(0, 0);
+    }
+}
+
+///
+pure nothrow @safe @nogc unittest
+{
+    enum cmp(T, U) = T.sizeof < U.sizeof;
+    static assert(is(staticSort!(cmp, long, short, byte, int)
+               == AliasSeq!(byte, short, int, long)));
+}
+
+private pure nothrow @safe @nogc unittest
+{
+    enum cmp(int T, int U) = T - U;
+    static assert(staticSort!(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 = staticSort!(DerivedToFrontCmp, L);
+}
+
+///
+pure nothrow @safe @nogc 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 .. $]);
+    }
+}
+
+///
+pure nothrow @safe @nogc 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 (equalTo!(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);
+}
+
+///
+pure nothrow @safe @nogc 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 (equalTo!(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);
+}
+
+///
+pure nothrow @safe @nogc 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 .. $]);
+    }
+}
+
+///
+pure nothrow @safe @nogc unittest
+{
+    static assert(is(Filter!(isIntegral, real, int, bool, uint) == 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);
+    }
+}
+
+///
+pure nothrow @safe @nogc unittest
+{
+    alias Types = AliasSeq!(int, uint, int, short, short, uint);
+    static assert(is(NoDuplicates!Types == 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));
+    }
+}
+
+///
+pure nothrow @safe @nogc unittest
+{
+    foreach (i, e; aliasSeqOf!([0, 1, 2, 3]))
+    {
+        static assert(i == e);
+    }
+}
diff --git a/source/tanya/meta/trait.d b/source/tanya/meta/trait.d
index c4a79b8..7291aae 100644
--- a/source/tanya/meta/trait.d
+++ b/source/tanya/meta/trait.d
@@ -1624,7 +1624,7 @@ pure nothrow @safe @nogc unittest
  * Returns: Type of the function $(D_PARAM F).
  */
 template FunctionTypeOf(F...)
-if (F.length == 1 && isCallable!F)
+if (isCallable!F)
 {
     static if ((is(typeof(F[0]) T : T*) && is(T == function))
             || (is(F[0] T : T*) && is(T == function))
@@ -1705,3 +1705,22 @@ private pure nothrow @safe @nogc unittest
     static assert(is(FunctionTypeOf!S2 == function));
     static assert(is(FunctionTypeOf!s2 == function));
 }
+
+/**
+ * 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");
+    }
+}