net.ip.Address6.toString() recommended notation

Fix #65.

.gitignore

@@ -10,7 +10,7 @@ dub.selections.json
 __test__*__
 __test__*__.core
 /tanya-test-*
-/dub_platform_probe-*
+/dub_platform_probe[_-]*
 
 /docs/
 /docs.json

.travis.yml

@@ -1,37 +1,62 @@
 sudo: false
 
 os:
-  - linux
-  - osx
+- linux
+- osx
 
 language: d
 
 d:
-  - dmd-2.082.0
-  - dmd-2.081.2
+- dmd-2.084.1
+- dmd-2.083.1
+- dmd-2.082.1
 
 env:
+  global:
+  - LATEST=2.084.1
+
   matrix:
-    - ARCH=x86_64
-    - ARCH=x86
+  - ARCH=x86_64
+  - ARCH=x86
+
+matrix:
+  include:
+  - name: D-Scanner
+    d: dmd-$LATEST
+    env: DSCANNER=0.6.0
+    os: linux
+  - name: DDoc
+    d: dmd-$LATEST
+    env: DDOC=true
+    os: linux
+  allow_failures:
+  - name: D-Scanner
+    d: dmd-$LATEST
+    env: DSCANNER=0.6.0
+    os: linux
 
 addons:
   apt:
     packages:
-      - gcc-multilib
+    - gcc-multilib
 
 before_script:
-  - if [ "`$DC --version | head -n 1 | grep 'v2.082.0'`" ]; then
-      export UNITTEST="unittest-cov";
-    fi
+- if [ "`$DC --version | head -n 1 | grep v$LATEST`" ] &&
+     [ -z "$DSCANNER$DDOC" ]; then
+    export UNITTEST="unittest-cov";
+  fi
 
 script:
-  - dub test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC
-  - if [ "$UNITTEST" ] && [ "$ARCH" = "x86_64" ] && [ "$TRAVIS_OS_NAME" = "linux" ];
-    then
-      dub fetch dscanner --version=0.5.10;
-      dub run dscanner -- --styleCheck ./source/;
-    fi
+- if [ -n "$DDOC" ]; then
+    dub build -b ddox --compiler=$DC;
+  elif [ -z "$DSCANNER" ]; then
+    dub test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+  else
+    dub fetch dscanner --version=$DSCANNER;
+
+    FILES=$(find source -type f);
+    dub run dscanner -- --styleCheck $FILES;
+  fi
 
 after_success:
-  - test "$UNITTEST" && bash <(curl -s https://codecov.io/bash)
+- test "$UNITTEST" && bash <(curl -s https://codecov.io/bash)

README.md

@@ -25,6 +25,7 @@ Tanya consists of the following packages and (top-level) modules:
 
 * `algorithm`: Collection of generic algorithms.
 * `async`: Event loop (epoll, kqueue and IOCP).
+* `bitmanip`: Bit manipulation.
 * `container`: Queue, Array, Singly and doubly linked lists, Buffers, UTF-8
 string, Set, Hash table.
 * `conv`: This module provides functions for converting between different
@@ -172,10 +173,11 @@ parameter is used)
 
 ### Supported compilers
 
-| DMD     | GCC    |
-|:-------:|:------:|
-| 2.082.0 | gdc-8  |
-| 2.081.2 | gdc-7  |
+| DMD     | GCC             |
+|:-------:|:---------------:|
+| 2.084.1 | gdc-8 (2.081.2) |
+| 2.083.1 | gdc-7 (2.081.2) |
+| 2.082.1 |                 |
 
 ### Release management
 

appveyor.yml

@@ -4,16 +4,22 @@ os: Visual Studio 2015
 environment:
   matrix:
     - DC: dmd
-      DVersion: 2.082.0
+      DVersion: 2.084.1
       arch: x64
     - DC: dmd
-      DVersion: 2.082.0
+      DVersion: 2.084.1
       arch: x86
     - DC: dmd
-      DVersion: 2.081.2
+      DVersion: 2.083.1
       arch: x64
     - DC: dmd
-      DVersion: 2.081.2
+      DVersion: 2.083.1
+      arch: x86
+    - DC: dmd
+      DVersion: 2.082.1
+      arch: x64
+    - DC: dmd
+      DVersion: 2.082.1
       arch: x86
 
 skip_tags: true

arch/build.ninja

@@ -6,9 +6,9 @@ rule archive
 
 build abs.o: gas x64/linux/math/abs.S
 build log.o: gas x64/linux/math/log.S
-build cmp.o: gas x64/linux/memory/cmp.S
+build equal.o: gas x64/linux/memory/equal.S
 build fill.o: gas x64/linux/memory/fill.S
 build copy.o: gas x64/linux/memory/copy.S
 build syscall.o: gas x64/linux/syscall.S
 
-build tanya.a: archive syscall.o copy.o fill.o cmp.o log.o abs.o
+build tanya.a: archive syscall.o copy.o fill.o equal.o log.o abs.o

arch/x64/linux/memory/equal.S

@@ -1,20 +1,19 @@
 	.text
 
 /*
- * cmpMemory.
+ * equalMemory.
  *
  * rdi - r1 length
  * rsi - r1 data.
  * rdx - r2 length.
  * rcx - r2 data.
  */
-	.globl _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi
-	.type _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi, @function
-_D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi:
+	.globl _D5tanya6memory2op11equalMemoryFNaNbNixAvxQdZb
+	.type _D5tanya6memory2op11equalMemoryFNaNbNixAvxQdZb, @function
+_D5tanya6memory2op11equalMemoryFNaNbNixAvxQdZb:
 		// Compare the lengths
 		cmp %rdx, %rdi
-		jl  less
-		jg  greater
+		jne not_equal
 
 		mov %rcx, %rdi
 
@@ -26,8 +25,7 @@ _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi:
 
 	naligned:
 		cmpsb
-		jl less
-		jg greater
+		jne not_equal
 
 		dec %rdx
 		test $0x07, %edi
@@ -38,8 +36,7 @@ _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi:
 		shr $0x03, %rcx
 
 		repe cmpsq
-		jl less
-		jg greater
+		jne not_equal
 
 		and $0x07, %edx
 		jz equal
@@ -49,19 +46,14 @@ _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi:
 		cmp $0x0, %rcx
 
 		repe cmpsb
-		jl less
-		jg greater
+		jne not_equal
 
 	equal:
+		mov $0x01, %rax // Return 1
+		jmp end
+
+	not_equal:
 		xor %rax, %rax // Return 0
-		jmp end
-
-	greater:
-		mov $0x01, %rax
-		jmp end
-
-	less:
-		mov $-0x01, %rax
 
 	end:
 		ret

source/tanya/algorithm/comparison.d

@@ -15,8 +15,8 @@
 module tanya.algorithm.comparison;
 
 import tanya.algorithm.mutation;
-import tanya.math : isNaN;
-import tanya.memory.op;
+import tanya.math;
+static import tanya.memory.op;
 import tanya.meta.metafunction;
 import tanya.meta.trait;
 import tanya.meta.transform;
@@ -278,22 +278,25 @@ if (isForwardRange!Range && isOrderingComparable!(ElementType!Range))
  * If the ranges have different lengths, they aren't equal.
  *
  * Params:
- *  R1 = First range type.
- *  R2 = Second range type.
- *  r1 = First range.
- *  r2 = Second range.
+ *  pred = Predicate used to compare individual element pairs.
+ *  R1   = First range type.
+ *  R2   = Second range type.
+ *  r1   = First range.
+ *  r2   = Second range.
  *
  * Returns: $(D_KEYWORD true) if both ranges are equal, $(D_KEYWORD false)
  *          otherwise.
  */
-bool equal(R1, R2)(R1 r1, R2 r2)
-if (allSatisfy!(isInputRange, R1, R2) && is(typeof(r1.front == r2.front)))
+bool equal(alias pred = (auto ref a, auto ref b) => a == b, R1, R2)
+          (R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(pred(r1.front, r2.front)) == bool))
 {
     static if (isDynamicArray!R1
             && is(R1 == R2)
             && __traits(isPOD, ElementType!R1))
     {
-        return cmp(r1, r2) == 0;
+        return tanya.memory.op.equal(r1, r2);
     }
     else
     {
@@ -306,7 +309,7 @@ if (allSatisfy!(isInputRange, R1, R2) && is(typeof(r1.front == r2.front)))
         }
         for (; !r1.empty && !r2.empty; r1.popFront(), r2.popFront())
         {
-            if (r1.front != r2.front)
+            if (!pred(r1.front, r2.front))
             {
                 return false;
             }
@@ -331,3 +334,130 @@ if (allSatisfy!(isInputRange, R1, R2) && is(typeof(r1.front == r2.front)))
     int[3] range2 = [1, 2, 3];
     assert(!equal(range1[], range2[]));
 }
+
+/**
+ * Compares element-wise two ranges for ordering.
+ *
+ * $(D_PSYMBOL compare) returns a negative value if $(D_PARAM r1) is less than
+ * $(D_PARAM r2), a positive value if $(D_PARAM r2) is less than $(D_PARAM r1),
+ * or `0` if $(D_PARAM r1) and $(D_PARAM r2) equal.
+ *
+ * $(D_PSYMBOL compare) iterates both ranges in lockstep. Whichever of them
+ * contains an element that is greater than the respective element at the same
+ * position in the other range is the greater one of the two.
+ *
+ * If one of the ranges becomes empty when iterating, but all elements equal so
+ * far, the range with more elements is the greater one.
+ *
+ * If $(D_PARAM pred) is given, it is used for comparison. $(D_PARAM pred) is
+ * called as $(D_INLINECODE pred(r1.front, r2.front)) and
+ * $(D_INLINECODE pred(r2.front, r1.front)) to perform three-way comparison.
+ * $(D_PARAM pred) should return a $(D_KEYWORD bool).
+ *
+ * If $(D_PARAM pred) is not given, but the element type of $(D_PARAM R1)
+ * defines `opCmp()` for the element type of $(D_PARAM R2), `opCmp()` is used.
+ *
+ * Otherwise the comparison is perfomed using the basic comparison operators.
+ *
+ * Params:
+ *  pred = Predicate used for comparison.
+ *  R1   = First range type.
+ *  R2   = Second range type.
+ *  r1   = First range.
+ *  r2   = Second range.
+ *
+ * Returns: A negative value if $(D_PARAM r1) is less than $(D_PARAM r2), a
+ *          positive value if $D(_PARAM r2) is less than $(D_PARAM r1), `0`
+ *          otherwise.
+ */
+int compare(alias pred, R1, R2)(R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(pred(r1.front, r2.front)) == bool)
+ && is(typeof(pred(r2.front, r1.front)) == bool))
+{
+    alias predImpl = (ref r1, ref r2) {
+        return pred(r2.front, r1.front) - pred(r1.front, r2.front);
+    };
+    return compareImpl!(predImpl, R1, R2)(r1, r2);
+}
+
+/// ditto
+int compare(R1, R2)(R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(r1.front < r2.front || r2.front < r1.front)))
+{
+    static if (is(typeof(r1.front.opCmp(r2.front)) == int))
+    {
+        alias pred = (ref r1, ref r2) => r1.front.opCmp(r2.front);
+    }
+    else
+    {
+        alias pred = (ref r1, ref r2) {
+            return (r2.front < r1.front) - (r1.front < r2.front);
+        };
+    }
+    return compareImpl!(pred, R1, R2)(r1, r2);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(compare("abc", "abc") == 0);
+    assert(compare("abcd", "abc") > 0);
+    assert(compare("ab", "abc") < 0);
+    assert(compare("abc", "abcd") < 0);
+    assert(compare("abc", "ab") > 0);
+    assert(compare("aec", "abc") > 0);
+    assert(compare("aac", "abc") < 0);
+    assert(compare("abc", "aec") < 0);
+    assert(compare("abc", "aab") > 0);
+    assert(compare("aacd", "abc") < 0);
+    assert(compare("abc", "aacd") > 0);
+
+    assert(compare!((a, b) => a > b)("aec", "abc") < 0);
+    assert(compare!((a, b) => a > b)("aac", "abc") > 0);
+}
+
+private int compareImpl(alias pred, R1, R2)(ref R1 r1, ref R2 r2)
+{
+    for (; !r1.empty || !r2.empty; r1.popFront(), r2.popFront())
+    {
+        if (r1.empty)
+        {
+            return -1;
+        }
+        else if (r2.empty)
+        {
+            return 1;
+        }
+        const comparison = pred(r1, r2);
+        if (comparison != 0)
+        {
+            return comparison;
+        }
+    }
+    return 0;
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static struct OpCmp(int value)
+    {
+        int opCmp(OpCmp) @nogc nothrow pure @safe
+        {
+            return value;
+        }
+    }
+    {
+        OpCmp!(-1)[1] range;
+        assert(compare(range[], range[]) < 0);
+    }
+    {
+        OpCmp!1[1] range;
+        assert(compare(range[], range[]) > 0);
+    }
+    {
+        OpCmp!0[1] range;
+        assert(compare(range[], range[]) == 0);
+    }
+}

source/tanya/algorithm/iteration.d

@@ -3,13 +3,13 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Range adapters.
+ * Iteration algorithms.
  *
- * A range adapter wraps another range and modifies the way, how the original
+ * These algorithms wrap other ranges and modify the way, how the original
  * range is iterated, or the order in which its elements are accessed.
  *
- * All adapters are lazy algorithms, they request the next element of the
- * adapted range on demand.
+ * All algorithms in this module are lazy, they request the next element of the
+ * original range on demand.
  *
  * Copyright: Eugene Wissner 2018.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
@@ -22,9 +22,13 @@ module tanya.algorithm.iteration;
 
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
+import tanya.meta.trait;
+import tanya.meta.transform;
 import tanya.range;
+import tanya.typecons;
+version (unittest) import tanya.test.stub;
 
-private mixin template Take(R, bool exactly)
+private struct Take(R, bool exactly)
 {
     private R source;
     size_t length_;
@@ -73,13 +77,16 @@ private mixin template Take(R, bool exactly)
         }
         else
         {
-            return length == 0 || this.source.empty;
+            return this.length_ == 0 || this.source.empty;
         }
     }
 
-    @property size_t length()
+    static if (exactly || hasLength!R)
     {
-        return this.length_;
+        @property size_t length()
+        {
+            return this.length_;
+        }
     }
 
     static if (hasAssignableElements!R)
@@ -187,6 +194,22 @@ private mixin template Take(R, bool exactly)
             }
         }
     }
+
+    static if (!exactly && hasSlicing!R)
+    {
+        auto opSlice(size_t i, size_t j)
+        in
+        {
+            assert(i <= j);
+            assert(j <= length);
+        }
+        do
+        {
+            return typeof(this)(this.source[i .. j], length);
+        }
+    }
+
+    version (unittest) static assert(isInputRange!Take);
 }
 
 /**
@@ -212,25 +235,34 @@ private mixin template Take(R, bool exactly)
 auto take(R)(R range, size_t n)
 if (isInputRange!R)
 {
-    static struct Take
+    static if (hasSlicing!R && hasLength!R)
     {
-        mixin .Take!(R, false);
-
-        static if (hasSlicing!R)
-        {
-            auto opSlice(size_t i, size_t j)
-            in
-            {
-                assert(i <= j);
-                assert(j <= length);
-            }
-            do
-            {
-                return typeof(this)(this.source[i .. j], length);
-            }
-        }
+        if (range.length <= n)
+            return range;
+        else
+            return range[0 .. n];
+    }
+    // Special case: take(take(...), n)
+    else static if (is(Range == Take!(RRange, exact), RRange, bool exact))
+    {
+        if (n > range.length_)
+            n = range.length_;
+        static if (exact)
+            // `take(takeExactly(r, n0), n)` is rewritten `takeExactly(r, min(n0, n))`.
+            return Take!(RRange, true)(range.source, n);
+        else
+            // `take(take(r, n0), n)` is rewritten `take(r, min(n0, n))`.
+            return Take!(RRange, false)(range.source, n);
+    }
+    else static if (isInfinite!R)
+    {
+        // If the range is infinite then `take` is the same as `takeExactly`.
+        return Take!(R, true)(range, n);
+    }
+    else
+    {
+        return Take!(R, false)(range, n);
     }
-    return Take(range, n);
 }
 
 ///
@@ -290,6 +322,18 @@ if (isInputRange!R)
     assert(t.empty);
 }
 
+// length is unknown when taking from a range without length
+@nogc nothrow pure @safe unittest
+{
+    static struct R
+    {
+        mixin InputRangeStub;
+    }
+    auto actual = take(R(), 100);
+
+    static assert(!hasLength!(typeof(actual)));
+}
+
 /**
  * Takes exactly $(D_PARAM n) elements from $(D_PARAM range).
  *
@@ -315,13 +359,15 @@ if (isInputRange!R)
     {
         return range[0 .. n];
     }
+    // Special case: takeExactly(take(range, ...), n) is takeExactly(range, n)
+    else static if (is(Range == Take!(RRange, exact), RRange, bool exact))
+    {
+        assert(n <= range.length_);
+        return Take!(RRange, true)(range.source, n);
+    }
     else
     {
-        static struct TakeExactly
-        {
-            mixin Take!(R, true);
-        }
-        return TakeExactly(range, n);
+        return Take!(R, true)(range, n);
     }
 }
 
@@ -407,3 +453,403 @@ if (isInputRange!R)
         assert(slice.back == 3);
     }
 }
+
+// Reverse-access-order range returned by `retro`.
+private struct Retro(Range)
+{
+    Range source;
+
+    @disable this();
+
+    private this(Range source)
+    {
+        this.source = source;
+    }
+
+    Retro save()
+    {
+        return this;
+    }
+
+    @property auto ref front()
+    in (!empty)
+    {
+        return this.source.back;
+    }
+
+    void popFront()
+    in (!empty)
+    {
+        this.source.popBack();
+    }
+
+    @property auto ref back()
+    in (!empty)
+    {
+        return this.source.front;
+    }
+
+    void popBack()
+    in (!empty)
+    {
+        this.source.popFront();
+    }
+
+    @property bool empty()
+    {
+        return this.source.empty;
+    }
+
+    static if (hasLength!Range)
+    {
+        @property size_t length()
+        {
+            return this.source.length;
+        }
+    }
+
+    static if (isRandomAccessRange!Range && hasLength!Range)
+    {
+        auto ref opIndex(size_t i)
+        in (i < length)
+        {
+            return this.source[$ - ++i];
+        }
+    }
+
+    static if (hasLength!Range && hasSlicing!Range)
+    {
+        alias opDollar = length;
+
+        auto opSlice(size_t i, size_t j)
+        in
+        {
+            assert(i <= j);
+            assert(j <= length);
+        }
+        do
+        {
+            return typeof(this)(this.source[$-j .. $-i]);
+        }
+    }
+
+    static if (hasAssignableElements!Range)
+    {
+        @property void front(ref ElementType!Range value)
+        in (!empty)
+        {
+            this.source.back = value;
+        }
+
+        @property void front(ElementType!Range value)
+        in (!empty)
+        {
+            this.source.back = move(value);
+        }
+
+        @property void back(ref ElementType!Range value)
+        in (!empty)
+        {
+            this.source.front = value;
+        }
+
+        @property void back(ElementType!Range value)
+        in (!empty)
+        {
+            this.source.front = move(value);
+        }
+
+        static if (isRandomAccessRange!Range && hasLength!Range)
+        {
+            void opIndexAssign(ref ElementType!Range value, size_t i)
+            in (i < length)
+            {
+                this.source[$ - ++i] = value;
+            }
+
+            void opIndexAssign(ElementType!Range value, size_t i)
+            in (i < length)
+            {
+                this.source[$ - ++i] = move(value);
+            }
+        }
+    }
+
+    version (unittest) static assert(isBidirectionalRange!Retro);
+}
+
+/**
+ * Iterates a bidirectional range backwards.
+ *
+ * If $(D_PARAM Range) is a random-access range as well, the resulting range
+ * is a random-access range too.
+ *
+ * Params:
+ *  Range = Bidirectional range type.
+ *  range = Bidirectional range.
+ *
+ * Returns: Bidirectional range with the elements order reversed.
+ */
+auto retro(Range)(return Range range)
+if (isBidirectionalRange!Range)
+{
+    // Special case: retro(retro(range)) is range
+    static if (is(Range == Retro!RRange, RRange))
+        return range.source;
+    else
+        return Retro!Range(range);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[3] given = [1, 2, 3];
+    const int[3] expected = [3, 2, 1];
+
+    auto actual = retro(given[]);
+
+    assert(actual.length == expected.length);
+    assert(!actual.empty);
+    assert(equal(actual, expected[]));
+}
+
+// Elements are accessible in reverse order
+@nogc nothrow pure @safe unittest
+{
+    const int[3] given = [1, 2, 3];
+    auto actual = retro(given[]);
+
+    assert(actual.back == given[].front);
+    assert(actual[0] == 3);
+    assert(actual[2] == 1);
+
+    actual.popBack();
+    assert(actual.back == 2);
+    assert(actual[1] == 2);
+
+    // Check slicing.
+    auto slice = retro(given[])[1 .. $];
+    assert(slice.length == 2 && slice.front == 2 && slice.back == 1);
+}
+
+// Elements can be assigned
+@nogc nothrow pure @safe unittest
+{
+    int[4] given = [1, 2, 3, 4];
+    auto actual = retro(given[]);
+
+    actual.front = 5;
+    assert(given[].back == 5);
+
+    actual.back = 8;
+    assert(given[].front == 8);
+
+    actual[2] = 10;
+    assert(given[1] == 10);
+}
+
+private struct SingletonByValue(E)
+{
+    private Option!E element;
+
+    @disable this();
+
+    private this(U)(ref U element)
+    if (is(U == E))
+    {
+        this.element = move(element);
+    }
+
+    private this(U)(ref U element)
+    if (is(Unqual!U == Option!(Unqual!E)) || is(Unqual!U == Option!(const E)))
+    {
+        if (!element.isNothing)
+        {
+            this.element = element.get;
+        }
+    }
+
+    @property ref inout(E) front() inout
+    in (!empty)
+    {
+        return this.element.get;
+    }
+
+    alias back = front;
+
+    void popFront()
+    in (!empty)
+    {
+        this.element.reset();
+    }
+
+    alias popBack = popFront;
+
+    @property bool empty() const
+    {
+        return this.element.isNothing;
+    }
+
+    @property size_t length() const
+    {
+        return !this.element.isNothing;
+    }
+
+    auto save()
+    {
+        return SingletonByValue!E(this.element);
+    }
+
+    auto save() const
+    {
+        return SingletonByValue!(const E)(this.element);
+    }
+
+    ref inout(E) opIndex(size_t i) inout
+    in (!empty)
+    in (i == 0)
+    {
+        return this.element.get;
+    }
+}
+
+private struct SingletonByRef(E)
+{
+    private E* element;
+
+    @disable this();
+
+    private this(return ref E element) @trusted
+    {
+        this.element = &element;
+    }
+
+    @property ref inout(E) front() inout return
+    in (!empty)
+    {
+        return *this.element;
+    }
+
+    alias back = front;
+
+    void popFront()
+    in (!empty)
+    {
+        this.element = null;
+    }
+
+    alias popBack = popFront;
+
+    @property bool empty() const
+    {
+        return this.element is null;
+    }
+
+    @property size_t length() const
+    {
+        return this.element !is null;
+    }
+
+    auto save() return
+    {
+        return typeof(this)(*this.element);
+    }
+
+    auto save() const return
+    {
+        return SingletonByRef!(const E)(*this.element);
+    }
+
+    ref inout(E) opIndex(size_t i) inout return
+    in (!empty)
+    in (i == 0)
+    {
+        return *this.element;
+    }
+}
+
+/**
+ * Creates a bidirectional and random-access range with the single element
+ * $(D_PARAM element).
+ *
+ * If $(D_PARAM element) is passed by value the resulting range stores it
+ * internally. If $(D_PARAM element) is passed by reference, the resulting
+ * range keeps only a pointer to the element.
+ *
+ * Params:
+ *  E       = Element type.
+ *  element = Element.
+ *
+ * Returns: A range with one element.
+ */
+auto singleton(E)(return E element)
+if (isMutable!E)
+{
+    return SingletonByValue!E(element);
+}
+
+/// ditto
+auto singleton(E)(return ref E element)
+{
+    return SingletonByRef!E(element);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    auto singleChar = singleton('a');
+
+    assert(singleChar.length == 1);
+    assert(singleChar.front == 'a');
+
+    singleChar.popFront();
+    assert(singleChar.empty);
+}
+
+// Singleton range is bidirectional and random-access
+@nogc nothrow pure @safe unittest
+{
+    static assert(isBidirectionalRange!(typeof(singleton('a'))));
+    static assert(isRandomAccessRange!(typeof(singleton('a'))));
+
+    assert({ char a; return isBidirectionalRange!(typeof(singleton(a))); });
+    assert({ char a; return isRandomAccessRange!(typeof(singleton(a))); });
+}
+
+@nogc nothrow pure @safe unittest
+{
+    char a = 'a';
+    auto single = singleton(a);
+
+    assert(single.front == 'a');
+    assert(single.back == 'a');
+    assert(single[0] == 'a');
+    assert(single.length == 1);
+    assert(!single.empty);
+}
+
+// popFront makes SingletonByRef empty
+@nogc nothrow pure @safe unittest
+{
+    char a = 'a';
+    auto single = singleton(a);
+
+    single.popFront();
+    assert(single.empty);
+    assert(single.length == 0);
+    assert(single.empty);
+}
+
+// popBack makes SingletonByRef empty
+@nogc nothrow pure @safe unittest
+{
+    char a = 'b';
+    auto single = singleton(a);
+
+    single.popBack();
+    assert(single.empty);
+    assert(single.length == 0);
+    assert(single.empty);
+}

source/tanya/algorithm/mutation.d

@@ -5,7 +5,7 @@
 /**
  * Algorithms that modify its arguments.
  *
- * Copyright: Eugene Wissner 2017-2018.
+ * Copyright: Eugene Wissner 2017-2019.
  * 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)
@@ -14,10 +14,12 @@
  */
 module tanya.algorithm.mutation;
 
+import tanya.conv;
 static import tanya.memory.op;
 import tanya.meta.trait;
 import tanya.meta.transform;
 import tanya.range;
+version (unittest) import tanya.test.stub;
 
 private void deinitialize(bool zero, T)(ref T value)
 {
@@ -88,13 +90,20 @@ do
 
         static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
         {
-            if (typeid(T).initializer().ptr is null)
+            static if (__VERSION__ >= 2083) // __traits(isZeroInit) available.
             {
-                deinitialize!true(source);
+                deinitialize!(__traits(isZeroInit, T))(source);
             }
             else
             {
-                deinitialize!false(source);
+                if (typeid(T).initializer().ptr is null)
+                {
+                    deinitialize!true(source);
+                }
+                else
+                {
+                    deinitialize!false(source);
+                }
             }
         }
     }
@@ -214,9 +223,16 @@ void move(T)(ref T source, ref T target)
 /// ditto
 T move(T)(ref T source) @trusted
 {
-    T target = void;
-    moveEmplace(source, target);
-    return target;
+    static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
+    {
+        T target = void;
+        moveEmplace(source, target);
+        return target;
+    }
+    else
+    {
+        return source;
+    }
 }
 
 ///
@@ -293,7 +309,7 @@ void swap(T)(ref T a, ref T b) @trusted
  *               $(D_PARAM source) elements.
  */
 Target copy(Source, Target)(Source source, Target target)
-if (isInputRange!Source && isOutputRange!(Target, Source))
+if (isInputRange!Source && isOutputRange!(Target, ElementType!Source))
 in
 {
     static if (hasLength!Source && hasLength!Target)
@@ -373,12 +389,9 @@ do
     static struct OutPutRange
     {
         int value;
-        void put(int value) @nogc nothrow pure @safe
-        in
-        {
-            assert(this.value == 0);
-        }
-        do
+
+        void opCall(int value) @nogc nothrow pure @safe
+        in (this.value == 0)
         {
             this.value = value;
         }
@@ -388,3 +401,296 @@ do
 
     assert(copy(source[], target).value == 5);
 }
+
+/**
+ * Fills $(D_PARAM range) with $(D_PARAM value).
+ *
+ * Params:
+ *  Range = Input range type.
+ *  Value = Filler type.
+ *  range = Input range.
+ *  value = Filler.
+ */
+void fill(Range, Value)(Range range, auto ref Value value)
+if (isInputRange!Range && isAssignable!(ElementType!Range, Value))
+{
+    static if (!isDynamicArray!Range && is(typeof(range[] = value)))
+    {
+        range[] = value;
+    }
+    else
+    {
+        for (; !range.empty; range.popFront())
+        {
+            range.front = value;
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    int[6] actual;
+    const int[6] expected = [1, 1, 1, 1, 1, 1];
+
+    fill(actual[], 1);
+    assert(equal(actual[], expected[]));
+}
+
+// [] is called where possible
+@nogc nothrow pure @system unittest
+{
+    static struct Slice
+    {
+        bool* slicingCalled;
+
+        int front() @nogc nothrow pure @safe
+        {
+            return 0;
+        }
+
+        void front(int) @nogc nothrow pure @safe
+        {
+        }
+
+        void popFront() @nogc nothrow pure @safe
+        {
+        }
+
+        bool empty() @nogc nothrow pure @safe
+        {
+            return true;
+        }
+
+        void opIndexAssign(int) @nogc nothrow pure @safe
+        {
+            *this.slicingCalled = true;
+        }
+    }
+    bool slicingCalled;
+    auto range = Slice(&slicingCalled);
+    fill(range, 0);
+    assert(slicingCalled);
+}
+
+/**
+ * Fills $(D_PARAM range) with $(D_PARAM value) assuming the elements of the
+ * $(D_PARAM range) aren't initialized.
+ *
+ * Params:
+ *  Range = Input range type.
+ *  Value = Initializer type.
+ *  range = Input range.
+ *  value = Initializer.
+ */
+void uninitializedFill(Range, Value)(Range range, auto ref Value value)
+if (isInputRange!Range && hasLvalueElements!Range
+ && isAssignable!(ElementType!Range, Value))
+{
+    static if (hasElaborateDestructor!(ElementType!Range))
+    {
+        for (; !range.empty; range.popFront())
+        {
+            ElementType!Range* p = &range.front;
+            emplace!(ElementType!Range)(cast(void[]) (p[0 .. 1]), value);
+        }
+    }
+    else
+    {
+        fill(range, value);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    int[6] actual = void;
+    const int[6] expected = [1, 1, 1, 1, 1, 1];
+
+    uninitializedFill(actual[], 1);
+    assert(equal(actual[], expected[]));
+}
+
+/**
+ * Initializes all elements of the $(D_PARAM range) assuming that they are
+ * uninitialized.
+ *
+ * Params:
+ *  Range = Input range type
+ *  range = Input range.
+ */
+void initializeAll(Range)(Range range) @trusted
+if (isInputRange!Range && hasLvalueElements!Range)
+{
+    import tanya.memory.op : copy, fill;
+    alias T = ElementType!Range;
+
+    static if (__VERSION__ >= 2083
+            && isDynamicArray!Range
+            && __traits(isZeroInit, T))
+    {
+        fill!0(range);
+    }
+    else
+    {
+        static immutable init = T.init;
+        for (; !range.empty; range.popFront())
+        {
+            copy((&init)[0 .. 1], (&range.front)[0 .. 1]);
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    int[2] actual = void;
+    const int[2] expected = [0, 0];
+
+    initializeAll(actual[]);
+    assert(equal(actual[], expected[]));
+}
+
+@nogc nothrow pure @safe unittest
+{
+    NonCopyable[] nonCopyable;
+    initializeAll(nonCopyable);
+}
+
+/**
+ * Destroys all elements in the $(D_PARAM range).
+ *
+ * This function has effect only if the element type of $(D_PARAM Range) has
+ * an elaborate destructor, i.e. it is a $(D_PSYMBOL struct) with an explicit
+ * or generated by the compiler destructor.
+ *
+ * Params:
+ *  Range = Input range type.
+ *  range = Input range.
+ */
+void destroyAll(Range)(Range range)
+if (isInputRange!Range && hasLvalueElements!Range)
+{
+    static if (hasElaborateDestructor!(ElementType!Range))
+    {
+        foreach (ref e; range)
+        {
+            destroy(e);
+        }
+    }
+}
+
+///
+@nogc nothrow pure @trusted unittest
+{
+    static struct WithDtor
+    {
+        private size_t* counter;
+        ~this() @nogc nothrow pure
+        {
+            if (this.counter !is null)
+            {
+                ++(*this.counter);
+            }
+        }
+    }
+
+    size_t counter;
+    WithDtor[2] withDtor = [WithDtor(&counter), WithDtor(&counter)];
+
+    destroyAll(withDtor[]);
+
+    assert(counter == 2);
+}
+
+/**
+ * Rotates the elements of a union of two ranges.
+ *
+ * Performs a left rotation on the given ranges, as if it would be a signle
+ * range, so that [`front.front`, `back.front`$(RPAREN) is a valid range, that
+ * is $(D_PARAM back) would continue $(D_PARAM front).
+ *
+ * The elements are moved so, that the first element of $(D_PARAM back) becomes
+ * the first element of $(D_PARAM front) without changing the relative order of
+ * their elements.
+ *
+ * Params:
+ *  Range = Range type.
+ *  front = Left half.
+ *  back  = Right half.
+ */
+void rotate(Range)(Range front, Range back)
+if (isForwardRange!Range && hasSwappableElements!Range)
+{
+    auto next = back.save();
+
+    while (!front.empty && !next.empty && !sameHead(front, next))
+    {
+        swap(front.front, next.front);
+        front.popFront();
+        next.popFront();
+
+        if (next.empty)
+        {
+            next = back.save();
+        }
+        else if (front.empty)
+        {
+            front = back.save();
+            back = next.save();
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[7] expected = [1, 2, 3, 4, 5, 6, 7];
+    int[7] actual = [5, 6, 3, 4, 1, 2, 7];
+
+    rotate(actual[0 .. 2], actual[4 .. 6]);
+    assert(equal(actual[], expected[]));
+}
+
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[5] expected = [1, 2, 3, 4, 5];
+    int[5] actual = [4, 5, 1, 2, 3];
+
+    rotate(actual[0 .. 2], actual[2 .. $]);
+    assert(equal(actual[], expected[]));
+}
+
+// Doesn't cause an infinite loop if back is shorter than the front
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[5] expected = [1, 2, 3, 4, 5];
+    int[5] actual = [3, 4, 5, 1, 2];
+
+    rotate(actual[0 .. 3], actual[3 .. $]);
+    assert(equal(actual[], expected[]));
+}
+
+// Doesn't call .front on an empty front
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[2] expected = [2, 8];
+    int[2] actual = expected;
+
+    rotate(actual[0 .. 0], actual[]);
+    assert(equal(actual[], expected[]));
+}

source/tanya/algorithm/searching.d

@@ -0,0 +1,78 @@
+/* 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/. */
+
+/**
+ * Searching algorithms.
+ *
+ * Copyright: Eugene Wissner 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/algorithm/searching.d,
+ *                 tanya/algorithm/searching.d)
+ */
+module tanya.algorithm.searching;
+
+import tanya.range;
+
+/**
+ * Counts the elements in an input range.
+ *
+ * If $(D_PARAM R) has length, $(D_PSYMBOL count) returns it, otherwise it
+ * iterates over the range and counts the elements.
+ *
+ * Params:
+ *  R     = Input range type.
+ *  range = Input range.
+ *
+ * Returns: $(D_PARAM range) length.
+ */
+size_t count(R)(R range)
+if (isInputRange!R)
+{
+    static if (hasLength!R)
+    {
+        return range.length;
+    }
+    else
+    {
+        size_t counter;
+        for (; !range.empty; range.popFront(), ++counter)
+        {
+        }
+        return counter;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    int[3] array;
+    assert(count(array) == 3);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static struct Range
+    {
+        private int counter = 3;
+
+        int front() const @nogc nothrow pure @safe
+        {
+            return this.counter;
+        }
+
+        void popFront() @nogc nothrow pure @safe
+        {
+            --this.counter;
+        }
+
+        bool empty() const @nogc nothrow pure @safe
+        {
+            return this.counter == 0;
+        }
+    }
+    Range range;
+    assert(count(range) == 3);
+}

source/tanya/async/event/iocp.d

@@ -318,7 +318,9 @@ final class IOCPLoop : Loop
 
                 connection.incoming.insertBack(transport);
 
-                reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
+                reify(transport,
+                      EventMask(Event.none),
+                      EventMask(Event.read | Event.write));
 
                 pendings.insertBack(connection);
                 listener.beginAccept(overlapped);

source/tanya/async/event/selector.d

@@ -140,7 +140,7 @@ package class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
     {
         closing = true;
         loop.reify(this,
-                   EventMask(Event.read, Event.write),
+                   EventMask(Event.read | Event.write),
                    EventMask(Event.write));
     }
 
@@ -393,7 +393,9 @@ abstract class SelectorLoop : Loop
                 transport.socket = client;
             }
 
-            reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
+            reify(transport,
+                  EventMask(Event.none),
+                  EventMask(Event.read | Event.write));
             connection.incoming.insertBack(transport);
         }
 

source/tanya/async/loop.d

@@ -72,9 +72,9 @@
 module tanya.async.loop;
 
 import core.time;
-import std.typecons;
 import tanya.async.transport;
 import tanya.async.watcher;
+import tanya.bitmanip;
 import tanya.container.buffer;
 import tanya.container.list;
 import tanya.memory;

source/tanya/bitmanip.d

@@ -0,0 +1,359 @@
+/* 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/. */
+
+/**
+ * Bit manipulation.
+ *
+ * Copyright: Eugene Wissner 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/bitmanip.d,
+ *                 tanya/bitmanip.d)
+ */
+module tanya.bitmanip;
+
+import tanya.meta.metafunction;
+import tanya.meta.trait;
+import tanya.meta.transform;
+
+/**
+ * Determines whether $(D_PARAM E) is a $(D_KEYWORD enum), whose members can be
+ * used as bit flags.
+ *
+ * This is the case if all members of $(D_PARAM E) are integral numbers that
+ * are either 0 or positive integral powers of 2.
+ *
+ * Params:
+ *  E = Some $(D_KEYWORD enum).
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM E) contains only bit flags,
+ *          $(D_KEYWORD false) otherwise.
+ */
+template isBitFlagEnum(E)
+{
+    enum bool isValid(OriginalType!E x) = x == 0
+                                       || (x > 0 && ((x & (x - 1)) == 0));
+    static if (isIntegral!E)
+    {
+        enum bool isBitFlagEnum = allSatisfy!(isValid, EnumMembers!E);
+    }
+    else
+    {
+        enum bool isBitFlagEnum = false;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    enum Valid
+    {
+        none = 0,
+        one = 1 << 0,
+        two = 1 << 1,
+    }
+    static assert(isBitFlagEnum!Valid);
+
+    enum Invalid
+    {
+        one,
+        two,
+        three,
+        four,
+    }
+    static assert(!isBitFlagEnum!Invalid);
+
+    enum Negative
+    {
+        one = -1,
+        two = -2,
+    }
+    static assert(!isBitFlagEnum!Negative);
+}
+
+/**
+ * Validates that $(D_PARAM field) contains only bits from $(D_PARAM E).
+ *
+ * Params:
+ *  E     = Some $(D_KEYWORD enum).
+ *  field = Bit field.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM field) is valid, $(D_KEYWORD false)
+ *          otherwise.
+ */
+bool containsBitFlags(E)(E field)
+if (isBitFlagEnum!E)
+{
+    OriginalType!E fillField()
+    {
+        typeof(return) full;
+        static foreach (member; EnumMembers!E)
+        {
+            full |= member;
+        }
+        return full;
+    }
+    enum OriginalType!E full = fillField();
+    return (field & ~full) == OriginalType!E.init;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    enum E
+    {
+        one,
+        two,
+        three,
+    }
+    assert(containsBitFlags(E.one | E.two));
+    assert(!containsBitFlags(cast(E) 0x8));
+}
+
+/**
+ * Allows to use $(D_KEYWORD enum) values as a set of bit flags.
+ *
+ * $(D_PSYMBOL BitFlags) behaves the same as a bit field of type $(D_PARAM E),
+ * but does additional cheks to ensure that the bit field contains only valid
+ * values, this is only values from $(D_PARAM E).
+ *
+ * Params:
+ *  E = Some $(D_KEYWORD enum).
+ */
+struct BitFlags(E)
+if (isBitFlagEnum!E)
+{
+    private OriginalType!E field;
+
+    /**
+     * Constructs $(D_PSYMBOL BitFlags) from $(D_PARAM field).
+     *
+     * Params:
+     *  field = Bits to be set.
+     */
+    this(E field)
+    {
+        this.field = field;
+    }
+
+    /**
+     * Converts $(D_PSYMBOL BitFlags) to a boolean.
+     *
+     * It is $(D_KEYWORD true) if any bit is set, $(D_KEYWORD false) otherwise.
+     *
+     * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL BitFlags) contains any
+     *          set bits, $(D_KEYWORD false) otherwise.
+     */
+    bool opCast(T : bool)()
+    {
+        return this.field != 0;
+    }
+
+    /**
+     * Converts to the original type of $(D_PARAM E) ($(D_KEYWORD int) by
+     * default).
+     *
+     * Returns: $(D_KEYWORD this) as $(D_INLINECODE OriginalType!T).
+     */
+    OriginalType!E opCast(T : OriginalType!E)() const
+    {
+        return this.field;
+    }
+
+    /**
+     * Tests (&), sets (|) or toggles (^) bits.
+     *
+     * Params:
+     *  op   = Operation.
+     *  that = 0 or more bit flags.
+     *
+     * Returns: New $(D_PSYMBOL BitFlags) object.
+     */
+    BitFlags opBinary(string op)(E that) const
+    if (op == "&" || op == "|" || op == "^")
+    {
+        BitFlags result = this;
+        mixin("return result " ~ op ~ "= that;");
+    }
+
+    /// ditto
+    BitFlags opBinary(string op)(BitFlags that) const
+    if (op == "&" || op == "|" || op == "^")
+    {
+        BitFlags result = this;
+        mixin("return result " ~ op ~ "= that;");
+    }
+
+    /// ditto
+    BitFlags opBinaryRight(string op)(E that) const
+    if (op == "&" || op == "|" || op == "^")
+    {
+        BitFlags result = this;
+        mixin("return result " ~ op ~ "= that;");
+    }
+
+    /**
+     * Tests (&), sets (|) or toggles (^) bits.
+     *
+     * Params:
+     *  op   = Operation.
+     *  that = 0 or more bit flags.
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    ref BitFlags opOpAssign(string op)(E that)
+    if (op == "&" || op == "|" || op == "^")
+    {
+        mixin("this.field " ~ op ~ "= that;");
+        return this;
+    }
+
+    /// ditto
+    ref BitFlags opOpAssign(string op)(BitFlags that)
+    if (op == "&" || op == "|" || op == "^")
+    {
+        mixin("this.field " ~ op ~ "= that.field;");
+        return this;
+    }
+
+    /**
+     * Inverts all bit flags.
+     *
+     * Returns: New $(D_PSYMBOL BitFlags) object with all bits inverted.
+     */
+    BitFlags opUnary(string op : "~")() const
+    {
+        BitFlags result;
+        result.field  = ~this.field;
+        return result;
+    }
+
+    /**
+     * Assigns a bit field.
+     *
+     * Params:
+     *  that = Bit field of type $(D_PARAM E).
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    ref BitFlags opAssign(E that)
+    {
+        this.field = that;
+        return this;
+    }
+
+    /**
+     * Compares this $(D_PSYMBOL BitFlags) object to another bit field.
+     *
+     * Params:
+     *  that = $(D_PSYMBOL BitFlags) object or a bit field of type
+     *         $(D_PARAM E).
+     *
+     * Returns: $(D_KEYWORD true) if $(D_KEYWORD this) and $(D_PARAM that)
+     *          contain the same bits ,$(D_KEYWORD false) otherwise.
+     */
+    bool opEquals(E that) const
+    {
+        return this.field == that;
+    }
+
+    /// ditto
+    bool opEquals(BitFlags that) const
+    {
+        return this.field == that.field;
+    }
+
+    /**
+     * Generates a hash value of this object.
+     *
+     * Returns: Hash value.
+     */
+    size_t toHash() const
+    {
+        return cast(size_t) this.field;
+    }
+}
+
+@nogc nothrow pure @safe unittest
+{
+    enum E : int
+    {
+        one = 1,
+    }
+
+    // Casts to a boolean
+    assert(BitFlags!E(E.one));
+    assert(!BitFlags!E());
+
+    // Assigns to and compares with a single value
+    {
+        BitFlags!E bitFlags;
+        bitFlags = E.one;
+        assert(bitFlags == E.one);
+    }
+    // Assigns to and compares with the same type
+    {
+        auto bitFlags1 = BitFlags!E(E.one);
+        BitFlags!E bitFlags2;
+        bitFlags2 = bitFlags1;
+        assert(bitFlags1 == bitFlags2);
+    }
+    assert((BitFlags!E() | E.one) == BitFlags!E(E.one));
+    assert((BitFlags!E() | BitFlags!E(E.one)) == BitFlags!E(E.one));
+
+    assert(!(BitFlags!E() & BitFlags!E(E.one)));
+
+    assert(!(BitFlags!E(E.one) ^ E.one));
+    assert(BitFlags!E() ^ BitFlags!E(E.one));
+
+    assert(~BitFlags!E());
+
+    assert(BitFlags!E().toHash() == 0);
+    assert(BitFlags!E(E.one).toHash() != 0);
+
+    // opBinaryRight is allowed
+    static assert(is(typeof({ E.one | BitFlags!E(); })));
+}
+
+/**
+ * Creates a $(D_PSYMBOL BitFlags) object initialized with $(D_PARAM field).
+ *
+ * Params:
+ *  E     = Some $(D_KEYWORD enum).
+ *  field = Bits to be set.
+ */
+BitFlags!E bitFlags(E)(E field)
+if (isBitFlagEnum!E)
+{
+    return BitFlags!E(field);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    enum E
+    {
+        one = 1 << 0,
+        two = 1 << 1,
+        three = 1 << 2,
+    }
+    // Construct with E.one and E.two set
+    auto flags = bitFlags(E.one | E.two);
+
+    // Test wheter E.one is set
+    assert(flags & E.one);
+
+    // Toggle E.one
+    flags ^= E.one;
+    assert(!(flags & E.one));
+
+    // Set E.three
+    flags |= E.three;
+    assert(flags & E.three);
+
+    // Clear E.three
+    flags &= ~E.three;
+    assert(!(flags & E.three));
+}

source/tanya/container/array.d

@@ -15,19 +15,15 @@
 module tanya.container.array;
 
 import core.checkedint;
-import std.algorithm.mutation : bringToFront,
-                                copy,
-                                fill,
-                                initializeAll,
-                                uninitializedFill;
-import std.meta;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.exception;
+import tanya.functional;
 import tanya.memory;
 import tanya.meta.trait;
 import tanya.meta.transform;
-import tanya.range.primitive;
+import tanya.range;
+version (unittest) import tanya.test.stub;
 
 /**
  * Random-access range for the $(D_PSYMBOL Array).
@@ -299,7 +295,9 @@ struct Array(T)
      *  init      = Initial value to fill the array with.
      *  allocator = Allocator.
      */
-    this(size_t len, T init, shared Allocator allocator = defaultAllocator)
+    this()(size_t len,
+           auto ref T init,
+           shared Allocator allocator = defaultAllocator)
     {
         this(allocator);
         reserve(len);
@@ -354,15 +352,19 @@ struct Array(T)
         (() @trusted => allocator.deallocate(slice(capacity)))();
     }
 
-    /**
-     * Copies the array.
-     */
-    this(this)
+    static if (isCopyable!T)
     {
-        auto buf = slice(this.length);
-        this.length_ = capacity_ = 0;
-        this.data = null;
-        insertBack(buf);
+        this(this)
+        {
+            auto buf = slice(this.length);
+            this.length_ = capacity_ = 0;
+            this.data = null;
+            insertBack(buf);
+        }
+    }
+    else
+    {
+        @disable this(this);
     }
 
     /**
@@ -419,27 +421,19 @@ struct Array(T)
      */
     @property void length(size_t len) @trusted
     {
-        if (len == length)
-        {
-            return;
-        }
-        else if (len > length)
+        if (len > length)
         {
             reserve(len);
             initializeAll(this.data[length_ .. len]);
         }
         else
         {
-            static if (hasElaborateDestructor!T)
-            {
-                const T* end = this.data + length_ - 1;
-                for (T* e = this.data + len; e != end; ++e)
-                {
-                    destroy(*e);
-                }
-            }
+            destroyAll(this.data[len .. this.length_]);
+        }
+        if (len != length)
+        {
+            length_ = len;
         }
-        length_ = len;
     }
 
     ///
@@ -817,10 +811,11 @@ struct Array(T)
     }
     do
     {
-        const oldLen = length;
-        const offset = r.end - this.data;
+        const oldLength = length;
+        const after = r.end - this.data;
         const inserted = insertBack(el);
-        bringToFront(this.data[offset .. oldLen], this.data[oldLen .. length]);
+
+        rotate(this.data[after .. oldLength], this.data[oldLength .. length]);
         return inserted;
     }
 
@@ -859,7 +854,7 @@ struct Array(T)
         {
             moveBack(el);
         }
-        bringToFront(this.data[offset .. oldLen], this.data[oldLen .. length]);
+        rotate(this.data[offset .. oldLen], this.data[oldLen .. length]);
 
         return 1;
     }
@@ -915,7 +910,7 @@ struct Array(T)
         {
             moveBack(el);
         }
-        bringToFront(this.data[offset .. oldLen], this.data[oldLen .. length]);
+        rotate(this.data[offset .. oldLen], this.data[oldLen .. length]);
 
         return 1;
     }
@@ -1006,7 +1001,7 @@ struct Array(T)
      */
     ref T opIndexAssign(E : T)(auto ref E value, size_t pos)
     {
-        return opIndex(pos) = value;
+        return opIndex(pos) = forward!value;
     }
 
     /// ditto
@@ -1040,7 +1035,7 @@ struct Array(T)
     }
 
     /// ditto
-    Range opIndexAssign(Range value)
+    Range opIndexAssign()(Range value)
     {
         return opSliceAssign(value, 0, length);
     }
@@ -1334,7 +1329,7 @@ struct Array(T)
     }
 
     /// ditto
-    Range opSliceAssign(Range value, size_t i, size_t j) @trusted
+    Range opSliceAssign()(Range value, size_t i, size_t j) @trusted
     in
     {
         assert(i <= j);
@@ -1554,14 +1549,14 @@ struct Array(T)
 {
     struct MutableEqualsStruct
     {
-        int opEquals(typeof(this) that) @nogc nothrow pure @safe
+        bool opEquals(typeof(this) that) @nogc nothrow pure @safe
         {
             return true;
         }
     }
     struct ConstEqualsStruct
     {
-        int opEquals(const typeof(this) that) const @nogc nothrow pure @safe
+        bool opEquals(const typeof(this) that) const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -1588,15 +1583,10 @@ struct Array(T)
     assert(v7[].equal(v8[]));
 }
 
+// Destructor can destroy empty arrays
 @nogc nothrow pure @safe unittest
 {
-    struct SWithDtor
-    {
-        ~this() @nogc nothrow pure @safe
-        {
-        }
-    }
-    auto v = Array!SWithDtor(); // Destructor can destroy empty arrays.
+    auto v = Array!WithDtor();
 }
 
 @nogc nothrow pure @safe unittest
@@ -1607,7 +1597,6 @@ struct Array(T)
     A a1, a2;
     auto v1 = Array!A([a1, a2]);
 
-    // Issue 232: https://issues.caraus.io/issues/232.
     static assert(is(Array!(A*)));
 }
 
@@ -1692,3 +1681,10 @@ struct Array(T)
     }
     func(array);
 }
+
+// Can have non-copyable elements
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(Array!NonCopyable));
+    static assert(is(typeof({ Array!NonCopyable.init[0] = NonCopyable(); })));
+}

source/tanya/container/entry.d

@@ -20,6 +20,7 @@ import tanya.memory.allocator;
 import tanya.meta.trait;
 import tanya.meta.transform;
 import tanya.typecons;
+version (unittest) import tanya.test.stub;
 
 package struct SEntry(T)
 {
@@ -59,12 +60,12 @@ package struct Bucket(K, V = void)
     }
     BucketStatus status = BucketStatus.empty;
 
-    this(ref K key)
+    this()(ref K key)
     {
         this.key = key;
     }
 
-    @property void key(ref K key)
+    @property void key()(ref K key)
     {
         this.key() = key;
         this.status = BucketStatus.used;
@@ -170,7 +171,7 @@ package struct HashArray(alias hasher, K, V = void)
         .swap(this.length, data.length);
     }
 
-    void opAssign(ref typeof(this) that)
+    void opAssign()(ref typeof(this) that)
     {
         this.array = that.array;
         this.lengthIndex = that.lengthIndex;
@@ -326,3 +327,13 @@ package struct HashArray(alias hasher, K, V = void)
         return false;
     }
 }
+
+// Can be constructed with non-copyable key/values
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(Bucket!NonCopyable));
+    static assert(is(Bucket!(NonCopyable, NonCopyable)));
+
+    static assert(is(HashArray!((ref NonCopyable) => 0U, NonCopyable)));
+    static assert(is(HashArray!((ref NonCopyable) => 0U, NonCopyable, NonCopyable)));
+}

source/tanya/container/hashtable.d

@@ -22,6 +22,7 @@ import tanya.memory;
 import tanya.meta.trait;
 import tanya.meta.transform;
 import tanya.range.primitive;
+version (unittest) import tanya.test.stub;
 
 /**
  * Bidirectional range whose element type is a tuple of a key and the
@@ -68,7 +69,7 @@ struct Range(T)
         return this.dataRange.empty();
     }
 
-    @property void popFront()
+    void popFront()
     in
     {
         assert(!empty);
@@ -87,7 +88,7 @@ struct Range(T)
         while (!empty && dataRange.front.status != BucketStatus.used);
     }
 
-    @property void popBack()
+    void popBack()
     in
     {
         assert(!empty);
@@ -386,7 +387,7 @@ struct ByValue(T)
  *  hasher = Hash function for $(D_PARAM Key).
  */
 struct HashTable(Key, Value, alias hasher = hash)
-if (is(typeof(((Key k) => hasher(k))(Key.init)) == size_t))
+if (isHashFunction!(hasher, Key))
 {
     private alias HashArray = .HashArray!(hasher, Key, Value);
     private alias Buckets = HashArray.Buckets;
@@ -759,7 +760,7 @@ if (is(typeof(((Key k) => hasher(k))(Key.init)) == size_t))
      *
      * Returns: The number of the inserted elements with a unique key.
      */
-    size_t insert(ref KeyValue keyValue)
+    size_t insert()(ref KeyValue keyValue)
     {
         auto e = ((ref v) @trusted => &this.data.insert(v))(keyValue.key);
         size_t inserted;
@@ -773,7 +774,7 @@ if (is(typeof(((Key k) => hasher(k))(Key.init)) == size_t))
     }
 
     /// ditto
-    size_t insert(KeyValue keyValue)
+    size_t insert()(KeyValue keyValue)
     {
         auto e = ((ref v) @trusted => &this.data.insert(v))(keyValue.key);
         size_t inserted;
@@ -1197,3 +1198,16 @@ if (is(typeof(((Key k) => hasher(k))(Key.init)) == size_t))
     static assert(is(typeof("asdf" in HashTable!(String, int)())));
     static assert(is(typeof(HashTable!(String, int)()["asdf"])));
 }
+
+// Can have non-copyable keys and elements
+@nogc nothrow pure @safe unittest
+{
+    @NonCopyable @Hashable
+    static struct S
+    {
+        mixin StructStub;
+    }
+    static assert(is(HashTable!(S, int)));
+    static assert(is(HashTable!(int, S)));
+    static assert(is(HashTable!(S, S)));
+}

source/tanya/container/list.d

@@ -15,7 +15,6 @@
  */
 module tanya.container.list;
 
-import std.algorithm.searching;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.container.entry;
@@ -24,6 +23,7 @@ import tanya.meta.trait;
 import tanya.meta.transform;
 import tanya.range.array;
 import tanya.range.primitive;
+version (unittest) import tanya.test.stub;
 
 /**
  * Forward range for the $(D_PSYMBOL SList).
@@ -156,8 +156,9 @@ struct SList(T)
      *  init      = Initial value to fill the list with.
      *  allocator = Allocator.
      */
-    this(size_t len, T init, shared Allocator allocator = defaultAllocator)
-    @trusted
+    this()(size_t len,
+           auto ref T init,
+           shared Allocator allocator = defaultAllocator)
     {
         this(allocator);
         if (len == 0)
@@ -183,7 +184,18 @@ struct SList(T)
     /// ditto
     this(size_t len, shared Allocator allocator = defaultAllocator)
     {
-        this(len, T.init, allocator);
+        this(allocator);
+        if (len == 0)
+        {
+            return;
+        }
+
+        Entry* next = this.head = allocator.make!Entry();
+        foreach (i; 1 .. len)
+        {
+            next.next = allocator.make!Entry();
+            next = next.next;
+        }
     }
 
     ///
@@ -272,14 +284,18 @@ struct SList(T)
         clear();
     }
 
-    /**
-     * Copies the list.
-     */
-    this(this)
+    static if (isCopyable!T)
     {
-        auto list = typeof(this)(this[], this.allocator);
-        this.head = list.head;
-        list.head = null;
+        this(this)
+        {
+            auto list = typeof(this)(this[], this.allocator);
+            this.head = list.head;
+            list.head = null;
+        }
+    }
+    else
+    {
+        @disable this(this);
     }
 
     ///
@@ -513,7 +529,7 @@ struct SList(T)
     }
 
     /// ditto
-    size_t insertBefore(Range r, ref T el) @trusted
+    size_t insertBefore()(Range r, ref T el) @trusted
     in
     {
         assert(checkRangeBelonging(r));
@@ -1121,8 +1137,9 @@ struct DList(T)
      *  init      = Initial value to fill the list with.
      *  allocator = Allocator.
      */
-    this(size_t len, T init, shared Allocator allocator = defaultAllocator)
-    @trusted
+    this()(size_t len,
+           auto ref T init,
+           shared Allocator allocator = defaultAllocator)
     {
         this(allocator);
         if (len == 0)
@@ -1151,7 +1168,20 @@ struct DList(T)
     /// ditto
     this(size_t len, shared Allocator allocator = defaultAllocator)
     {
-        this(len, T.init, allocator);
+        this(allocator);
+        if (len == 0)
+        {
+            return;
+        }
+
+        Entry* next = this.head = allocator.make!Entry();
+        foreach (i; 1 .. len)
+        {
+            next.next = allocator.make!Entry();
+            next.next.prev = next;
+            next = next.next;
+        }
+        this.tail = next;
     }
 
     ///
@@ -1243,15 +1273,19 @@ struct DList(T)
         clear();
     }
 
-    /**
-     * Copies the list.
-     */
-    this(this)
+    static if (isCopyable!T)
     {
-        auto list = typeof(this)(this[], this.allocator);
-        this.head = list.head;
-        this.tail = list.tail;
-        list.head = list .tail = null;
+        this(this)
+        {
+            auto list = typeof(this)(this[], this.allocator);
+            this.head = list.head;
+            this.tail = list.tail;
+            list.head = list .tail = null;
+        }
+    }
+    else
+    {
+        @disable this(this);
     }
 
     ///
@@ -1642,7 +1676,7 @@ struct DList(T)
     }
 
     /// ditto
-    size_t insertBefore(Range r, ref T el) @trusted
+    size_t insertBefore()(Range r, ref T el) @trusted
     in
     {
         assert(checkRangeBelonging(r));
@@ -1759,7 +1793,7 @@ struct DList(T)
     }
 
     /// ditto
-    size_t insertAfter(Range r, ref T el) @trusted
+    size_t insertAfter()(Range r, ref T el) @trusted
     in
     {
         assert(checkRangeBelonging(r));
@@ -2356,3 +2390,10 @@ struct DList(T)
     assert(!l1.remove(r).empty);
     assert(l1 == l2);
 }
+
+// Can have non-copyable elements
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(SList!NonCopyable));
+    static assert(is(DList!NonCopyable));
+}

source/tanya/container/set.d

@@ -22,6 +22,7 @@ import tanya.memory;
 import tanya.meta.trait;
 import tanya.meta.transform;
 import tanya.range.primitive;
+version (unittest) import tanya.test.stub;
 
 /**
  * Bidirectional range that iterates over the $(D_PSYMBOL Set)'s values.
@@ -67,7 +68,7 @@ struct Range(T)
         return this.dataRange.empty();
     }
 
-    @property void popFront()
+    void popFront()
     in
     {
         assert(!empty);
@@ -86,7 +87,7 @@ struct Range(T)
         while (!empty && dataRange.front.status != BucketStatus.used);
     }
 
-    @property void popBack()
+    void popBack()
     in
     {
         assert(!empty);
@@ -154,7 +155,7 @@ struct Range(T)
  *  hasher = Hash function for $(D_PARAM T).
  */
 struct Set(T, alias hasher = hash)
-if (is(typeof(((T x) => hasher(x))(T.init)) == size_t))
+if (isHashFunction!(hasher, T))
 {
     private alias HashArray = .HashArray!(hasher, T);
     private alias Buckets = HashArray.Buckets;
@@ -459,7 +460,7 @@ if (is(typeof(((T x) => hasher(x))(T.init)) == size_t))
      *
      * Returns: Amount of new elements inserted.
      */
-    size_t insert(ref T value)
+    size_t insert()(ref T value)
     {
         auto e = ((ref v) @trusted => &this.data.insert(v))(value);
         if (e.status != BucketStatus.used)
@@ -470,7 +471,7 @@ if (is(typeof(((T x) => hasher(x))(T.init)) == size_t))
         return 0;
     }
 
-    size_t insert(T value)
+    size_t insert()(T value)
     {
         auto e = ((ref v) @trusted => &this.data.insert(v))(value);
         if (e.status != BucketStatus.used)
@@ -768,8 +769,19 @@ if (is(typeof(((T x) => hasher(x))(T.init)) == size_t))
     testFunc(set);
 }
 
+// Hasher can take argument by ref
 @nogc nothrow pure @safe unittest
 {
-    // Using hasher that takes argument by ref.
-    Set!(int, (const ref x) => cast(size_t)x) set;
+    static assert(is(Set!(int, (const ref x) => cast(size_t) x)));
+}
+
+// Can have non-copyable elements
+@nogc nothrow pure @safe unittest
+{
+    @NonCopyable @Hashable
+    static struct S
+    {
+        mixin StructStub;
+    }
+    static assert(is(Set!S));
 }

source/tanya/container/string.d

@@ -26,9 +26,6 @@
  */
 module tanya.container.string;
 
-import std.algorithm.comparison : cmp;
-import std.algorithm.mutation : bringToFront;
-import std.algorithm.searching;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.hash.lookup;
@@ -1284,29 +1281,29 @@ struct String
     int opCmp(S)(auto ref S that) const @trusted
     if (is(Unqual!S == String))
     {
-        return cmp(this.data[0 .. length], that.data[0 .. that.length]);
+        return compare(this.data[0 .. length], that.data[0 .. that.length]);
     }
 
     /// ditto
     int opCmp(S)(ByCodeUnit!S that) const @trusted
     if (is(Unqual!S == char))
     {
-        return cmp(this.data[0 .. length],
-                   that.begin[0 .. that.end - that.begin]);
+        return compare(this.data[0 .. length],
+                       that.begin[0 .. that.end - that.begin]);
     }
 
     /// ditto
     int opCmp(S)(ByCodePoint!S that) const @trusted
     if (is(Unqual!S == char))
     {
-        return cmp(this.data[0 .. length],
-                   that.begin[0 .. that.end - that.begin]);
+        return compare(this.data[0 .. length],
+                       that.begin[0 .. that.end - that.begin]);
     }
 
     /// ditto
     int opCmp()(const char[] that) const @trusted
     {
-        return cmp(this.data[0 .. length], that);
+        return compare(this.data[0 .. length], that);
     }
 
     ///
@@ -1486,6 +1483,8 @@ struct String
     ///
     @nogc pure @safe unittest
     {
+        import tanya.algorithm.searching : count;
+
         auto s = String("Из пословицы слова не выкинешь.");
 
         assert(s.remove(s[5 .. 24]).length == 33);
@@ -1531,11 +1530,10 @@ struct String
     do
     {
         const oldLength = length;
-        const rangeEnd = r.end - this.data;
+        const after = r.end - this.data;
         const inserted = insertBack(el);
-        auto containerEnd = this.data + oldLength;
-        bringToFront(ByCodeUnit!char(this, this.data + rangeEnd, containerEnd),
-                     ByCodeUnit!char(this, containerEnd, this.data + length));
+
+        rotate(this.data[after .. oldLength], this.data[oldLength .. length]);
         return inserted;
     }
 

source/tanya/conv.d

@@ -5,7 +5,7 @@
 /**
  * This module provides functions for converting between different types.
  *
- * Copyright: Eugene Wissner 2017-2018.
+ * Copyright: Eugene Wissner 2017-2019.
  * 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)
@@ -14,6 +14,7 @@
  */
 module tanya.conv;
 
+import tanya.algorithm.mutation;
 import tanya.container.string;
 import tanya.format;
 import tanya.memory;
@@ -26,6 +27,7 @@ import tanya.range.primitive;
 version (unittest)
 {
     import tanya.test.assertion;
+    import tanya.test.stub;
 }
 
 /**
@@ -60,15 +62,8 @@ version (unittest)
  */
 T emplace(T, U, Args...)(void[] memory, U outer, auto ref Args args)
 if (!isAbstractClass!T && isInnerClass!T && is(typeof(T.outer) == U))
-in
-{
-    assert(memory.length >= stateSize!T);
-}
-out (result)
-{
-    assert(memory.ptr is (() @trusted => cast(void*) result)());
-}
-do
+in (memory.length >= stateSize!T)
+out (result; memory.ptr is (() @trusted => cast(void*) result)())
 {
     copy(typeid(T).initializer, memory);
 
@@ -86,15 +81,8 @@ do
 /// ditto
 T emplace(T, Args...)(void[] memory, auto ref Args args)
 if (is(T == class) && !isAbstractClass!T && !isInnerClass!T)
-in
-{
-    assert(memory.length == stateSize!T);
-}
-out (result)
-{
-    assert(memory.ptr is (() @trusted => cast(void*) result)());
-}
-do
+in (memory.length == stateSize!T)
+out (result; memory.ptr is (() @trusted => cast(void*) result)())
 {
     copy(typeid(T).initializer, memory);
 
@@ -139,15 +127,8 @@ do
 /// ditto
 T* emplace(T, Args...)(void[] memory, auto ref Args args)
 if (!isAggregateType!T && (Args.length <= 1))
-in
-{
-    assert(memory.length >= T.sizeof);
-}
-out (result)
-{
-    assert(memory.ptr is result);
-}
-do
+in (memory.length >= T.sizeof)
+out (result; memory.ptr is result)
 {
     auto result = (() @trusted => cast(T*) memory.ptr)();
     static if (Args.length == 1)
@@ -161,43 +142,57 @@ do
     return result;
 }
 
-/// ditto
-T* emplace(T, Args...)(void[] memory, auto ref Args args)
-if (!isPolymorphicType!T && isAggregateType!T)
-in
+private void initializeOne(T)(ref void[] memory, ref T* result) @trusted
 {
-    assert(memory.length >= T.sizeof);
-}
-out (result)
-{
-    assert(memory.ptr is result);
-}
-do
-{
-    auto result = (() @trusted => cast(T*) memory.ptr)();
     static if (!hasElaborateAssign!T && isAssignable!T)
     {
         *result = T.init;
     }
+    else static if (__VERSION__ >= 2083 // __traits(isZeroInit) available.
+        && __traits(isZeroInit, T))
+    {
+        memory.ptr[0 .. T.sizeof].fill!0;
+    }
     else
     {
-        static const T init = T.init;
-        copy((cast(void*) &init)[0 .. T.sizeof], memory);
+        static immutable T init = T.init;
+        copy((&init)[0 .. 1], memory);
     }
+}
+
+/// ditto
+T* emplace(T, Args...)(void[] memory, auto ref Args args)
+if (!isPolymorphicType!T && isAggregateType!T)
+in (memory.length >= T.sizeof)
+out (result; memory.ptr is result)
+{
+    auto result = (() @trusted => cast(T*) memory.ptr)();
 
     static if (Args.length == 0)
     {
         static assert(is(typeof({ static T t; })),
                       "Default constructor is disabled");
-    }
-    else static if (is(typeof(T(args))))
-    {
-        *result = T(args);
+        initializeOne(memory, result);
     }
     else static if (is(typeof(result.__ctor(args))))
     {
+        initializeOne(memory, result);
         result.__ctor(args);
     }
+    else static if (Args.length == 1 && is(typeof({ T t = args[0]; })))
+    {
+        ((ref arg) @trusted =>
+            copy((cast(void*) &arg)[0 .. T.sizeof], memory))(args[0]);
+        static if (hasElaborateCopyConstructor!T)
+        {
+            result.__postblit();
+        }
+    }
+    else static if (is(typeof({ T t = T(args); })))
+    {
+        auto init = T(args);
+        (() @trusted => moveEmplace(init, *result))();
+    }
     else
     {
         static assert(false,
@@ -245,6 +240,59 @@ do
     static assert(is(typeof(emplace!F((void[]).init))));
 }
 
+// Can emplace structs without a constructor
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(typeof(emplace!WithDtor(null, WithDtor()))));
+    static assert(is(typeof(emplace!WithDtor(null))));
+}
+
+// Doesn't call a destructor on uninitialized elements
+@nogc nothrow pure @system unittest
+{
+    static struct SWithDtor
+    {
+        private bool canBeInvoked = false;
+        ~this() @nogc nothrow pure @safe
+        {
+            assert(this.canBeInvoked);
+        }
+    }
+    void[SWithDtor.sizeof] memory = void;
+    auto actual = emplace!SWithDtor(memory[], SWithDtor(true));
+    assert(actual.canBeInvoked);
+}
+
+// Initializes structs if no arguments are given
+@nogc nothrow pure @safe unittest
+{
+    static struct SEntry
+    {
+        byte content;
+    }
+    ubyte[1] mem = [3];
+
+    assert(emplace!SEntry(cast(void[]) mem[0 .. 1]).content == 0);
+}
+
+// Postblit is called when emplacing a struct
+@nogc nothrow pure @system unittest
+{
+    static struct S
+    {
+        bool called = false;
+        this(this) @nogc nothrow pure @safe
+        {
+            this.called = true;
+        }
+    }
+    S target;
+    S* sp = &target;
+
+    emplace!S(sp[0 .. 1], S());
+    assert(target.called);
+}
+
 /**
  * Thrown if a type conversion fails.
  */
@@ -856,13 +904,6 @@ if (is(Unqual!From == bool) && isNumeric!To && !is(Unqual!To == Unqual!From))
     assert(false.to!int == 0);
 }
 
-deprecated("Use tanya.format.format instead")
-To to(To, From)(auto ref From from)
-if (is(Unqual!To == String))
-{
-    return format!"{}"(from);
-}
-
 /**
  * Converts a stringish range to an integral value.
  *

source/tanya/format.d

@@ -17,11 +17,19 @@
  * To escape `{` or `}`, use `{{` and `}}` respectively. `{{` will be outputted
  * as a single `{`, `}}` - as a single `}`.
  *
- * If a custom data type (like $(D_KEYWORD struct) or $(D_KEYWORD class))
- * defines a `stringify()` function that is callable without arguments and
- * returns a $(D_PSYMBOL String), this function is used to produce a string
- * representation for the value. String conversions for the most built-in
- * data types a also available.
+ * To define the string representation for a custom data type (like
+ * $(D_KEYWORD class) or $(D_KEYWORD struct)), `toString()`-function can be
+ * implemented for that type. `toString()` should be $(D_KEYWORD const) and
+ * accept exactly one argument: an output range for `const(char)[]`. It should
+ * return the same output range, advanced after putting the corresponding value
+ * into it. That is `toString()` signature should look like:
+ *
+ * ---
+ * OR toString(OR)(OR range) const
+ * if (isOutputRange!(OR, const(char)[]));
+ * ---
+ *
+ * String conversions for the most built-in data types a also available.
  *
  * $(D_KEYWORD char), $(D_KEYWORD wchar) and $(D_KEYWORD dchar) ranges are
  * outputted as plain strings (without any delimiters between their elements).
@@ -30,7 +38,7 @@
  *
  * More advanced formatting is currently not implemented.
  *
- * Copyright: Eugene Wissner 2017-2018.
+ * Copyright: Eugene Wissner 2017-2019.
  * 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)
@@ -43,12 +51,11 @@ import tanya.algorithm.comparison;
 import tanya.container.string;
 import tanya.encoding.ascii;
 import tanya.math;
-import tanya.memory.op;
+static import tanya.memory.op;
 import tanya.meta.metafunction;
 import tanya.meta.trait;
 import tanya.meta.transform;
-import tanya.range.array;
-import tanya.range.primitive;
+import tanya.range;
 import tanya.typecons : Tuple;
 
 // Returns the last part of buffer with converted number.
@@ -1351,7 +1358,7 @@ do
         intSlice.popBack();
     }
     const begin = buffer.length - intSlice.length;
-    copy(intSlice, buffer[begin .. $]);
+    tanya.memory.op.copy(intSlice, buffer[begin .. $]);
 
     exponent = cast(int) (intSlice.length + mismatch);
 
@@ -1388,7 +1395,7 @@ do
 
     char[21] intBuffer;
     auto intSlice = integral2String(decimal, intBuffer);
-    copy(intSlice, buffer);
+    tanya.memory.op.copy(intSlice, buffer);
     exponent = cast(int) intSlice.length;
 
     size_t position = exponent;
@@ -1903,7 +1910,7 @@ private char[] errol3(double value,
         if (pathologies[middle].representation == bits.integral)
         {
             exponent = pathologies[middle].exponent;
-            copy(pathologies[middle].digits, buffer);
+            tanya.memory.op.copy(pathologies[middle].digits, buffer);
             return buffer[0 .. pathologies[middle].digits.length];
         }
         else if (pathologies[middle].representation < bits.integral)
@@ -1989,7 +1996,7 @@ private const(char)[] real2String(double value,
     }
 }
 
-private void formatReal(T)(ref T arg, ref String result)
+private void formatReal(T, OR)(ref T arg, OR result)
 if (isFloatingPoint!T)
 {
     char[512] buffer; // Big enough for e+308 or e-307.
@@ -2017,11 +2024,11 @@ if (isFloatingPoint!T)
 
     if (negative)
     {
-        result.insertBack('-');
+        put(result, "-");
     }
     if (decimalPoint == special)
     {
-        result.insertBack(realString);
+        put(result, realString);
         return;
     }
 
@@ -2054,7 +2061,7 @@ if (isFloatingPoint!T)
         {
             length = precision + 1;
         }
-        realString[1 .. length].copy(bufferSlice);
+        tanya.memory.op.copy(realString[1 .. length], bufferSlice);
         bufferSlice.popFrontExactly(length - 1);
 
         // Dump the exponent.
@@ -2116,7 +2123,7 @@ if (isFloatingPoint!T)
                 n = precision;
             }
 
-            fill!'0'(bufferSlice[0 .. n]);
+            tanya.memory.op.fill!'0'(bufferSlice[0 .. n]);
             bufferSlice.popFrontExactly(n);
 
             if ((length + n) > precision)
@@ -2124,7 +2131,7 @@ if (isFloatingPoint!T)
                 length = precision - n;
             }
 
-            realString[0 .. length].copy(bufferSlice);
+            tanya.memory.op.copy(realString[0 .. length], bufferSlice);
             bufferSlice.popFrontExactly(length);
         }
         else if (cast(uint) decimalPoint >= length)
@@ -2142,7 +2149,7 @@ if (isFloatingPoint!T)
             {
                 n = decimalPoint - n;
 
-                fill!'0'(bufferSlice[0 .. n]);
+                tanya.memory.op.fill!'0'(bufferSlice[0 .. n]);
                 bufferSlice.popFrontExactly(n);
             }
             if (precision != 0)
@@ -2173,7 +2180,7 @@ if (isFloatingPoint!T)
                 length = precision + decimalPoint;
             }
 
-            realString[n .. length].copy(bufferSlice);
+            tanya.memory.op.copy(realString[n .. length], bufferSlice);
             bufferSlice.popFrontExactly(length - n);
         }
     }
@@ -2181,11 +2188,11 @@ if (isFloatingPoint!T)
     // Get the length that we've copied.
     length = cast(uint) (buffer.length - bufferSlice.length);
 
-    result.insertBack(buffer[64 .. length]); // Number.
-    result.insertBack(tail[1 .. tail[0] + 1]); // Tail.
+    put(result, buffer[64 .. length]); // Number.
+    put(result, tail[1 .. tail[0] + 1]); // Tail.
 }
 
-private void formatStruct(T)(ref T arg, ref String result)
+private void formatStruct(T, OR)(ref T arg, OR result)
 if (is(T == struct))
 {
     template pred(alias f)
@@ -2202,24 +2209,24 @@ if (is(T == struct))
     }
     alias fields = Filter!(pred, __traits(allMembers, T));
 
-    result.insertBack(T.stringof);
-    result.insertBack('(');
+    put(result, T.stringof);
+    put(result, "(");
     static if (fields.length > 0)
     {
         printToString!"{}"(result, __traits(getMember, arg, fields[0]));
         foreach (field; fields[1 .. $])
         {
-            result.insertBack(", ");
+            put(result, ", ");
             printToString!"{}"(result, __traits(getMember, arg, field));
         }
     }
-    result.insertBack(')');
+    put(result, ")");
 }
 
-private void formatRange(T)(ref T arg, ref String result)
+private void formatRange(T, OR)(ref T arg, OR result)
 if (isInputRange!T && !isInfinite!T)
 {
-    result.insertBack('[');
+    put(result, "[");
     if (!arg.empty)
     {
         printToString!"{}"(result, arg.front);
@@ -2227,24 +2234,24 @@ if (isInputRange!T && !isInfinite!T)
     }
     foreach (e; arg)
     {
-        result.insertBack(", ");
+        put(result, ", ");
         printToString!"{}"(result, e);
     }
-    result.insertBack(']');
+    put(result, "]");
 }
 
-private ref String printToString(string fmt, Args...)(return ref String result,
-                                                      auto ref Args args)
+private void printToString(string fmt, OR, Args...)(ref OR result,
+                                                    auto ref Args args)
 {
     alias Arg = Args[0];
 
     static if (is(Unqual!Arg == typeof(null))) // null
     {
-        result.insertBack("null");
+        put(result, "null");
     }
     else static if (is(Unqual!Arg == bool)) // Boolean
     {
-        result.insertBack(args[0] ? "true" : "false");
+        put(result, args[0] ? "true" : "false");
     }
     else static if (is(Arg == enum)) // Enum
     {
@@ -2252,19 +2259,19 @@ private ref String printToString(string fmt, Args...)(return ref String result,
         {
             if (args[0] == __traits(getMember, Arg, m))
             {
-                result.insertBack(m);
+                put(result, m);
             }
         }
     }
     else static if (isSomeChar!Arg || isSomeString!Arg) // String or char
     {
-        result.insertBack(args[0]);
+        put(result, args[0]);
     }
     else static if (isInputRange!Arg
                  && !isInfinite!Arg
                  && isSomeChar!(ElementType!Arg)) // Stringish range
     {
-        result.insertBack(args[0]);
+        put(result, args[0]);
     }
     else static if (isInputRange!Arg && !isInfinite!Arg)
     {
@@ -2272,29 +2279,49 @@ private ref String printToString(string fmt, Args...)(return ref String result,
     }
     else static if (is(Unqual!(typeof(args[0].stringify())) == String))
     {
+        pragma(msg, ".stringify() is deprecated. Use toString() with an output"
+                  ~ " range instead");
         static if (is(Arg == class) || is(Arg == interface))
         {
             if (args[0] is null)
             {
-                result.insertBack("null");
+                put(result, "null");
             }
             else
             {
-                result.insertBack(args[0].stringify()[]);
+                put(result, args[0].stringify()[]);
             }
         }
         else
         {
-            result.insertBack(args[0].stringify()[]);
+            put(result, args[0].stringify()[]);
+        }
+    }
+    else static if (is(typeof(args[0].toString(result)) == OR))
+    {
+        static if (is(Arg == class) || is(Arg == interface))
+        {
+            if (args[0] is null)
+            {
+                put(result, "null");
+            }
+            else
+            {
+                result = args[0].toString(result);
+            }
+        }
+        else
+        {
+            result = args[0].toString(result);
         }
     }
     else static if (is(Arg == class))
     {
-        result.insertBack(args[0] is null ? "null" : args[0].toString());
+        put(result, args[0] is null ? "null" : args[0].toString());
     }
     else static if (is(Arg == interface))
     {
-        result.insertBack(Arg.classinfo.name);
+        put(result, Arg.classinfo.name);
     }
     else static if (is(Arg == struct))
     {
@@ -2302,7 +2329,7 @@ private ref String printToString(string fmt, Args...)(return ref String result,
     }
     else static if (is(Arg == union))
     {
-        result.insertBack(Arg.stringof);
+        put(result, Arg.stringof);
     }
     else static if (isFloatingPoint!Arg) // Float
     {
@@ -2321,21 +2348,19 @@ private ref String printToString(string fmt, Args...)(return ref String result,
         }
         while (address != 0);
 
-        result.insertBack("0x");
-        result.insertBack(buffer[position .. $]);
+        put(result, "0x");
+        put(result, buffer[position .. $]);
     }
     else static if (isIntegral!Arg) // Integer
     {
         char[21] buffer;
-        result.insertBack(integral2String(args[0], buffer));
+        put(result, integral2String(args[0], buffer));
     }
     else
     {
         static assert(false,
                       "Formatting type " ~ Arg.stringof ~ " is not supported");
     }
-
-    return result;
 }
 
 /**
@@ -2351,28 +2376,47 @@ private ref String printToString(string fmt, Args...)(return ref String result,
 String format(string fmt, Args...)(auto ref Args args)
 {
     String formatted;
+    sformat!fmt(backInserter(formatted), args);
+    return formatted;
+}
 
+/**
+ * Produces a string according to the specified format and writes it into an
+ * output range. $(D_PSYMBOL sformat) writes the final string in chunks, so the
+ * output range should be in output range for `const(char)[]`.
+ *
+ * Params:
+ *  fmt    = Format.
+ *  R      = Output range type.
+ *  output = Output range.
+ *  args   = Arguments.
+ *
+ * Returns: $(D_PARAM output).
+ */
+R sformat(string fmt, R, Args...)(R output, auto ref Args args)
+if (isOutputRange!(R, const(char)[]))
+{
     alias Specs = ParseFmt!fmt;
     enum bool FormatSpecFilter(alias spec) = is(typeof(spec) == FormatSpec);
     static assert((Filter!(FormatSpecFilter, ParseFmt!fmt)).length == Args.length,
-                  "Number of the arguments doesn't match the format strign");
+                  "Number of the arguments doesn't match the format string");
 
     foreach (spec; Specs)
     {
         static if (FormatSpecFilter!spec)
         {
-            printToString!"{}"(formatted, args[spec.position]);
+            printToString!"{}"(output, args[spec.position]);
         }
         else static if (isSomeString!(typeof(spec)))
         {
-            formatted.insertBack(spec);
+            put(output, spec);
         }
         else
         {
             static assert(false, "Format string parsed incorrectly");
         }
     }
-    return formatted;
+    return output;
 }
 
 // doesn't print the first argument repeatedly
@@ -2507,14 +2551,15 @@ String format(string fmt, Args...)(auto ref Args args)
     }
     assert(format!"{}"(Nested()) == "Nested(0)");
 
-    static struct WithStringify
+    static struct WithToString
     {
-        String stringify() const @nogc nothrow pure @safe
+        OR toString(OR)(OR range) const
         {
-            return String("stringify method");
+            put(range, "toString method");
+            return range;
         }
     }
-    assert(format!"{}"(WithStringify()) == "stringify method");
+    assert(format!"{}"(WithToString()) == "toString method");
 }
 
 // Aggregate types.
@@ -2536,9 +2581,10 @@ String format(string fmt, Args...)(auto ref Args args)
 
     class B
     {
-        String stringify() @nogc nothrow pure @safe
+        OR toString(OR)(OR range) const
         {
-            return String("Class B");
+            put(range, "Class B");
+            return range;
         }
     }
     assert(format!"{}"(cast(B) null) == "null");

source/tanya/functional.d

@@ -17,21 +17,6 @@ module tanya.functional;
 import tanya.algorithm.mutation;
 import tanya.meta.metafunction;
 
-private template forwardOne(alias arg)
-{
-    static if (__traits(isRef, arg) || __traits(isOut, arg))
-    {
-        alias forwardOne = arg;
-    }
-    else
-    {
-        @property auto forwardOne()
-        {
-            return move(arg);
-        }
-    }
-}
-
 /**
  * Forwards its argument list preserving $(D_KEYWORD ref) and $(D_KEYWORD out)
  * storage classes.
@@ -47,13 +32,35 @@ private template forwardOne(alias arg)
  */
 template forward(args...)
 {
-    static if (args.length == 1)
+    static if (args.length == 0)
     {
-        alias forward = forwardOne!(args[0]);
+        alias forward = AliasSeq!();
+    }
+    else static if (__traits(isRef, args[0]) || __traits(isOut, args[0]))
+    {
+        static if (args.length == 1)
+        {
+            alias forward = args[0];
+        }
+        else
+        {
+            alias forward = AliasSeq!(args[0], forward!(args[1 .. $]));
+        }
     }
     else
     {
-        alias forward = Map!(forwardOne, args);
+        @property auto forwardOne()
+        {
+            return move(args[0]);
+        }
+        static if (args.length == 1)
+        {
+            alias forward = forwardOne;
+        }
+        else
+        {
+            alias forward = AliasSeq!(forwardOne, forward!(args[1 .. $]));
+        }
     }
 }
 

source/tanya/hash/lookup.d

@@ -16,8 +16,9 @@ module tanya.hash.lookup;
 
 import tanya.meta.trait;
 import tanya.range.primitive;
+version (unittest) import tanya.test.stub;
 
-private struct FNV
+private struct Hasher
 {
     static if (size_t.sizeof == 4)
     {
@@ -29,6 +30,11 @@ private struct FNV
         enum ulong offsetBasis = 14695981039346656037UL;
         enum ulong prime = 1099511628211UL;
     }
+    else static if (size_t.sizeof == 16)
+    {
+        enum size_t offsetBasis = (size_t(0x6c62272e07bb0142UL) << 64) + 0x62b821756295c58dUL;
+        enum size_t prime = (size_t(1) << 88) + (1 << 8) + 0x3b;
+    }
     else
     {
         static assert(false, "FNV requires at least 32-bit hash length");
@@ -44,11 +50,33 @@ private struct FNV
         }
         else static if (isScalarType!T || isPointer!T)
         {
-            (() @trusted => add((cast(const ubyte*) &key)[0 .. T.sizeof]))();
+            // Treat as an array of words
+            static if (T.sizeof % size_t.sizeof == 0
+                    && T.alignof >= size_t.alignof)
+                alias CastT = size_t;
+            // (64-bit or 128-bit) Treat as an array of ints
+            else static if (T.sizeof % uint.sizeof == 0
+                    && T.alignof >= uint.alignof)
+                alias CastT = uint;
+            // Treat as an array of bytes
+            else
+                alias CastT = ubyte;
+            add((() @trusted => (cast(const CastT*) &key)[0 .. T.sizeof / CastT.sizeof])());
         }
         else static if (isArray!T && isScalarType!(ElementType!T))
         {
-            add(cast(const ubyte[]) key);
+            // Treat as an array of words
+            static if (ElementType!T.sizeof % size_t.sizeof == 0
+                    && ElementType!T.alignof >= size_t.alignof)
+                alias CastT = size_t;
+            // (64-bit or 128-bit) Treat as an array of ints
+            else static if (ElementType!T.sizeof % uint.sizeof == 0
+                    && ElementType!T.alignof >= uint.alignof)
+                alias CastT = uint;
+            // Treat as an array of bytes
+            else
+                alias CastT = ubyte;
+            add(cast(const CastT[]) key);
         }
         else static if (is(T == typeof(null)))
         {
@@ -67,13 +95,166 @@ private struct FNV
         }
     }
 
-    void add(const ubyte[] key) @nogc nothrow pure @safe
+    void add(scope const ubyte[] key) @nogc nothrow pure @safe
     {
+        // FNV-1a
         foreach (c; key)
         {
             this.hash = (this.hash ^ c) * prime;
         }
     }
+
+    void add(scope const size_t[] key) @nogc nothrow pure @safe
+    {
+        static if (size_t.sizeof == 4)
+        {
+            // Partial MurmurHash3_x86_32 (no finalization)
+            enum uint c1 = 0xcc9e2d51;
+            enum uint c2 = 0x1b873593;
+            alias h1 = hash;
+            foreach (x; key)
+            {
+                auto k1 = x * c1;
+                k1 = (k1 << 15) | (k1 >> (32 - 15));
+                k1 *= c2;
+
+                h1 ^= k1;
+                h1 = (h1 << 13) | (h1 >> (32 - 13));
+                h1 = h1 * 5 + 0xe6546b64;
+            }
+        }
+        else static if (size_t.sizeof == 8)
+        {
+            // Partial 64-bit MurmurHash64A (no finalization)
+            alias h = hash;
+            enum ulong m = 0xc6a4a7935bd1e995UL;
+            foreach (x; key)
+            {
+                auto k = x * m;
+                k ^= k >>> 47;
+                k *= m;
+
+                h ^= k;
+                h *= m;
+            }
+        }
+        else static if (size_t.sizeof == 16)
+        {
+            // Partial MurmurHash3_x64_128 (no finalization)
+            // treating each size_t as a pair of ulong.
+            ulong h1 = cast(ulong) hash;
+            ulong h2 = cast(ulong) (hash >> 64);
+
+            enum ulong c1 = 0x87c37b91114253d5UL;
+            enum ulong c2 = 0x4cf5ad432745937fUL;
+
+            foreach (x; key)
+            {
+                auto k1 = cast(ulong) x;
+                auto k2 = cast(ulong) (x >> 64);
+
+                k1 *= c1; k1 = (k1 << 32) | (k1 >> (64 - 31)); k1 *= c2; h1 ^= k1;
+                h1 = (h1 << 27) | (h1 >> (64 - 27)); h1 += h2; h1 = h1*5+0x52dce729;
+                k2 *= c2; k2 = (k2 << 33) | (k2 >> (64 - 33)); k2 *= c1; h2 ^= k2;
+                h2 = (h2 << 31) | (h2 >> (64 - 31)); h2 += h1; h2 = h2*5+0x38495ab5;
+            }
+
+            hash = cast(size_t) h1 + ((cast(size_t) h2) << 64);
+        }
+        else
+        {
+            static assert(0, "Hash length must be either 32, 64, or 128 bits.");
+        }
+    }
+
+    static if (size_t.sizeof != uint.sizeof)
+    void add(scope const uint[] key) @nogc nothrow pure @trusted
+    {
+        static if (size_t.sizeof == 8)
+        {
+            // Partial 32-bit MurmurHash64B (no finalization)
+            enum uint m = 0x5bd1e995;
+            enum r = 24;
+
+            uint h1 = cast(uint) hash;
+            uint h2 = cast(uint) (hash >> 32);
+            const(uint)* data = key.ptr;
+            auto len = key.length;
+
+            for (; len >= 2; data += 2, len -= 2)
+            {
+                uint k1 = data[0];
+                k1 *= m; k1 ^= k1 >> r; k1 *= m;
+                h1 *= m; h1 ^= k1;
+
+                uint k2 = data[1];
+                k2 *= m; k2 ^= k2 >> r; k2 *= m;
+                h2 *= m; h2 ^= k2;
+            }
+            if (len)
+            {
+                uint k1 = data[0];
+                k1 *= m; k1 ^= k1 >> r; k1 *= m;
+                h1 *= m; h1 ^= k1;
+            }
+            hash = cast(ulong) h1 + ((cast(ulong) h2) << 32);
+        }
+        else static if (size_t.sizeof == 16)
+        {
+            // Partial MurmurHash3_x86_128 (no finalization)
+            enum uint c1 = 0x239b961b;
+            enum uint c2 = 0xab0e9789;
+            enum uint c3 = 0x38b34ae5;
+            enum uint c4 = 0xa1e38b93;
+
+            uint h1 = cast(uint) hash;
+            uint h2 = cast(uint) (hash >> 32);
+            uint h3 = cast(uint) (hash >> 64);
+            uint h4 = cast(uint) (hash >> 96);
+            const(uint)* data = key.ptr;
+            auto len = key.length;
+
+            for (; len >= 4; data += 4, len -= 4)
+            {
+                uint k1 = data[0];
+                uint k2 = data[1];
+                uint k3 = data[2];
+                uint k4 = data[3];
+
+                h1 = (h1 << 19) | (h1 >> (32 - 19)); h1 += h2; h1 = h1*5+0x561ccd1b;
+                k2 *= c2; k2 = (k2 << 16) | (k2 >> (32 - 16)); k2 *= c3; h2 ^= k2;
+                h2 = (h2 << 17) | (h2 >> (32 - 17)); h2 += h3; h2 = h2*5+0x0bcaa747;
+                k3 *= c3; k3 = (k3 << 17) | (k3 >> (32 - 17)); k3 *= c4; h3 ^= k3;
+                h3 = (h3 << 15) | (h3 >> (32 - 15)); h3 += h4; h3 = h3*5+0x96cd1c35;
+                k4 *= c4; k4 = (k4 << 18) | (k4 >> (32 - 18)); k4 *= c1; h4 ^= k4;
+                h4 = (h4 << 13) | (h4 >> (32 - 13)); h4 += h1; h4 = h4*5+0x32ac3b17;
+            }
+            uint k1, k2, k3;
+            switch (len) // 0, 1, 2, 3
+            {
+                case 3:
+                    k3 = data[2];
+                    k3 *= c3; k3 = (k3 << 17) | (k3 >> (32 - 17)); k3 *= c4; h3 ^= k3;
+                    goto case;
+                case 2:
+                    k2 = data[1];
+                    k2 *= c2; k2 = (k2 << 16) | (k2 >> (32 - 16)); k2 *= c3; h2 ^= k2;
+                    goto case;
+                case 1:
+                    k1 = data[0];
+                    k1 *= c1; k1 = (k1 << 15) | (k1 >> (32 - 15)); k1 *= c2; h1 ^= k1;
+                    break;
+            }
+            hash = cast(size_t) h1 +
+                   ((cast(size_t) h2) << 32) +
+                   ((cast(size_t) h3) << 64) +
+                   ((cast(size_t) h4) << 96);
+        }
+        else
+        {
+            static assert(0, "Hash length must be either 32, 64, or 128 bits.");
+        }
+    }
 }
 
 /**
@@ -92,7 +273,8 @@ private struct FNV
  * For pointers and for scalar types implicitly convertible to `size_t` this
  * is an identity operation (i.e. the value is cast to `size_t` and returned
  * unaltered). Integer types wider than `size_t` are XOR folded down to
- * `size_t`. Other scalar types use the FNV-1a (Fowler-Noll-Vo) hash function.
+ * `size_t`. Other scalar types use an architecture-dependent hash function
+ * based on their width and alignment.
  * If the type provides a `toHash`-function, only `toHash()` is called and its
  * result is returned.
  *
@@ -128,9 +310,9 @@ size_t hash(T)(auto ref T key)
     }
     else
     {
-        FNV fnv;
-        fnv(key);
-        return fnv.hash;
+        Hasher hasher;
+        hasher(key);
+        return hasher.hash;
     }
 }
 
@@ -141,14 +323,6 @@ version (unittest)
                                ~ r10!x ~ r10!x ~ r10!x ~ r10!x ~ r10!x;
     enum string r500(string x) = r100!x ~ r100!x ~ r100!x ~ r100!x ~ r100!x;
 
-    private static struct ToHash
-    {
-        size_t toHash() const @nogc nothrow pure @safe
-        {
-            return 0;
-        }
-    }
-
     private static struct HashRange
     {
         string fo = "fo";
@@ -173,9 +347,9 @@ version (unittest)
     {
         bool empty_;
 
-        @property ToHash front() const @nogc nothrow pure @safe
+        @property Hashable front() const @nogc nothrow pure @safe
         {
-            return ToHash();
+            return Hashable();
         }
 
         void popFront() @nogc nothrow pure @safe
@@ -194,19 +368,19 @@ version (unittest)
 @nogc nothrow pure @safe unittest
 {
     assert(hash(null) == 0);
-    assert(hash(ToHash()) == 0U);
+    assert(hash(Hashable()) == 0U);
     assert(hash('a') == 'a');
 }
 
 static if (size_t.sizeof == 4) @nogc nothrow pure @safe unittest
 {
     assert(hash(HashRange()) == 0x6222e842U);
-    assert(hash(ToHashRange()) == 1268118805U);
+    assert(hash(ToHashRange()) == 3371162643U);
 }
 static if (size_t.sizeof == 8) @nogc nothrow pure @safe unittest
 {
     assert(hash(HashRange()) == 0x08985907b541d342UL);
-    assert(hash(ToHashRange()) == 12161962213042174405UL);
+    assert(hash(ToHashRange()) == 2072958611659694473);
 }
 
 static if (size_t.sizeof == 4) @nogc nothrow pure @system unittest
@@ -636,3 +810,27 @@ static if (size_t.sizeof == 8) @nogc nothrow pure @safe unittest
     assert(hash(r500!"~") == 0xc1af12bdfe16b5b5UL);
     assert(hash(r500!"\x7f") == 0x39e9f18f2f85e221UL);
 }
+
+/**
+ * Determines whether $(D_PARAM hasher) is hash function for $(D_PARAM T), i.e.
+ * it is callable with a value of type $(D_PARAM T) and returns a
+ * $(D_PSYMBOL size_t) value.
+ *
+ * Params:
+ *  hasher = Hash function candidate.
+ *  T      = Type to test the hash function with.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM hasher) is a hash function for
+ *          $(D_PARAM T), $(D_KEYWORD false) otherwise.
+ */
+template isHashFunction(alias hasher, T)
+{
+    private alias wrapper = (T x) => hasher(x);
+    enum bool isHashFunction = is(typeof(wrapper(T.init)) == size_t);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static assert(isHashFunction!(hash, int));
+}

source/tanya/math/mp.d

@@ -14,16 +14,15 @@
  */
 module tanya.math.mp;
 
-import std.algorithm.comparison : cmp;
-import std.algorithm.mutation : fill, reverse;
-import std.range;
 import tanya.algorithm.comparison;
+import tanya.algorithm.iteration;
 import tanya.algorithm.mutation;
 import tanya.container.array;
 import tanya.encoding.ascii;
 import tanya.memory;
 import tanya.meta.trait;
 import tanya.meta.transform;
+import tanya.range;
 
 /**
  * Algebraic sign.
@@ -629,7 +628,7 @@ struct Integer
         }
         return this.rep[0 .. this.size]
                    .retro
-                   .cmp(that.rep[0 .. that.size].retro);
+                   .compare(that.rep[0 .. that.size].retro);
     }
 
     /**
@@ -930,7 +929,7 @@ struct Integer
             const shift = digitBitCount - bit;
             digit carry;
 
-            foreach (ref d; this.rep[0 .. this.size].retro)
+            foreach_reverse (ref d; this.rep[0 .. this.size])
             {
                 const newCarry = d & mask;
                 d = (d >> bit) | (carry << shift);
@@ -1506,14 +1505,11 @@ struct Integer
             tmp = this;
         }
 
-        do
+        array.length = length;
+        for (size_t i = array.length - 1; tmp != 0; tmp >>= 8, --i)
         {
-            array.insertBack(cast(ubyte) (tmp.rep[0] & 0xff));
-            tmp >>= 8;
+            array[i] = (cast(ubyte) (tmp.rep[0] & 0xff));
         }
-        while (tmp != 0);
-
-        array[].reverse();
 
         return array;
     }

source/tanya/math/random.d

@@ -15,11 +15,8 @@
 module tanya.math.random;
 
 import std.digest.sha;
-import std.typecons;
 import tanya.memory;
-
-/// Block size of entropy accumulator (SHA-512).
-enum blockSize = 64;
+import tanya.typecons;
 
 /// Maximum amount gathered from the entropy sources.
 enum maxGather = 128;
@@ -39,7 +36,7 @@ class EntropyException : Exception
     this(string msg,
          string file = __FILE__,
          size_t line = __LINE__,
-         Throwable next = null) pure @safe nothrow const @nogc
+         Throwable next = null) const @nogc nothrow pure @safe
     {
         super(msg, file, line, next);
     }
@@ -56,17 +53,17 @@ abstract class EntropySource
     /**
      * Returns: Minimum bytes required from the entropy source.
      */
-    @property ubyte threshold() const pure nothrow @safe @nogc;
+    @property ubyte threshold() const @nogc nothrow pure @safe;
 
     /**
      * Returns: Whether this entropy source is strong.
      */
-    @property bool strong() const pure nothrow @safe @nogc;
+    @property bool strong() const @nogc nothrow pure @safe;
 
     /**
      * Returns: Amount of already generated entropy.
      */
-    @property ushort size() const pure nothrow @safe @nogc
+    @property ushort size() const @nogc nothrow pure @safe
     {
         return size_;
     }
@@ -76,7 +73,7 @@ abstract class EntropySource
      *  size = Amount of already generated entropy. Cannot be smaller than the
      *         already set value.
      */
-    @property void size(ushort size) pure nothrow @safe @nogc
+    @property void size(ushort size) @nogc nothrow pure @safe
     {
         size_ = size;
     }
@@ -89,9 +86,13 @@ abstract class EntropySource
      *           to fill the buffer).
      *
      * Returns: Number of bytes that were copied to the $(D_PARAM output)
-     *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+     *          or nothing on error.
+     *
+     * Postcondition: Returned length is less than or equal to
+     *                $(D_PARAM output) length.
      */
-    Nullable!ubyte poll(out ubyte[maxGather] output) @nogc;
+    Option!ubyte poll(out ubyte[maxGather] output) @nogc
+    out (length; length.isNothing || length.get <= maxGather);
 }
 
 version (CRuntime_Bionic)
@@ -118,7 +119,7 @@ else version (Solaris)
 version (linux)
 {
     import core.stdc.config : c_long;
-    extern (C) c_long syscall(c_long number, ...) nothrow @system @nogc;
+    private extern(C) c_long syscall(c_long number, ...) @nogc nothrow @system;
 
     /**
      * Uses getrandom system call.
@@ -128,7 +129,7 @@ version (linux)
         /**
          * Returns: Minimum bytes required from the entropy source.
          */
-        override @property ubyte threshold() const pure nothrow @safe @nogc
+        override @property ubyte threshold() const @nogc nothrow pure @safe
         {
             return 32;
         }
@@ -136,7 +137,7 @@ version (linux)
         /**
          * Returns: Whether this entropy source is strong.
          */
-        override @property bool strong() const pure nothrow @safe @nogc
+        override @property bool strong() const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -149,19 +150,14 @@ version (linux)
          *           to fill the buffer).
          *
          * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+         *          or nothing on error.
          */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) nothrow @nogc
-        out (length)
-        {
-            assert(length <= maxGather);
-        }
-        do
+        override Option!ubyte poll(out ubyte[maxGather] output) @nogc nothrow
         {
             // int getrandom(void *buf, size_t buflen, unsigned int flags);
             import mir.linux._asm.unistd : NR_getrandom;
             auto length = syscall(NR_getrandom, output.ptr, output.length, 0);
-            Nullable!ubyte ret;
+            Option!ubyte ret;
 
             if (length >= 0)
             {
@@ -170,19 +166,11 @@ version (linux)
             return ret;
         }
     }
-
-    @nogc @system unittest
-    {
-        auto entropy = defaultAllocator.make!Entropy();
-        ubyte[blockSize] output;
-        output = entropy.random;
-
-        defaultAllocator.dispose(entropy);
-    }
 }
 else version (SecureARC4Random)
 {
-    private extern (C) void arc4random_buf(scope void* buf, size_t nbytes) nothrow @nogc @system;
+    private extern(C) void arc4random_buf(scope void* buf, size_t nbytes)
+    @nogc nothrow @system;
 
     /**
      * Uses arc4random_buf.
@@ -192,7 +180,7 @@ else version (SecureARC4Random)
         /**
          * Returns: Minimum bytes required from the entropy source.
          */
-        override @property ubyte threshold() const pure nothrow @safe @nogc
+        override @property ubyte threshold() const @nogc nothrow pure @safe
         {
             return 32;
         }
@@ -200,7 +188,7 @@ else version (SecureARC4Random)
         /**
          * Returns: Whether this entropy source is strong.
          */
-        override @property bool strong() const pure nothrow @safe @nogc
+        override @property bool strong() const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -213,23 +201,15 @@ else version (SecureARC4Random)
          *           to fill the buffer).
          *
          * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+         *          or nothing on error.
          */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) nothrow @nogc @safe
+        override Option!ubyte poll(out ubyte[maxGather] output)
+        @nogc nothrow @safe
         {
             (() @trusted => arc4random_buf(output.ptr, output.length))();
-            return Nullable!ubyte(cast(ubyte) (output.length));
+            return Option!ubyte(cast(ubyte) (output.length));
         }
     }
-
-    @nogc @system unittest
-    {
-        auto entropy = defaultAllocator.make!Entropy();
-        ubyte[blockSize] output;
-        output = entropy.random;
-
-        defaultAllocator.dispose(entropy);
-    }
 }
 else version (Windows)
 {
@@ -248,22 +228,31 @@ else version (Windows)
         BOOL CryptReleaseContext(HCRYPTPROV, ULONG_PTR);
     }
 
-    private bool initCryptGenRandom(scope ref HCRYPTPROV hProvider) @nogc nothrow @trusted
+    private bool initCryptGenRandom(scope ref HCRYPTPROV hProvider)
+    @nogc nothrow @trusted
     {
         // https://msdn.microsoft.com/en-us/library/windows/desktop/aa379886(v=vs.85).aspx
         // For performance reasons, we recommend that you set the pszContainer
         // parameter to NULL and the dwFlags parameter to CRYPT_VERIFYCONTEXT
         // in all situations where you do not require a persisted key.
-        // CRYPT_SILENT is intended for use with applications for which the UI cannot be displayed by the CSP.
-        if (!CryptAcquireContextW(&hProvider, null, null, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
+        // CRYPT_SILENT is intended for use with applications for which the UI
+        // cannot be displayed by the CSP.
+        if (!CryptAcquireContextW(&hProvider,
+                                  null,
+                                  null,
+                                  PROV_RSA_FULL,
+                                  CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
         {
-            if (GetLastError() == NTE_BAD_KEYSET)
+            if (GetLastError() != NTE_BAD_KEYSET)
             {
-                // Attempt to create default container
-                if (!CryptAcquireContextA(&hProvider, null, null, PROV_RSA_FULL, CRYPT_NEWKEYSET | CRYPT_SILENT))
-                    return false;
+                return false;
             }
-            else
+            // Attempt to create default container
+            if (!CryptAcquireContextA(&hProvider,
+                                      null,
+                                      null,
+                                      PROV_RSA_FULL,
+                                      CRYPT_NEWKEYSET | CRYPT_SILENT))
             {
                 return false;
             }
@@ -299,7 +288,7 @@ else version (Windows)
         /**
          * Returns: Minimum bytes required from the entropy source.
          */
-        override @property ubyte threshold() const pure nothrow @safe @nogc
+        override @property ubyte threshold() const @nogc nothrow pure @safe
         {
             return 32;
         }
@@ -307,7 +296,7 @@ else version (Windows)
         /**
          * Returns: Whether this entropy source is strong.
          */
-        override @property bool strong() const pure nothrow @safe @nogc
+        override @property bool strong() const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -320,16 +309,14 @@ else version (Windows)
          *           to fill the buffer).
          *
          * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+         *          or nothing on error.
          */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) @nogc nothrow @safe
-        in
+        override Option!ubyte poll(out ubyte[maxGather] output)
+        @nogc nothrow @safe
         {
-            assert(hProvider > 0, "hProvider not properly initialized.");
-        }
-        do
-        {
-            Nullable!ubyte ret;
+            Option!ubyte ret;
+
+            assert(hProvider > 0, "hProvider not properly initialized");
             if ((() @trusted => CryptGenRandom(hProvider, output.length, cast(PBYTE) output.ptr))())
             {
                 ret = cast(ubyte) (output.length);
@@ -337,185 +324,14 @@ else version (Windows)
             return ret;
         }
     }
-
-    @nogc @system unittest
-    {
-        auto entropy = defaultAllocator.make!Entropy();
-        ubyte[blockSize] output;
-        output = entropy.random;
-
-        defaultAllocator.dispose(entropy);
-    }
 }
 
-/**
- * Pseudorandom number generator.
- * ---
- * auto entropy = defaultAllocator.make!Entropy();
- *
- * ubyte[blockSize] output;
- *
- * output = entropy.random;
- *
- * defaultAllocator.dispose(entropy);
- * ---
- */
-class Entropy
+static if (is(PlatformEntropySource)) @nogc @system unittest
 {
-    /// Entropy sources.
-    protected EntropySource[] sources;
+    import tanya.memory.smartref : unique;
 
-    private ubyte sourceCount_;
+    auto source = defaultAllocator.unique!PlatformEntropySource();
 
-    /// Entropy accumulator.
-    protected SHA!(maxGather * 8, 512) accumulator;
-
-    /**
-     * Params:
-     *  maxSources = Maximum amount of entropy sources can be set.
-     *  allocator  = Allocator to allocate entropy sources available on the
-     *               system.
-     */
-    this(const size_t maxSources = 20,
-         shared Allocator allocator = defaultAllocator) @nogc
-    in
-    {
-        assert(maxSources > 0 && maxSources <= ubyte.max);
-        assert(allocator !is null);
-    }
-    do
-    {
-        allocator.resize(sources, maxSources);
-
-        static if (is(PlatformEntropySource))
-        {
-            this ~= allocator.make!PlatformEntropySource;
-        }
-    }
-
-    /**
-     * Returns: Amount of the registered entropy sources.
-     */
-    @property ubyte sourceCount() const pure nothrow @safe @nogc
-    {
-        return sourceCount_;
-    }
-
-    /**
-     * Add an entropy source.
-     *
-     * Params:
-     *  source = Entropy source.
-     *
-     * Returns: $(D_PSYMBOL this).
-     *
-     * See_Also:
-     *  $(D_PSYMBOL EntropySource)
-     */
-    Entropy opOpAssign(string op)(EntropySource source)
-    pure nothrow @safe @nogc
-    if (op == "~")
-    in
-    {
-        assert(sourceCount_ <= sources.length);
-    }
-    do
-    {
-        sources[sourceCount_++] = source;
-        return this;
-    }
-
-    /**
-     * Returns: Generated random sequence.
-     *
-     * Throws: $(D_PSYMBOL EntropyException) if no strong entropy source was
-     *         registered or it failed.
-     */
-    @property ubyte[blockSize] random() @nogc
-    in
-    {
-        assert(sourceCount_ > 0, "No entropy sources defined.");
-    }
-    do
-    {
-        bool haveStrong;
-        ushort done;
-        ubyte[blockSize] output;
-
-        do
-        {
-            ubyte[maxGather] buffer;
-
-            // Run through our entropy sources
-            for (ubyte i; i < sourceCount; ++i)
-            {
-                auto outputLength = sources[i].poll(buffer);
-
-                if (!outputLength.isNull)
-                {
-                    if (outputLength > 0)
-                    {
-                        update(i, buffer, outputLength);
-                        sources[i].size = cast(ushort) (sources[i].size + outputLength);
-                    }
-                    if (sources[i].size < sources[i].threshold)
-                    {
-                        continue;
-                    }
-                    else if (sources[i].strong)
-                    {
-                        haveStrong = true;
-                    }
-                }
-                done = 257;
-            }
-        }
-        while (++done < 256);
-
-        if (!haveStrong)
-        {
-            throw defaultAllocator.make!EntropyException("No strong entropy source defined.");
-        }
-
-        output = accumulator.finish();
-
-        // Reset accumulator and counters and recycle existing entropy
-        accumulator.start();
-
-        // Perform second SHA-512 on entropy
-        output = sha512Of(output);
-
-        for (ubyte i; i < sourceCount; ++i)
-        {
-            sources[i].size = 0;
-        }
-        return output;
-    }
-
-    /**
-     * Update entropy accumulator.
-     *
-     * Params:
-     *  sourceId = Entropy source index in $(D_PSYMBOL sources).
-     *  data     = Data got from the entropy source.
-     *  length   = Length of the received data.
-     */
-    protected void update(in ubyte sourceId,
-                          ref ubyte[maxGather] data,
-                          ubyte length) pure nothrow @safe @nogc
-    {
-        ubyte[2] header;
-
-        if (length > blockSize)
-        {
-            data[0 .. 64] = sha512Of(data);
-            length = blockSize;
-        }
-
-        header[0] = sourceId;
-        header[1] = length;
-
-        accumulator.put(header);
-        accumulator.put(data[0 .. length]);
-    }
+    assert(source.threshold == 32);
+    assert(source.strong);
 }

source/tanya/memory/op.d

@@ -24,7 +24,7 @@ version (TanyaNative)
     extern private void moveMemory(const void[], void[])
     pure nothrow @system @nogc;
 
-    extern private int cmpMemory(const void[], const void[])
+    extern private bool equalMemory(const void[], const void[])
     pure nothrow @system @nogc;
 }
 else
@@ -43,7 +43,7 @@ version (TanyaNative)
 
     @nogc nothrow pure @safe unittest
     {
-        assert(cmp(null, null) == 0);
+        assert(equal(null, null));
     }
 }
 
@@ -91,7 +91,7 @@ do
     ubyte[9] source = [1, 2, 3, 4, 5, 6, 7, 8, 9];
     ubyte[9] target;
     source.copy(target);
-    assert(cmp(source, target) == 0);
+    assert(equal(source, target));
 }
 
 @nogc nothrow pure @safe unittest
@@ -110,7 +110,7 @@ do
         ubyte[8] source = [1, 2, 3, 4, 5, 6, 7, 8];
         ubyte[8] target;
         source.copy(target);
-        assert(cmp(source, target) == 0);
+        assert(equal(source, target));
     }
 }
 
@@ -212,7 +212,7 @@ do
     ubyte[6] expected = [ 'a', 'a', 'a', 'a', 'b', 'b' ];
 
     copyBackward(mem[0 .. 4], mem[2 .. $]);
-    assert(cmp(expected, mem) == 0);
+    assert(equal(expected, mem));
 }
 
 @nogc nothrow pure @safe unittest
@@ -221,76 +221,7 @@ do
     ubyte[9] r2;
 
     copyBackward(r1, r2);
-    assert(cmp(r1, r2) == 0);
-}
-
-/**
- * Compares two memory areas $(D_PARAM r1) and $(D_PARAM r2).
- *
- * $(D_PSYMBOL cmp) returns a positive integer if
- * $(D_INLINECODE r1.length > r2.length) or the first `n` compared bytes of
- * $(D_PARAM r1) found to be greater than the first `n` bytes of $(D_PARAM r2),
- *
- * $(D_PSYMBOL cmp) returns a negative integer if
- * $(D_INLINECODE r2.length > r1.length) or the first `n` compared bytes of
- * $(D_PARAM r1) found to be less than the first `n` bytes of $(D_PARAM r2),
- *
- * `0` is returned otherwise.
- *
- * Returns: Positive integer if $(D_INLINECODE r1 > r2),
- *          negative integer if $(D_INLINECODE r2 > r1),
- *          `0` if $(D_INLINECODE r1 == r2).
- */
-int cmp(const void[] r1, const void[] r2) @nogc nothrow pure @trusted
-in
-{
-    assert(r1.length == 0 || r1.ptr !is null);
-    assert(r2.length == 0 || r2.ptr !is null);
-}
-do
-{
-    version (TanyaNative)
-    {
-        return cmpMemory(r1, r2);
-    }
-    else
-    {
-        if (r1.length > r2.length)
-        {
-            return 1;
-        }
-        return r1.length < r2.length ? -1 : memcmp(r1.ptr, r2.ptr, r1.length);
-    }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    ubyte[4] r1 = [ 'a', 'b', 'c', 'd' ];
-    ubyte[3] r2 = [ 'c', 'a', 'b' ];
-
-    assert(cmp(r1[0 .. 3], r2[]) < 0);
-    assert(cmp(r2[], r1[0 .. 3]) > 0);
-
-    assert(cmp(r1, r2) > 0);
-    assert(cmp(r2, r1) < 0);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    ubyte[16] r1 = [
-        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
-    ];
-    ubyte[16] r2 = [
-        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
-    ];
-
-    assert(cmp(r1, r2) == 0);
-    assert(cmp(r1[1 .. $], r2[1 .. $]) == 0);
-    assert(cmp(r1[0 .. $ - 1], r2[0 .. $ - 1]) == 0);
-    assert(cmp(r1[0 .. 8], r2[0 .. 8]) == 0);
+    assert(equal(r1, r2));
 }
 
 /**
@@ -362,13 +293,13 @@ do
 {
     const ubyte[9] haystack = ['a', 'b', 'c', 'd', 'e', 'f', 'b', 'g', 'h'];
 
-    assert(cmp(find(haystack, 'a'), haystack[]) == 0);
-    assert(cmp(find(haystack, 'b'), haystack[1 .. $]) == 0);
-    assert(cmp(find(haystack, 'c'), haystack[2 .. $]) == 0);
-    assert(cmp(find(haystack, 'd'), haystack[3 .. $]) == 0);
-    assert(cmp(find(haystack, 'e'), haystack[4 .. $]) == 0);
-    assert(cmp(find(haystack, 'f'), haystack[5 .. $]) == 0);
-    assert(cmp(find(haystack, 'h'), haystack[8 .. $]) == 0);
+    assert(equal(find(haystack, 'a'), haystack[]));
+    assert(equal(find(haystack, 'b'), haystack[1 .. $]));
+    assert(equal(find(haystack, 'c'), haystack[2 .. $]));
+    assert(equal(find(haystack, 'd'), haystack[3 .. $]));
+    assert(equal(find(haystack, 'e'), haystack[4 .. $]));
+    assert(equal(find(haystack, 'f'), haystack[5 .. $]));
+    assert(equal(find(haystack, 'h'), haystack[8 .. $]));
     assert(find(haystack, 'i').length == 0);
 
     assert(find(null, 'a').length == 0);
@@ -441,10 +372,66 @@ do
 ///
 @nogc nothrow pure @safe unittest
 {
-    assert(cmp(findNullTerminated("abcdef\0gh"), "abcdef") == 0);
-    assert(cmp(findNullTerminated("\0garbage"), "") == 0);
-    assert(cmp(findNullTerminated("\0"), "") == 0);
-    assert(cmp(findNullTerminated("cstring\0"), "cstring") == 0);
+    assert(equal(findNullTerminated("abcdef\0gh"), "abcdef"));
+    assert(equal(findNullTerminated("\0garbage"), ""));
+    assert(equal(findNullTerminated("\0"), ""));
+    assert(equal(findNullTerminated("cstring\0"), "cstring"));
     assert(findNullTerminated(null) is null);
     assert(findNullTerminated("abcdef") is null);
 }
+
+/**
+ * Compares two memory areas $(D_PARAM r1) and $(D_PARAM r2) for equality.
+ *
+ * Params:
+ *  r1 = First memory block.
+ *  r2 = Second memory block.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM r1) and $(D_PARAM r2) are equal,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool equal(const void[] r1, const void[] r2) @nogc nothrow pure @trusted
+in
+{
+    assert(r1.length == 0 || r1.ptr !is null);
+    assert(r2.length == 0 || r2.ptr !is null);
+}
+do
+{
+    version (TanyaNative)
+    {
+        return equalMemory(r1, r2);
+    }
+    else
+    {
+        return r1.length == r2.length
+            && memcmp(r1.ptr, r2.ptr, r1.length) == 0;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(equal("asdf", "asdf"));
+    assert(!equal("asd", "asdf"));
+    assert(!equal("asdf", "asd"));
+    assert(!equal("asdf", "qwer"));
+}
+
+// Compares unanligned memory
+@nogc nothrow pure @safe unittest
+{
+    ubyte[16] r1 = [
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
+    ];
+    ubyte[16] r2 = [
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
+    ];
+
+    assert(equal(r1, r2));
+    assert(equal(r1[1 .. $], r2[1 .. $]));
+    assert(equal(r1[0 .. $ - 1], r2[0 .. $ - 1]));
+    assert(equal(r1[0 .. 8], r2[0 .. 8]));
+}

source/tanya/memory/package.d

@@ -14,7 +14,7 @@
  */
 module tanya.memory;
 
-import std.algorithm.mutation : uninitializedFill;
+import tanya.algorithm.mutation;
 import tanya.conv;
 import tanya.exception;
 public import tanya.memory.allocator;
@@ -341,13 +341,7 @@ if (isPolymorphicType!T)
 
 package(tanya) void[] finalize(T)(ref T[] p)
 {
-    static if (hasElaborateDestructor!(typeof(p[0])))
-    {
-        foreach (ref e; p)
-        {
-            destroy(e);
-        }
-    }
+    destroyAll(p);
     return p;
 }
 

source/tanya/memory/smartref.d

@@ -30,6 +30,7 @@ import tanya.exception;
 import tanya.memory;
 import tanya.meta.trait;
 import tanya.range.primitive;
+version (unittest) import tanya.test.stub;
 
 private template Payload(T)
 {
@@ -611,19 +612,11 @@ do
 
 @nogc @system unittest
 {
-    static bool destroyed;
-
-    static struct F
+    size_t destroyed;
     {
-        ~this() @nogc nothrow @safe
-        {
-            destroyed = true;
-        }
+        auto rc = defaultAllocator.refCounted!WithDtor(destroyed);
     }
-    {
-        auto rc = defaultAllocator.refCounted!F();
-    }
-    assert(destroyed);
+    assert(destroyed == 1);
 }
 
 /**

source/tanya/meta/metafunction.d

@@ -238,18 +238,6 @@ struct Pack(Args...)
     alias Seq this;
 }
 
-deprecated("Use Pack instead")
-struct Tuple(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
 {
@@ -1813,3 +1801,62 @@ if (T.length == 2)
     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));
+}

source/tanya/meta/trait.d

@@ -1493,6 +1493,8 @@ if (F.length == 1)
 }
 
 /**
+ * Determines whether $(D_PARAM T) defines a symbol $(D_PARAM member).
+ *
  * Params:
  *  T      = Aggregate type.
  *  member = Symbol name.
@@ -1601,7 +1603,7 @@ if (is(T == class) || is(T == struct) || is(T == union))
 }
 
 ///
-pure nothrow @safe unittest
+@nogc pure nothrow @safe unittest
 {
     static struct S
     {
@@ -2613,14 +2615,23 @@ if (is(T == enum))
         }
         else
         {
-            alias getEnumMembers = AliasSeq!(__traits(getMember, T, Args[0]), getEnumMembers!(Args[1 .. $]));
+            alias getEnumMembers = AliasSeq!(__traits(getMember, T, Args[0]),
+                                             getEnumMembers!(Args[1 .. $]));
         }
     }
-    alias EnumMembers = getEnumMembers!(__traits(allMembers, T));
+    private alias allMembers = AliasSeq!(__traits(allMembers, T));
+    static if (allMembers.length == 1)
+    {
+        alias EnumMembers = AliasSeq!(__traits(getMember, T, allMembers));
+    }
+    else
+    {
+        alias EnumMembers = getEnumMembers!allMembers;
+    }
 }
 
 ///
-pure nothrow @nogc @safe unittest
+@nogc nothrow pure @safe unittest
 {
     enum E : int
     {
@@ -2628,7 +2639,17 @@ pure nothrow @nogc @safe unittest
         two,
         three,
     }
-    static assert([E.one, E.two, E.three] == [ EnumMembers!E ]);
+    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);
 }
 
 /**
@@ -2835,6 +2856,46 @@ template hasUDA(alias symbol, alias attr)
     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.

source/tanya/network/socket.d

@@ -53,10 +53,10 @@ module tanya.network.socket;
 import core.stdc.errno;
 import core.time;
 public import std.socket : SocketOption, SocketOptionLevel;
-import std.traits;
-import std.typecons;
 import tanya.algorithm.comparison;
+import tanya.bitmanip;
 import tanya.memory;
+import tanya.meta.trait;
 import tanya.os.error;
 
 /// Value returned by socket operations on error.

source/tanya/range/adapter.d

@@ -3,260 +3,228 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Range adapters.
+ * Range adapters transform some data structures into ranges.
  *
- * A range adapter wraps another range and modifies the way, how the original
- * range is iterated, or the order in which its elements are accessed.
- *
- * All adapters are lazy algorithms, they request the next element of the
- * adapted range on demand.
- *
- * Copyright: Eugene Wissner 2018.
+ * Copyright: Eugene Wissner 2018-2019.
  * 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/range/adapter.d,
  *                 tanya/range/adapter.d)
  */
-deprecated("Use tanya.algorithm.iteration instead")
 module tanya.range.adapter;
 
 import tanya.algorithm.mutation;
-import tanya.math;
-import tanya.range.primitive;
+import tanya.functional;
+import tanya.meta.trait;
+import tanya.range;
 
-private mixin template Take(R, bool exactly)
+version (unittest)
 {
-    private R source;
-    size_t length_;
-
-    @disable this();
-
-    private this(R source, size_t length)
+    static struct Container
     {
-        this.source = source;
-        static if (!exactly && hasLength!R)
+        void insertBack(const(char)[])
         {
-            this.length_ = min(source.length, length);
-        }
-        else
-        {
-            this.length_ = length;
         }
     }
+}
 
-    @property auto ref front()
-    in
+private mixin template InserterCtor()
+{
+    private Container* container;
+
+    private this(ref Container container) @trusted
     {
-        assert(!empty);
-    }
-    do
-    {
-        return this.source.front;
-    }
-
-    void popFront()
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        this.source.popFront();
-        --this.length_;
-    }
-
-    @property bool empty()
-    {
-        static if (exactly || isInfinite!R)
-        {
-            return length == 0;
-        }
-        else
-        {
-            return length == 0 || this.source.empty;
-        }
-    }
-
-    @property size_t length()
-    {
-        return this.length_;
-    }
-
-    static if (hasAssignableElements!R)
-    {
-        @property void front(ref ElementType!R value)
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            this.source.front = value;
-        }
-
-        @property void front(ElementType!R value)
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            this.source.front = move(value);
-        }
-    }
-
-    static if (isForwardRange!R)
-    {
-        typeof(this) save()
-        {
-            return typeof(this)(this.source.save(), length);
-        }
-    }
-    static if (isRandomAccessRange!R)
-    {
-        @property auto ref back()
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            return this.source[this.length - 1];
-        }
-
-        void popBack()
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            --this.length_;
-        }
-
-        auto ref opIndex(size_t i)
-        in
-        {
-            assert(i < length);
-        }
-        do
-        {
-            return this.source[i];
-        }
-
-        static if (hasAssignableElements!R)
-        {
-            @property void back(ref ElementType!R value)
-            in
-            {
-                assert(!empty);
-            }
-            do
-            {
-                this.source[length - 1] = value;
-            }
-
-            @property void back(ElementType!R value)
-            in
-            {
-                assert(!empty);
-            }
-            do
-            {
-                this.source[length - 1] = move(value);
-            }
-
-            void opIndexAssign(ref ElementType!R value, size_t i)
-            in
-            {
-                assert(i < length);
-            }
-            do
-            {
-                this.source[i] = value;
-            }
-
-            void opIndexAssign(ElementType!R value, size_t i)
-            in
-            {
-                assert(i < length);
-            }
-            do
-            {
-                this.source[i] = move(value);
-            }
-        }
-    }
-    static if (hasSlicing!R)
-    {
-        auto opSlice(size_t i, size_t j)
-        in
-        {
-            assert(i <= j);
-            assert(j <= length);
-        }
-        do
-        {
-            return take(this.source[i .. j], length);
-        }
+        this.container = &container;
     }
 }
 
 /**
- * Takes $(D_PARAM n) elements from $(D_PARAM range).
+ * If $(D_PARAM container) is a container with `insertBack`-support,
+ * $(D_PSYMBOL backInserter) returns an output range that puts the elements
+ * into the container with `insertBack`.
  *
- * If $(D_PARAM range) doesn't have $(D_PARAM n) elements, the resulting range
- * spans all elements of $(D_PARAM range).
+ * The resulting output range supports all types `insertBack` supports.
  *
- * $(D_PSYMBOL take) is particulary useful with infinite ranges. You can take
- ` $(B n) elements from such range and pass the result to an algorithm which
- * expects a finit range.
+ * The range keeps a reference to the container passed to it, it doesn't use
+ * any other storage. So there is no method to get the written data out of the
+ * range - the container passed to $(D_PSYMBOL backInserter) contains that data
+ * and can be used directly after all operations on the output range are
+ * completed. It also means that the result range is not allowed to outlive its
+ * container.
  *
  * Params:
- *  R     = Type of the adapted range.
- *  range = The range to take the elements from.
- *  n     = The number of elements to take.
+ *  Container = Container type.
+ *  container = Container used as an output range.
  *
- * Returns: A range containing maximum $(D_PARAM n) first elements of
- *          $(D_PARAM range).
- *
- * See_Also: $(D_PSYMBOL takeExactly).
+ * Returns: `insertBack`-based output range.
  */
-auto take(R)(R range, size_t n)
-if (isInputRange!R)
+auto backInserter(Container)(return scope ref Container container)
+if (hasMember!(Container, "insertBack"))
 {
-    struct Take
+    static struct Inserter
     {
-        mixin .Take!(R, false);
+        void opCall(T)(auto ref T data)
+        {
+            this.container.insertBack(forward!data);
+        }
+
+        mixin InserterCtor;
     }
-    return Take(range, n);
+    return Inserter(container);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static struct Container
+    {
+        int element;
+
+        void insertBack(int element)
+        {
+            this.element = element;
+        }
+    }
+    Container container;
+    backInserter(container)(5);
+
+    assert(container.element == 5);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    auto func()()
+    {
+        Container container;
+        return backInserter(container);
+    }
+    static assert(!is(typeof(func!())));
+}
+
+@nogc nothrow pure @safe unittest
+{
+    Container container;
+    static assert(isOutputRange!(typeof(backInserter(container)), string));
 }
 
 /**
- * Takes exactly $(D_PARAM n) elements from $(D_PARAM range).
+ * If $(D_PARAM container) is a container with `insertFront`-support,
+ * $(D_PSYMBOL frontInserter) returns an output range that puts the elements
+ * into the container with `insertFront`.
  *
- * $(D_PARAM range) must have at least $(D_PARAM n) elements.
+ * The resulting output range supports all types `insertFront` supports.
  *
- * $(D_PSYMBOL takeExactly) is particulary useful with infinite ranges. You can
- ` take $(B n) elements from such range and pass the result to an algorithm
- * which expects a finit range.
+ * The range keeps a reference to the container passed to it, it doesn't use
+ * any other storage. So there is no method to get the written data out of the
+ * range - the container passed to $(D_PSYMBOL frontInserter) contains that data
+ * and can be used directly after all operations on the output range are
+ * completed. It also means that the result range is not allowed to outlive its
+ * container.
  *
  * Params:
- *  R     = Type of the adapted range.
- *  range = The range to take the elements from.
- *  n     = The number of elements to take.
+ *  Container = Container type.
+ *  container = Container used as an output range.
  *
- * Returns: A range containing $(D_PARAM n) first elements of $(D_PARAM range).
- *
- * See_Also: $(D_PSYMBOL take).
+ * Returns: `insertFront`-based output range.
  */
-auto takeExactly(R)(R range, size_t n)
-if (isInputRange!R)
+auto frontInserter(Container)(return scope ref Container container)
+if (hasMember!(Container, "insertFront"))
 {
-    struct TakeExactly
+    static struct Inserter
     {
-        mixin Take!(R, true);
+        void opCall(T)(auto ref T data)
+        {
+            this.container.insertFront(forward!data);
+        }
+
+        mixin InserterCtor;
     }
-    return TakeExactly(range, n);
+    return Inserter(container);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static struct Container
+    {
+        int element;
+
+        void insertFront(int element)
+        {
+            this.element = element;
+        }
+    }
+    Container container;
+    frontInserter(container)(5);
+
+    assert(container.element == 5);
+}
+
+/**
+ * $(D_PSYMBOL arrayInserter) makes an output range out of an array.
+ *
+ * The returned output range accepts single values as well as input ranges that
+ * can be copied into the target array.
+ *
+ * Params:
+ *  Array = Array type.
+ *  array = Array.
+ *
+ * Returns: An output range writing into $(D_PARAM array).
+ */
+auto arrayInserter(Array)(return scope ref Array array)
+if (isArray!Array)
+{
+    static if (is(Array ArrayT : ArrayT[size], size_t size))
+    {
+        alias E = ArrayT;
+    }
+    else
+    {
+        alias E = ElementType!Array;
+    }
+
+    static struct ArrayInserter
+    {
+        private E[] data;
+
+        private this(ref Array data) @trusted
+        {
+            this.data = data[];
+        }
+
+        void opCall(T)(auto ref T data)
+        if (is(T : E))
+        in (!this.data.empty)
+        {
+            put(this.data, data);
+        }
+
+        void opCall(R)(auto ref R data)
+        if (isInputRange!R && isOutputRange!(E[], ElementType!R))
+        {
+            this.data = copy(data, this.data);
+        }
+    }
+    return ArrayInserter(array);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    int[1] array;
+
+    arrayInserter(array)(5);
+    assert(array[0] == 5);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    char[1] array;
+    alias Actual = typeof(arrayInserter(array));
+
+    static assert(isOutputRange!(Actual, char));
+    static assert(isOutputRange!(Actual, char[]));
 }

source/tanya/range/array.d

@@ -54,7 +54,7 @@ module tanya.range.array;
  *
  * Precondition: $(D_INLINECODE array.length > 0).
  */
-@property ref T front(T)(T[] array)
+@property ref inout(T) front(T)(return scope inout(T)[] array)
 in
 {
     assert(array.length > 0);
@@ -94,7 +94,7 @@ do
  *
  * Precondition: $(D_INLINECODE array.length > 0).
  */
-@property ref T back(T)(T[] array)
+@property ref inout(T) back(T)(return scope inout(T)[] array)
 in
 {
     assert(array.length > 0);
@@ -133,7 +133,7 @@ do
  *
  * Precondition: $(D_INLINECODE array.length > 0).
  */
-void popFront(T)(ref T[] array)
+void popFront(T)(scope ref inout(T)[] array)
 in
 {
     assert(array.length > 0);
@@ -144,7 +144,7 @@ do
 }
 
 /// ditto
-void popBack(T)(ref T[] array)
+void popBack(T)(scope ref inout(T)[] array)
 in
 {
     assert(array.length > 0);
@@ -178,7 +178,7 @@ do
  * Returns: $(D_KEYWORD true) if $(D_PARAM array) has no elements,
  *          $(D_KEYWORD false) otherwise.
  */
-@property bool empty(T)(const T[] array)
+@property bool empty(T)(scope const T[] array)
 {
     return array.length == 0;
 }
@@ -203,7 +203,7 @@ do
  *
  * Returns: A copy of the slice $(D_PARAM array).
  */
-@property T[] save(T)(T[] array)
+@property inout(T)[] save(T)(return scope inout(T)[] array)
 {
     return array;
 }

source/tanya/range/primitive.d

@@ -5,7 +5,7 @@
 /**
  * This module defines primitives for working with ranges.
  *
- * Copyright: Eugene Wissner 2017-2018.
+ * Copyright: Eugene Wissner 2017-2019.
  * 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)
@@ -20,6 +20,19 @@ import tanya.meta.trait;
 import tanya.meta.transform;
 import tanya.range.array;
 
+version (unittest)
+{
+    import tanya.test.stub;
+
+    private struct AssertPostblit
+    {
+        this(this) @nogc nothrow pure @safe
+        {
+            assert(false);
+        }
+    }
+}
+
 /**
  * Returns the element type of the range $(D_PARAM R).
  *
@@ -73,10 +86,7 @@ template ElementType(R)
  *
  * See_Also: $(D_PSYMBOL isInfinite).
  */
-template hasLength(R)
-{
-    enum bool hasLength = is(ReturnType!((R r) => r.length) == size_t);
-}
+enum bool hasLength(R) = is(ReturnType!((R r) => r.length) == size_t);
 
 ///
 @nogc nothrow pure @safe unittest
@@ -294,34 +304,6 @@ template hasSlicing(R)
     static assert(hasSlicing!D);
 }
 
-version (unittest)
-{
-    mixin template InputRangeStub()
-    {
-        @property int front() @nogc nothrow pure @safe
-        {
-            return 0;
-        }
-        @property bool empty() const @nogc nothrow pure @safe
-        {
-            return false;
-        }
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
-    }
-    mixin template BidirectionalRangeStub()
-    {
-        @property int back() @nogc nothrow pure @safe
-        {
-            return 0;
-        }
-        void popBack() @nogc nothrow pure @safe
-        {
-        }
-    }
-}
-
 private template isDynamicArrayRange(R)
 {
     static if (is(R E : E[]))
@@ -334,6 +316,26 @@ private template isDynamicArrayRange(R)
     }
 }
 
+private struct Primitive(Candidate, string primitive)
+{
+    auto ref returnType(Candidate candidate)
+    {
+        mixin("return candidate." ~ primitive ~ ";");
+    }
+
+    alias ReturnType = .ReturnType!returnType;
+    static assert(!is(ReturnType == void));
+
+    enum uint attributes = functionAttributes!returnType
+                         & FunctionAttribute.ref_;
+
+    bool opEquals(That)(That) const
+    {
+        return is(ReturnType == That.ReturnType)
+            && attributes == That.attributes;
+    }
+}
+
 /**
  * Determines whether $(D_PARAM R) is an input range.
  *
@@ -353,11 +355,11 @@ private template isDynamicArrayRange(R)
  */
 template isInputRange(R)
 {
-    static if (is(ReturnType!((R r) => r.front()) U)
+    static if (is(Primitive!(R, "front()") U)
             && is(ReturnType!((R r) => r.empty) == bool)
             && is(typeof(R.popFront())))
     {
-        enum bool isInputRange = !is(U == void);
+        enum bool isInputRange = true;
     }
     else
     {
@@ -373,10 +375,12 @@ template isInputRange(R)
         void popFront() @nogc nothrow pure @safe
         {
         }
+
         int front() @nogc nothrow pure @safe
         {
             return 0;
         }
+
         bool empty() const @nogc nothrow pure @safe
         {
             return true;
@@ -391,13 +395,8 @@ template isInputRange(R)
 {
     static struct Range1(T)
     {
-        void popFront()
-        {
-        }
-        int front()
-        {
-            return 0;
-        }
+        mixin InputRangeStub;
+
         T empty() const
         {
             return true;
@@ -408,50 +407,56 @@ template isInputRange(R)
 
     static struct Range2
     {
+        mixin InputRangeStub;
+
         int popFront() @nogc nothrow pure @safe
         {
             return 100;
         }
-        int front() @nogc nothrow pure @safe
-        {
-            return 100;
-        }
-        bool empty() const @nogc nothrow pure @safe
-        {
-            return true;
-        }
     }
     static assert(isInputRange!Range2);
 
     static struct Range3
     {
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
+        mixin InputRangeStub;
+
         void front() @nogc nothrow pure @safe
         {
         }
-        bool empty() const @nogc nothrow pure @safe
-        {
-            return true;
-        }
     }
     static assert(!isInputRange!Range3);
 
     static struct Range4
     {
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
-        int front() @nogc nothrow pure @safe
-        {
-            return 0;
-        }
+        mixin InputRangeStub;
+
         enum bool empty = false;
     }
     static assert(isInputRange!Range4);
 }
 
+// Ranges with non-copyable elements can be input ranges
+@nogc nothrow pure @safe unittest
+{
+    @WithLvalueElements
+    static struct R
+    {
+        mixin InputRangeStub!NonCopyable;
+    }
+    static assert(isInputRange!R);
+}
+
+// Ranges with const non-copyable elements can be input ranges
+@nogc nothrow pure @safe unittest
+{
+    @WithLvalueElements
+    static struct R
+    {
+        mixin InputRangeStub!(const(NonCopyable));
+    }
+    static assert(isInputRange!R);
+}
+
 /**
  * Determines whether $(D_PARAM R) is a forward range.
  *
@@ -489,14 +494,17 @@ template isForwardRange(R)
         void popFront() @nogc nothrow pure @safe
         {
         }
+
         int front() @nogc nothrow pure @safe
         {
             return 0;
         }
+
         bool empty() const @nogc nothrow pure @safe
         {
             return true;
         }
+
         typeof(this) save() @nogc nothrow pure @safe
         {
             return this;
@@ -515,6 +523,7 @@ template isForwardRange(R)
     static struct Range2
     {
         mixin InputRangeStub;
+
         Range1 save() @nogc nothrow pure @safe
         {
             return Range1();
@@ -525,6 +534,7 @@ template isForwardRange(R)
     static struct Range3
     {
         mixin InputRangeStub;
+
         const(typeof(this)) save() const @nogc nothrow pure @safe
         {
             return this;
@@ -553,11 +563,11 @@ template isForwardRange(R)
  */
 template isBidirectionalRange(R)
 {
-    static if (is(ReturnType!((R r) => r.back()) U)
+    static if (is(Primitive!(R, "back()") U)
             && is(typeof(R.popBack())))
     {
         enum bool isBidirectionalRange = isForwardRange!R
-                                      && is(U == ReturnType!((R r) => r.front()));
+                                      && (U() == Primitive!(R, "front()")());
     }
     else
     {
@@ -573,21 +583,26 @@ template isBidirectionalRange(R)
         void popFront() @nogc nothrow pure @safe
         {
         }
+
         void popBack() @nogc nothrow pure @safe
         {
         }
+
         @property int front() @nogc nothrow pure @safe
         {
             return 0;
         }
+
         @property int back() @nogc nothrow pure @safe
         {
             return 0;
         }
+
         bool empty() const @nogc nothrow pure @safe
         {
             return true;
         }
+
         Range save() @nogc nothrow pure @safe
         {
             return this;
@@ -602,33 +617,33 @@ template isBidirectionalRange(R)
 {
     static struct Range(T, U)
     {
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
-        void popBack() @nogc nothrow pure @safe
-        {
-        }
+        mixin BidirectionalRangeStub;
+
         @property T front() @nogc nothrow pure @safe
         {
             return T.init;
         }
+
         @property U back() @nogc nothrow pure @safe
         {
             return U.init;
         }
-        bool empty() const @nogc nothrow pure @safe
-        {
-            return true;
-        }
-        Range save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
     }
     static assert(!isBidirectionalRange!(Range!(int, uint)));
     static assert(!isBidirectionalRange!(Range!(int, const int)));
 }
 
+// Ranges with non-copyable elements can be bidirectional ranges
+@nogc nothrow pure @safe unittest
+{
+    @WithLvalueElements
+    static struct R
+    {
+        mixin BidirectionalRangeStub!NonCopyable;
+    }
+    static assert(isBidirectionalRange!R);
+}
+
 /**
  * Determines whether $(D_PARAM R) is a random-access range.
  *
@@ -654,11 +669,11 @@ template isBidirectionalRange(R)
  */
 template isRandomAccessRange(R)
 {
-    static if (is(ReturnType!((R r) => r.opIndex(size_t.init)) U))
+    static if (is(Primitive!(R, "opIndex(size_t.init)") U))
     {
         enum bool isRandomAccessRange = isInputRange!R
                                      && (hasLength!R || isInfinite!R)
-                                     && is(U == ReturnType!((R r) => r.front()));
+                                     && (U() == Primitive!(R, "front()")());
     }
     else
     {
@@ -674,29 +689,22 @@ template isRandomAccessRange(R)
         void popFront() @nogc nothrow pure @safe
         {
         }
-        void popBack() @nogc nothrow pure @safe
-        {
-        }
+
         @property int front() @nogc nothrow pure @safe
         {
             return 0;
         }
-        @property int back() @nogc nothrow pure @safe
-        {
-            return 0;
-        }
+
         bool empty() const @nogc nothrow pure @safe
         {
             return true;
         }
-        typeof(this) save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
-        int opIndex(const size_t pos) @nogc nothrow pure @safe
+
+        int opIndex(size_t) @nogc nothrow pure @safe
         {
             return 0;
         }
+
         size_t length() const @nogc nothrow pure @safe
         {
             return 0;
@@ -711,15 +719,14 @@ template isRandomAccessRange(R)
         void popFront() @nogc nothrow pure @safe
         {
         }
+
         @property int front() @nogc nothrow pure @safe
         {
             return 0;
         }
+
         enum bool empty = false;
-        typeof(this) save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
+
         int opIndex(const size_t pos) @nogc nothrow pure @safe
         {
             return 0;
@@ -732,76 +739,43 @@ template isRandomAccessRange(R)
 {
     static struct Range1
     {
-        mixin InputRangeStub;
         mixin BidirectionalRangeStub;
-
-        typeof(this) save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
-        int opIndex(const size_t pos) @nogc nothrow pure @safe
-        {
-            return 0;
-        }
+        mixin RandomAccessRangeStub;
     }
     static assert(!isRandomAccessRange!Range1);
 
+    @Length
     static struct Range2(Args...)
     {
-        mixin InputRangeStub;
         mixin BidirectionalRangeStub;
 
-        typeof(this) save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
         int opIndex(Args) @nogc nothrow pure @safe
         {
             return 0;
         }
-        size_t length() const @nogc nothrow pure @safe
-        {
-            return 0;
-        }
     }
     static assert(isRandomAccessRange!(Range2!size_t));
     static assert(!isRandomAccessRange!(Range2!()));
     static assert(!isRandomAccessRange!(Range2!(size_t, size_t)));
 
+    @Length
     static struct Range3
     {
-        mixin InputRangeStub;
         mixin BidirectionalRangeStub;
 
-        typeof(this) save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
         int opIndex(const size_t pos1, const size_t pos2 = 0)
         @nogc nothrow pure @safe
         {
             return 0;
         }
-        size_t length() const @nogc nothrow pure @safe
-        {
-            return 0;
-        }
     }
     static assert(isRandomAccessRange!Range3);
 
     static struct Range4
     {
-        mixin InputRangeStub;
         mixin BidirectionalRangeStub;
+        mixin RandomAccessRangeStub;
 
-        typeof(this) save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
-        int opIndex(const size_t pos1) @nogc nothrow pure @safe
-        {
-            return 0;
-        }
         size_t opDollar() const @nogc nothrow pure @safe
         {
             return 0;
@@ -810,20 +784,40 @@ template isRandomAccessRange(R)
     static assert(!isRandomAccessRange!Range4);
 }
 
+// Ranges with non-copyable elements can be random-access ranges
+@nogc nothrow pure @safe unittest
+{
+    @WithLvalueElements @Infinite
+    static struct R
+    {
+        mixin RandomAccessRangeStub!NonCopyable;
+    }
+    static assert(isRandomAccessRange!R);
+}
+
 /**
  * Puts $(D_PARAM e) into the $(D_PARAM range).
  *
- * $(D_PSYMBOL R) should be an output range for $(D_PARAM E).
- *
- * $(D_PARAM range) is advanced after putting an element into it if all of the
- * following conditions are met:
+ * $(D_PSYMBOL R) should be an output range for $(D_PARAM E), i.e. at least one
+ * of the following conditions should met:
  *
  * $(OL
- *  $(LI $(D_PSYMBOL R) is an input range)
- *  $(LI $(D_PSYMBOL R) doesn't define a `put`-method)
+ *  $(LI $(D_PARAM e) can be put into $(D_PARAM range) using
+ *       $(D_INLINECODE range(e))
  *  $(LI $(D_PARAM e) can be assigned to $(D_INLINECODE range.front))
+ *  )
  * )
  *
+ * The method to put $(D_PARAM e) into $(D_PARAM range) is chosen based on the
+ * order specified above.
+ *
+ * If $(D_PARAM E) is an input range and $(D_PARAM R) is an output range for
+ * its elements as well, use $(D_PSYMBOL tanya.algorithm.mutation.copy)
+ * instead.
+ *
+ * $(D_PARAM range) is advanced after putting an element into it if it is an
+ * input range that doesn't define a `put`-method.
+ *
  * Params:
  *  R     = Target range type.
  *  E     = Source element type.
@@ -837,27 +831,19 @@ void put(R, E)(ref R range, auto ref E e)
     static if (__traits(hasMember, R, "put")
             && is(typeof((R r, E e) => r.put(e))))
     {
+        pragma(msg, "OutputRange.put()-primitive is deprecated. Define opCall() instead.");
         range.put(e);
     }
+    else static if (is(typeof((R r, E e) => r(e))))
+    {
+        range(e);
+    }
     else static if (isInputRange!R
                  && is(typeof((R r, E e) => r.front = e)))
     {
         range.front = e;
         range.popFront();
     }
-    else static if (is(typeof((R r, E e) => r(e))))
-    {
-        range(e);
-    }
-    else static if (isInputRange!E)
-    {
-        pragma(msg, "Putting an input range into an output range is "
-                  ~ "deprecated. Use tanya.algorithm.mutation.copy instead");
-        for (; !e.empty; e.popFront())
-        {
-            put(range, e.front);
-        }
-    }
     else
     {
         static assert(false, R.stringof ~ " is not an output range for "
@@ -875,23 +861,6 @@ void put(R, E)(ref R range, auto ref E e)
     assert(actual == [2, 0]);
 }
 
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct Put
-    {
-        int e;
-
-        void put(int e)
-        {
-            this.e = e;
-        }
-    }
-    Put p;
-    put(p, 2);
-    assert(p.e == 2);
-}
-
 ///
 @nogc nothrow pure @safe unittest
 {
@@ -923,36 +892,28 @@ void put(R, E)(ref R range, auto ref E e)
  *      $(TH Scenario)
  *  )
  *  $(TR
- *      $(TD r.put(e))
- *      $(TD $(D_PARAM R) defines `put` for $(D_PARAM E).)
- *  )
- *  $(TR
- *      $(TD r.front = e)
- *      $(TD $(D_PARAM R) is an input range, whose element type is
- *      $(D_PARAM E) and `front` is an lvalue.)
- *  )
- *  $(TR
  *      $(TD r(e))
  *      $(TD $(D_PARAM R) defines `opCall` for $(D_PARAM E).)
  *  )
  *  $(TR
- *      $(TD for (; !e.empty; e.popFront()) r.put(e.front) $(BR)
- *           for (; !e.empty; e.popFront(), r.popFront())
- *           r.front = e.front $(BR)
- *           for (; !e.empty; e.popFront()) r(e.front)
- *      )
- *      $(TD $(D_PARAM E) is input range, whose elements can be put into
- *           $(D_PARAM R) according to the rules described above in this table.
- *      )
+ *      $(TD r.front = e)
+ *      $(TD $(D_PARAM R) is an input range with assignable elements of type
+ *           $(D_PARAM E).)
  *  )
  * )
  *
+ * Output ranges don't have element type (so $(D_PSYMBOL ElementType) returns
+ * $(D_KEYWORD void) when applied to an output range). It is because an output
+ * range can support puting differently typed elements into it.
+ *
  * Params:
  *  R = The type to be tested.
  *  E = Element type should be tested for.
  *
  * Returns: $(D_KEYWORD true) if $(D_PARAM R) is an output range for the
  *          elements of the type $(D_PARAM E), $(D_KEYWORD false) otherwise.
+ *
+ * See_Also: $(D_PSYMBOL put).
  */
 template isOutputRange(R, E)
 {
@@ -962,6 +923,11 @@ template isOutputRange(R, E)
     }
     else static if (isInputRange!E)
     {
+        pragma(msg, "Deprecation. An input range whose element type is "
+                  ~ "supported by the output range isn't considered itself to "
+                  ~ "be a source for such an output range. Don't rely on this "
+                  ~ "behavior and use tanya.algorithm.copy() to write one "
+                  ~ "range into another one.");
         alias ET = ElementType!E;
         enum bool isOutputRange = is(typeof((R r, ET e) => put(r, e)));
     }
@@ -976,7 +942,7 @@ template isOutputRange(R, E)
 {
     static struct R1
     {
-        void put(int) @nogc nothrow pure @safe
+        void opCall(int) @nogc nothrow pure @safe
         {
         }
     }
@@ -985,13 +951,16 @@ template isOutputRange(R, E)
     static struct R2
     {
         int value;
+
         void popFront() @nogc nothrow pure @safe
         {
         }
+
         ref int front() @nogc nothrow pure @safe
         {
             return value;
         }
+
         bool empty() const @nogc nothrow pure @safe
         {
             return true;
@@ -1004,28 +973,18 @@ template isOutputRange(R, E)
         void popFront() @nogc nothrow pure @safe
         {
         }
+
         int front() @nogc nothrow pure @safe
         {
             return 0;
         }
+
         bool empty() const @nogc nothrow pure @safe
         {
             return true;
         }
     }
     static assert(!isOutputRange!(R3, int));
-
-    static struct R4
-    {
-        void opCall(int) @nogc nothrow pure @safe
-        {
-        }
-    }
-    static assert(isOutputRange!(R4, int));
-
-    static assert(isOutputRange!(R1, R3));
-    static assert(isOutputRange!(R2, R3));
-    static assert(isOutputRange!(R4, R3));
 }
 
 /**
@@ -1095,28 +1054,20 @@ template isInfinite(R)
 
 @nogc nothrow pure @safe unittest
 {
+    @Infinite
     static struct StaticConstRange
     {
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
-        @property int front() @nogc nothrow pure @safe
-        {
-            return 0;
-        }
+        mixin InputRangeStub;
+
         static bool empty = false;
     }
     static assert(!isInfinite!StaticConstRange);
 
+    @Infinite
     static struct TrueRange
     {
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
-        @property int front() @nogc nothrow pure @safe
-        {
-            return 0;
-        }
+        mixin InputRangeStub;
+
         static const bool empty = true;
     }
     static assert(!isInfinite!TrueRange);
@@ -1346,15 +1297,12 @@ if (isBidirectionalRange!R)
 
 @nogc nothrow pure @safe unittest
 {
+    @Infinite
     static struct InfiniteRange
     {
+        mixin ForwardRangeStub;
         private int i;
 
-        InfiniteRange save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
-
         void popFront() @nogc nothrow pure @safe
         {
             ++this.i;
@@ -1374,8 +1322,6 @@ if (isBidirectionalRange!R)
         {
             return this.i;
         }
-
-        enum bool empty = false;
     }
     {
         InfiniteRange range;
@@ -1495,44 +1441,19 @@ if (isInputRange!R)
 
 @nogc nothrow pure @safe unittest
 {
-    static struct Element
-    {
-        this(this) @nogc nothrow pure @safe
-        {
-            assert(false);
-        }
-    }
-
     // Returns its elements by reference.
+    @Infinite @WithLvalueElements
     static struct R1
     {
-        Element element;
-        enum bool empty = false;
-
-        ref Element front() @nogc nothrow pure @safe
-        {
-            return element;
-        }
-
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
+        mixin InputRangeStub!AssertPostblit;
     }
     static assert(is(typeof(moveFront(R1()))));
 
     // Returns elements with a postblit constructor by value. moveFront fails.
+    @Infinite
     static struct R2
     {
-        enum bool empty = false;
-
-        Element front() @nogc nothrow pure @safe
-        {
-            return Element();
-        }
-
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
+        mixin InputRangeStub!AssertPostblit;
     }
     static assert(!is(typeof(moveFront(R2()))));
 }
@@ -1580,58 +1501,19 @@ if (isBidirectionalRange!R)
 
 @nogc nothrow pure @safe unittest
 {
-    static struct Element
-    {
-        this(this) @nogc nothrow pure @safe
-        {
-            assert(false);
-        }
-    }
-
     // Returns its elements by reference.
+    @Infinite @WithLvalueElements
     static struct R1
     {
-        Element element;
-        enum bool empty = false;
-
-        ref Element back() @nogc nothrow pure @safe
-        {
-            return element;
-        }
-        alias front = back;
-
-        void popBack() @nogc nothrow pure @safe
-        {
-        }
-        alias popFront = popBack;
-
-        R1 save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
+        mixin BidirectionalRangeStub!AssertPostblit;
     }
     static assert(is(typeof(moveBack(R1()))));
 
     // Returns elements with a postblit constructor by value. moveBack fails.
+    @Infinite
     static struct R2
     {
-        enum bool empty = false;
-
-        Element back() @nogc nothrow pure @safe
-        {
-            return Element();
-        }
-        alias front = back;
-
-        void popBack() @nogc nothrow pure @safe
-        {
-        }
-        alias popFront = popBack;
-
-        R2 save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
+        mixin BidirectionalRangeStub!AssertPostblit;
     }
     static assert(!is(typeof(moveBack(R2()))));
 }
@@ -1678,54 +1560,19 @@ if (isRandomAccessRange!R)
 
 @nogc nothrow pure @safe unittest
 {
-    static struct Element
-    {
-        this(this) @nogc nothrow pure @safe
-        {
-            assert(false);
-        }
-    }
-
     // Returns its elements by reference.
+    @Infinite @WithLvalueElements
     static struct R1
     {
-        Element element;
-        enum bool empty = false;
-
-        ref Element front() @nogc nothrow pure @safe
-        {
-            return element;
-        }
-
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
-
-        ref Element opIndex(size_t)
-        {
-            return element;
-        }
+        mixin RandomAccessRangeStub!AssertPostblit;
     }
     static assert(is(typeof(moveAt(R1(), 0))));
 
     // Returns elements with a postblit constructor by value. moveAt fails.
+    @Infinite
     static struct R2
     {
-        enum bool empty = false;
-
-        Element front() @nogc nothrow pure @safe
-        {
-            return Element();
-        }
-
-        void popFront() @nogc nothrow pure @safe
-        {
-        }
-
-        Element opIndex() @nogc nothrow pure @safe
-        {
-            return Element();
-        }
+        mixin RandomAccessRangeStub!AssertPostblit;
     }
     static assert(!is(typeof(moveAt(R2(), 0))));
 }
@@ -1826,7 +1673,7 @@ template hasMobileElements(R)
  */
 template hasLvalueElements(R)
 {
-    private alias refDg = (ref ElementType!R e) => e;
+    private alias refDg = (ref ElementType!R e) => &e;
 
     static if (isRandomAccessRange!R)
     {
@@ -1884,6 +1731,12 @@ template hasLvalueElements(R)
     static assert(hasLvalueElements!R2);
 }
 
+// Works with non-copyable elements
+@nogc nothrow pure @safe unittest
+{
+    static assert(hasLvalueElements!(NonCopyable[]));
+}
+
 /**
  * Determines whether the elements of $(D_PARAM R) are assignable.
  *
@@ -2039,3 +1892,41 @@ template hasSwappableElements(R)
     }
     static assert(!hasSwappableElements!R2);
 }
+
+/**
+ * Determines whether `r1.front` and `r2.front` point to the same element.
+ *
+ * Params:
+ *  r1 = First range.
+ *  r2 = Second range.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM r1) and $(D_PARAM r2) have the same
+ *          head, $(D_KEYWORD false) otherwise.
+ */
+bool sameHead(Range)(Range r1, Range r2) @trusted
+if (isInputRange!Range && hasLvalueElements!Range)
+{
+    return &r1.front is &r2.front;
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    const int[2] array;
+
+    auto r1 = array[];
+    auto r2 = array[];
+
+    assert(sameHead(r1, r2));
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    const int[2] array;
+
+    auto r1 = array[];
+    auto r2 = array[1 .. $];
+
+    assert(!sameHead(r1, r2));
+}

source/tanya/test/package.d

@@ -15,3 +15,4 @@
 module tanya.test;
 
 public import tanya.test.assertion;
+public import tanya.test.stub;

source/tanya/test/stub.d

@@ -0,0 +1,373 @@
+/* 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/. */
+
+/**
+ * Range and generic type generators.
+ *
+ * Copyright: Eugene Wissner 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/test/stub.d,
+ *                 tanya/test/stub.d)
+ */
+module tanya.test.stub;
+
+/**
+ * Attribute signalizing that the generated range should contain the given
+ * number of elements.
+ *
+ * $(D_PSYMBOL Count) should be always specified with some value and not as a
+ * type, so $(D_INLINECODE Count(1)) instead just $(D_INLINECODE Count),
+ * otherwise you can just omit $(D_PSYMBOL Count) and it will default to 0.
+ *
+ * $(D_PSYMBOL Count) doesn't generate `.length` property - use
+ * $(D_PSYMBOL Length) for that.
+ *
+ * If neither $(D_PSYMBOL Length) nor $(D_PSYMBOL Infinite) is given,
+ * $(D_ILNINECODE Count(0)) is assumed.
+ *
+ * This attribute conflicts with $(D_PSYMBOL Infinite) and $(D_PSYMBOL Length).
+ */
+struct Count
+{
+    /// Original range length.
+    size_t count = 0;
+
+    @disable this();
+
+    /**
+     * Constructs the attribute with the given length.
+     *
+     * Params:
+     *  count = Original range length.
+     */
+    this(size_t count) @nogc nothrow pure @safe
+    {
+        this.count = count;
+    }
+}
+
+/**
+ * Attribute signalizing that the generated range should be infinite.
+ *
+ * This attribute conflicts with $(D_PSYMBOL Count) and $(D_PSYMBOL Length).
+ */
+struct Infinite
+{
+}
+
+/**
+ * Generates `.length` property for the range.
+ *
+ * The length of the range can be specified as a constructor argument,
+ * otherwise it is 0.
+ *
+ * This attribute conflicts with $(D_PSYMBOL Count) and $(D_PSYMBOL Infinite).
+ */
+struct Length
+{
+    /// Original range length.
+    size_t length = 0;
+}
+
+/**
+ * Attribute signalizing that the generated range should return values by
+ * reference.
+ *
+ * This atribute affects the return values of `.front`, `.back` and `[]`.
+ */
+struct WithLvalueElements
+{
+}
+
+/**
+ * Generates an input range.
+ *
+ * Params:
+ *  E = Element type.
+ */
+mixin template InputRangeStub(E = int)
+{
+    import tanya.meta.metafunction : Alias;
+    import tanya.meta.trait : evalUDA, getUDAs, hasUDA;
+
+    /*
+     * Aliases for the attribute lookups to access them faster
+     */
+    private enum bool infinite = hasUDA!(typeof(this), Infinite);
+    private enum bool withLvalueElements = hasUDA!(typeof(this),
+                                                   WithLvalueElements);
+    private alias Count = getUDAs!(typeof(this), .Count);
+    private alias Length = getUDAs!(typeof(this), .Length);
+
+    static if (Count.length != 0)
+    {
+        private enum size_t count = Count[0].count;
+
+        static assert (!infinite,
+                       "Range cannot have count and be infinite at the same time");
+        static assert (Length.length == 0,
+                       "Range cannot have count and length at the same time");
+    }
+    else static if (Length.length != 0)
+    {
+        private enum size_t count = evalUDA!(Length[0]).length;
+
+        static assert (!infinite,
+                       "Range cannot have length and be infinite at the same time");
+    }
+    else static if (!infinite)
+    {
+        private enum size_t count = 0;
+    }
+
+    /*
+     * Member generation
+     */
+    static if (infinite)
+    {
+        enum bool empty = false;
+    }
+    else
+    {
+        private size_t length_ = count;
+
+        @property bool empty() const @nogc nothrow pure @safe
+        {
+            return this.length_ == 0;
+        }
+    }
+
+    static if (withLvalueElements)
+    {
+        private E* element; // Pointer to enable range copying in save()
+    }
+
+    void popFront() @nogc nothrow pure @safe
+    in (!empty)
+    {
+        static if (!infinite)
+        {
+            --this.length_;
+        }
+    }
+
+    static if (withLvalueElements)
+    {
+        ref E front() @nogc nothrow pure @safe
+        in (!empty)
+        {
+            return *this.element;
+        }
+    }
+    else
+    {
+        E front() @nogc nothrow pure @safe
+        in (!empty)
+        {
+            return E.init;
+        }
+    }
+
+    static if (Length.length != 0)
+    {
+        size_t length() const @nogc nothrow pure @safe
+        {
+            return this.length_;
+        }
+    }
+}
+
+/**
+ * Generates a forward range.
+ *
+ * This mixin includes input range primitives as well, but can be combined with
+ * $(D_PSYMBOL RandomAccessRangeStub).
+ *
+ * Params:
+ *  E = Element type.
+ */
+mixin template ForwardRangeStub(E = int)
+{
+    static if (!is(typeof(this.InputRangeMixin) == void))
+    {
+        mixin InputRangeStub!E InputRangeMixin;
+    }
+
+    auto save() @nogc nothrow pure @safe
+    {
+        return this;
+    }
+}
+
+/**
+ * Generates a bidirectional range.
+ *
+ * This mixin includes forward range primitives as well, but can be combined with
+ * $(D_PSYMBOL RandomAccessRangeStub).
+ *
+ * Params:
+ *  E = Element type.
+ */
+mixin template BidirectionalRangeStub(E = int)
+{
+    mixin ForwardRangeStub!E;
+
+    void popBack() @nogc nothrow pure @safe
+    in (!empty)
+    {
+        static if (!infinite)
+        {
+            --this.length_;
+        }
+    }
+
+    static if (withLvalueElements)
+    {
+        ref E back() @nogc nothrow pure @safe
+        in (!empty)
+        {
+            return *this.element;
+        }
+    }
+    else
+    {
+        E back() @nogc nothrow pure @safe
+        in (!empty)
+        {
+            return E.init;
+        }
+    }
+}
+
+/**
+ * Generates a random-access range.
+ *
+ * This mixin includes input range primitives as well, but can be combined with
+ * $(D_PSYMBOL ForwardRangeStub) or $(D_PSYMBOL BidirectionalRangeStub).
+ *
+ * Note that a random-access range also requires $(D_PSYMBOL Length) or
+ * $(D_PARAM Infinite) by definition.
+ *
+ * Params:
+ *  E = Element type.
+ */
+mixin template RandomAccessRangeStub(E = int)
+{
+    static if (!is(typeof(this.InputRangeMixin) == void))
+    {
+        mixin InputRangeStub!E InputRangeMixin;
+    }
+
+    static if (withLvalueElements)
+    {
+        ref E opIndex(size_t) @nogc nothrow pure @safe
+        {
+            return *this.element;
+        }
+    }
+    else
+    {
+        E opIndex(size_t) @nogc nothrow pure @safe
+        {
+            return E.init;
+        }
+    }
+}
+
+/**
+ * Struct with a disabled postblit constructor.
+ *
+ * $(D_PSYMBOL NonCopyable) can be used as an attribute for
+ * $(D_PSYMBOL StructStub) or as a standalone type.
+ */
+struct NonCopyable
+{
+    @disable this(this);
+}
+
+/**
+ * Struct with an elaborate destructor.
+ *
+ * $(D_PSYMBOL WithDtor) can be used as an attribute for
+ * $(D_PSYMBOL StructStub) or as a standalone type.
+ *
+ * When used as a standalone object the constructor of $(D_PSYMBOL WithDtor)
+ * accepts an additional `counter` argument, which is incremented by the
+ * destructor. $(D_PSYMBOL WithDtor) stores a pointer to the passed variable,
+ * so the variable can be investigated after the struct isn't available
+ * anymore.
+ */
+struct WithDtor
+{
+    size_t* counter;
+
+    this(ref size_t counter) @nogc nothrow pure @trusted
+    {
+        this.counter = &counter;
+    }
+
+    ~this() @nogc nothrow pure @safe
+    {
+        if (this.counter !is null)
+        {
+            ++*this.counter;
+        }
+    }
+}
+
+/**
+ * Struct supporting hashing.
+ *
+ * $(D_PSYMBOL Hashable) can be used as an attribute for
+ * $(D_PSYMBOL StructStub) or as a standalone type.
+ *
+ * The constructor accepts an additional parameter, which is returned by the
+ * `toHash()`-function. `0U` is returned if no hash value is given.
+ */
+struct Hashable
+{
+    size_t hash;
+
+    size_t toHash() const @nogc nothrow pure @safe
+    {
+        return this.hash;
+    }
+}
+
+/**
+ * Generates a $(D_KEYWORD struct) with common functionality.
+ *
+ * To specify the needed functionality use user-defined attributes on the
+ * $(D_KEYWORD struct) $(D_PSYMBOL StructStub) is mixed in.
+ *
+ * Supported attributes are: $(D_PSYMBOL NonCopyable), $(D_PSYMBOL Hashable),
+ * $(D_PSYMBOL WithDtor).
+ */
+mixin template StructStub()
+{
+    import tanya.meta.trait : evalUDA, getUDAs, hasUDA;
+
+    static if (hasUDA!(typeof(this), NonCopyable))
+    {
+        @disable this(this);
+    }
+
+    private alias Hashable = getUDAs!(typeof(this), .Hashable);
+    static if (Hashable.length > 0)
+    {
+        size_t toHash() const @nogc nothrow pure @safe
+        {
+            return evalUDA!(Hashable[0]).hash;
+        }
+    }
+
+    static if (hasUDA!(typeof(this), WithDtor))
+    {
+        ~this() @nogc nothrow pure @safe
+        {
+        }
+    }
+}

source/tanya/typecons.d

@@ -8,7 +8,7 @@
  * This module contains templates that allow to build new types from the
  * available ones.
  *
- * Copyright: Eugene Wissner 2017-2018.
+ * Copyright: Eugene Wissner 2017-2019.
  * 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)
@@ -18,9 +18,12 @@
 module tanya.typecons;
 
 import tanya.algorithm.mutation;
+import tanya.conv;
 import tanya.format;
+import tanya.functional;
 import tanya.meta.metafunction;
 import tanya.meta.trait;
+version (unittest) import tanya.test.stub;
 
 /**
  * $(D_PSYMBOL Tuple) can store two or more heterogeneous objects.
@@ -35,6 +38,8 @@ import tanya.meta.trait;
  *
  * Params:
  *  Specs = Field types and names.
+ *
+ * See_Also: $(D_PSYMBOL tuple).
  */
 template Tuple(Specs...)
 {
@@ -133,11 +138,50 @@ template Tuple(Specs...)
     static assert(!is(Tuple!(int, "first", double, "second", char, "third")));
 }
 
+/**
+ * Creates a new $(D_PSYMBOL Tuple).
+ *
+ * Params:
+ *  Names = Field names.
+ *
+ * See_Also: $(D_PSYMBOL Tuple).
+ */
+template tuple(Names...)
+{
+    /**
+     * Creates a new $(D_PSYMBOL Tuple).
+     *
+     * Params:
+     *  Args = Field types.
+     *  args = Field values.
+     *
+     * Returns: Newly created $(D_PSYMBOL Tuple).
+     */
+    auto tuple(Args...)(auto ref Args args)
+    if (Args.length >= Names.length && isTypeTuple!Args)
+    {
+        alias Zipped = ZipWith!(AliasSeq, Pack!Args, Pack!Names);
+        alias Nameless = Args[Names.length .. $];
+
+        return Tuple!(Zipped, Nameless)(forward!args);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    auto t = tuple!("one", "two")(20, 5);
+    assert(t.one == 20);
+    assert(t.two == 5);
+}
+
 /**
  * $(D_PSYMBOL Option) is a type that contains an optional value.
  *
  * Params:
  *  T = Type of the encapsulated value.
+ *
+ * See_Also: $(D_PSYMBOL option).
  */
 struct Option(T)
 {
@@ -184,11 +228,15 @@ struct Option(T)
      * Precondition: `!isNothing`.
      */
     @property ref inout(T) get() inout
-    in
+    in (!isNothing, "Option is nothing")
     {
-        assert(!isNothing, "Option is nothing");
+        return this.value;
     }
-    do
+
+    /// ditto
+    deprecated("Call Option.get explicitly instead of relying on alias this")
+    @property ref inout(T) get_() inout
+    in (!isNothing, "Option is nothing")
     {
         return this.value;
     }
@@ -324,8 +372,15 @@ struct Option(T)
     ref typeof(this) opAssign(U)(ref U that)
     if (is(U == Option))
     {
-        this.value = that;
-        this.isNothing_ = that.isNothing;
+        if (that.isNothing)
+        {
+            reset();
+        }
+        else
+        {
+            this.value = that.get;
+            this.isNothing_ = false;
+        }
         return this;
     }
 
@@ -338,7 +393,25 @@ struct Option(T)
         return this;
     }
 
-    alias get this;
+    version (D_Ddoc)
+    {
+        /**
+         * If $(D_PARAM T) has a `toHash()` method, $(D_PSYMBOL Option) defines
+         * `toHash()` which returns `T.toHash()` if it is set or 0 otherwise.
+         *
+         * Returns: Hash value.
+         */
+        size_t toHash() const;
+    }
+    else static if (is(typeof(T.init.toHash()) == size_t))
+    {
+        size_t toHash() const
+        {
+            return isNothing ? 0U : this.value.toHash();
+        }
+    }
+
+    alias get_ this;
 }
 
 ///
@@ -394,29 +467,24 @@ struct Option(T)
 // Moving
 @nogc nothrow pure @safe unittest
 {
-    static struct NotCopyable
-    {
-        @disable this(this);
-    }
-
-    static assert(is(typeof(Option!NotCopyable(NotCopyable()))));
+    static assert(is(typeof(Option!NonCopyable(NonCopyable()))));
     // The value cannot be returned by reference because the default value
     // isn't passed by reference
-    static assert(!is(typeof(Option!DisabledPostblit().or(NotCopyable()))));
+    static assert(!is(typeof(Option!DisabledPostblit().or(NonCopyable()))));
     {
-        NotCopyable notCopyable;
-        static assert(is(typeof(Option!NotCopyable().or(notCopyable))));
+        NonCopyable notCopyable;
+        static assert(is(typeof(Option!NonCopyable().or(notCopyable))));
     }
     {
-        Option!NotCopyable option;
+        Option!NonCopyable option;
         assert(option.isNothing);
-        option = NotCopyable();
+        option = NonCopyable();
         assert(!option.isNothing);
     }
     {
-        Option!NotCopyable option;
+        Option!NonCopyable option;
         assert(option.isNothing);
-        option = Option!NotCopyable(NotCopyable());
+        option = Option!NonCopyable(NonCopyable());
         assert(!option.isNothing);
     }
 }
@@ -447,8 +515,420 @@ struct Option(T)
 // Returns default value
 @nogc nothrow pure @safe unittest
 {
+    int i = 5;
+    assert(((ref e) => e)(Option!int().or(i)) == 5);
+}
+
+// Implements toHash() for nothing
+@nogc nothrow pure @safe unittest
+{
+    alias OptionT = Option!Hashable;
+    assert(OptionT().toHash() == 0U);
+    assert(OptionT(Hashable(1U)).toHash() == 1U);
+}
+
+// Can assign Option that is nothing
+@nogc nothrow pure @safe unittest
+{
+    auto option1 = Option!int(5);
+    Option!int option2;
+    option1 = option2;
+    assert(option1.isNothing);
+}
+
+/**
+ * Creates a new $(D_PSYMBOL Option).
+ *
+ * Params:
+ *  T     = Option type.
+ *  value = Initial value.
+ *
+ * See_Also: $(D_PSYMBOL Option).
+ */
+Option!T option(T)(auto ref T value)
+{
+    return Option!T(forward!value);
+}
+
+/// ditto
+Option!T option(T)()
+{
+    return Option!T();
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(option!int().isNothing);
+    assert(option(5) == 5);
+}
+
+/**
+ * Type that can hold one of the types listed as its template parameters.
+ *
+ * $(D_PSYMBOL Variant) is a type similar to $(D_KEYWORD union), but
+ * $(D_PSYMBOL Variant) keeps track of the actually used type and throws an
+ * assertion error when trying to access an invalid type at runtime.
+ *
+ * Params:
+ *  Specs = Types this $(D_SPYBMOL Variant) can hold.
+ */
+template Variant(Specs...)
+if (isTypeTuple!Specs && NoDuplicates!Specs.length == Specs.length)
+{
+    union AlignedUnion(Args...)
     {
-        int i = 5;
-        assert(((ref e) => e)(Option!int().or(i)) == 5);
+        static if (Args.length > 0)
+        {
+            Args[0] value;
+        }
+        static if (Args.length > 1)
+        {
+            AlignedUnion!(Args[1 .. $]) rest;
+        }
+    }
+
+    private struct VariantAccessorInfo
+    {
+        string accessor;
+        ptrdiff_t tag;
+    }
+
+    template accessor(T, Union)
+    {
+        enum VariantAccessorInfo info = accessorImpl!(T, Union, 1);
+        enum accessor = VariantAccessorInfo("this.values" ~ info.accessor, info.tag);
+    }
+
+    template accessorImpl(T, Union, size_t tag)
+    {
+        static if (is(T == typeof(Union.value)))
+        {
+            enum accessorImpl = VariantAccessorInfo(".value", tag);
+        }
+        else
+        {
+            enum VariantAccessorInfo info = accessorImpl!(T, typeof(Union.rest), tag + 1);
+            enum accessorImpl = VariantAccessorInfo(".rest" ~ info.accessor, info.tag);
+        }
+    }
+
+    struct Variant
+    {
+        /// Types can be present in this $(D_PSYMBOL Variant).
+        alias Types = Specs;
+
+        private ptrdiff_t tag = -1;
+        private AlignedUnion!Types values;
+
+        /**
+         * Constructs this $(D_PSYMBOL Variant) with one of the types supported
+         * in it.
+         *
+         * Params:
+         *  T     = Type of the initial value.
+         *  value = Initial value.
+         */
+        this(T)(ref T value)
+        if (canFind!(T, Types))
+        {
+            copyAssign!T(value);
+        }
+
+        /// ditto
+        this(T)(T value)
+        if (canFind!(T, Types))
+        {
+            moveAssign!T(value);
+        }
+
+        ~this()
+        {
+            reset();
+        }
+
+        this(this)
+        {
+            alias pred(U) = hasElaborateCopyConstructor!(U.Seq[1]);
+            static foreach (Type; Filter!(pred, Enumerate!Types))
+            {
+                if (this.tag == Type.Seq[0])
+                {
+                    get!(Type.Seq[1]).__postblit();
+                }
+            }
+        }
+
+        /**
+         * Tells whether this $(D_PSYMBOL Variant) is initialized.
+         *
+         * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Variant) contains a
+         *          value, $(D_KEYWORD false) otherwise.
+         */
+        bool hasValue() const
+        {
+            return this.tag != -1;
+        }
+
+        /**
+         * Tells whether this $(D_PSYMBOL Variant) holds currently a value of
+         * type $(D_PARAM T).
+         *
+         * Params:
+         *  T = Examined type.
+         *
+         * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Variant) currently
+         *          contains a value of type $(D_PARAM T), $(D_KEYWORD false)
+         *          otherwise.
+         */
+        bool peek(T)() const
+        if (canFind!(T, Types))
+        {
+            return this.tag == staticIndexOf!(T, Types);
+        }
+
+        /**
+         * Returns the underlying value, assuming it is of the type $(D_PARAM T).
+         *
+         * Params:
+         *  T = Type of the value should be returned.
+         *
+         * Returns: The underyling value.
+         *
+         * Precondition: The $(D_PSYMBOL Variant) has a value.
+         *
+         * See_Also: $(D_PSYMBOL peek), $(D_PSYMBOL hasValue).
+         */
+        ref inout(T) get(T)() inout
+        if (canFind!(T, Types))
+        in (this.tag == staticIndexOf!(T, Types), "Variant isn't initialized")
+        {
+            mixin("return " ~ accessor!(T, AlignedUnion!Types).accessor ~ ";");
+        }
+
+        /**
+         * Reassigns the value.
+         *
+         * Params:
+         *  T    = Type of the new value
+         *  that = New value.
+         *
+         * Returns: $(D_KEYWORD this).
+         */
+        ref typeof(this) opAssign(T)(T that)
+        if (canFind!(T, Types))
+        {
+            reset();
+            return moveAssign!T(that);
+        }
+
+        /// ditto
+        ref typeof(this) opAssign(T)(ref T that)
+        if (canFind!(T, Types))
+        {
+            reset();
+            return copyAssign!T(that);
+        }
+
+        private ref typeof(this) moveAssign(T)(ref T that) @trusted
+        {
+            this.tag = staticIndexOf!(T, Types);
+
+            enum string accessorMixin = accessor!(T, AlignedUnion!Types).accessor;
+            moveEmplace(that, mixin(accessorMixin));
+
+            return this;
+        }
+
+        private ref typeof(this) copyAssign(T)(ref T that)
+        {
+            this.tag = staticIndexOf!(T, Types);
+
+            enum string accessorMixin = accessor!(T, AlignedUnion!Types).accessor;
+            emplace!T((() @trusted => (&mixin(accessorMixin))[0 .. 1])(), that);
+
+            return this;
+        }
+
+        private void reset()
+        {
+            alias pred(U) = hasElaborateDestructor!(U.Seq[1]);
+            static foreach (Type; Filter!(pred, Enumerate!Types))
+            {
+                if (this.tag == Type.Seq[0])
+                {
+                    destroy(get!(Type.Seq[1]));
+                }
+            }
+        }
+
+        /**
+         * Returns $(D_PSYMBOL TypeInfo) corresponding to the current type.
+         *
+         * If this $(D_PSYMBOL Variant) isn't initialized, returns
+         * $(D_KEYWORD null).
+         *
+         * Returns: $(D_PSYMBOL TypeInfo) of the current type.
+         */
+        @property TypeInfo type()
+        {
+            static foreach (i, Type; Types)
+            {
+                if (this.tag == i)
+                {
+                    return typeid(Type);
+                }
+            }
+            return null;
+        }
+
+        /**
+         * Compares this $(D_PSYMBOL Variant) with another one with the same
+         * specification for equality.
+         *
+         * $(UL
+         *  $(LI If both hold values of the same type, these values are
+         *       compared.)
+         *  $(LI If they hold values of different types, then the
+         *       $(D_PSYMBOL Variant)s aren't equal.)
+         *  $(LI If only one of them is initialized but another one not, they
+         *       aren't equal.)
+         *  $(LI If neither of them is initialized, they are equal.)
+         * )
+         *
+         * Params:
+         *  that = The $(D_PSYMBOL Variant) to compare with.
+         *
+         * Returns: $(D_KEYWORD true) if this $(D_PSYMBOL Variant) is equal to
+         *          $(D_PARAM that), $(D_KEYWORD false) otherwise.
+         */
+        bool opEquals()(auto ref inout Variant that) inout
+        {
+            if (this.tag != that.tag)
+            {
+                return false;
+            }
+            static foreach (i, Type; Types)
+            {
+                if (this.tag == i)
+                {
+                    return get!Type == that.get!Type;
+                }
+            }
+            return true;
+        }
     }
 }
+
+///
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant = 5;
+    assert(variant.peek!int);
+    assert(variant.get!int == 5);
+
+    variant = 5.4;
+    assert(!variant.peek!int);
+    assert(variant.get!double == 5.4);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant;
+    variant = 5;
+    assert(variant.peek!int);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant;
+    variant = 5.0;
+    assert(!variant.peek!int);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant = 5;
+    assert(variant.get!int == 5);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(Variant!(int, float)));
+    static assert(is(Variant!int));
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static struct WithDestructorAndCopy
+    {
+        this(this) @nogc nothrow pure @safe
+        {
+        }
+
+        ~this() @nogc nothrow pure @safe
+        {
+        }
+    }
+    static assert(is(Variant!WithDestructorAndCopy));
+}
+
+// Equality compares the underlying objects
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant1 = 5;
+    Variant!(int, double) variant2 = 5;
+    assert(variant1 == variant2);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant1 = 5;
+    Variant!(int, double) variant2 = 6;
+    assert(variant1 != variant2);
+}
+
+// Differently typed variants aren't equal
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant1 = 5;
+    Variant!(int, double) variant2 = 5.0;
+    assert(variant1 != variant2);
+}
+
+// Uninitialized variants are equal
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, double) variant1, variant2;
+    assert(variant1 == variant2);
+}
+
+// Calls postblit constructor of the active type
+@nogc nothrow pure @safe unittest
+{
+    static struct S
+    {
+        bool called;
+
+        this(this)
+        {
+            this.called = true;
+        }
+    }
+    Variant!(int, S) variant1 = S();
+    auto variant2 = variant1;
+    assert(variant2.get!S.called);
+}
+
+// Variant.type is null if the Variant doesn't have a value
+@nogc nothrow pure @safe unittest
+{
+    Variant!(int, uint) variant;
+    assert(variant.type is null);
+}
+
+// Variant can contain only distinct types
+@nogc nothrow pure @safe unittest
+{
+    static assert(!is(Variant!(int, int)));
+}