net.ip.Address6.toString() recommended notation

Fix #65.

.travis.yml

@@ -7,18 +7,32 @@ os:
 language: d
 
 d:
+- dmd-2.084.1
+- dmd-2.083.1
 - dmd-2.082.1
 
 env:
+  global:
+  - LATEST=2.084.1
+
   matrix:
   - ARCH=x86_64
   - ARCH=x86
 
 matrix:
   include:
-  - name: "D-Scanner"
-    d: dmd-2.082.1
-    env: DSCANNER=0.5.11
+  - 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:
@@ -27,13 +41,15 @@ addons:
     - gcc-multilib
 
 before_script:
-- if [ "`$DC --version | head -n 1 | grep 'v2.082.1'`" ] &&
-     [ -z "$DSCANNER" ]; then
+- if [ "`$DC --version | head -n 1 | grep v$LATEST`" ] &&
+     [ -z "$DSCANNER$DDOC" ]; then
     export UNITTEST="unittest-cov";
   fi
 
 script:
-- if [ -z "$DSCANNER" ]; then
+- 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;

README.md

@@ -175,8 +175,9 @@ parameter is used)
 
 | DMD     | GCC             |
 |:-------:|:---------------:|
-| 2.082.1 | gdc-8 (2.081.2) |
-|         | gdc-7 (2.081.2) |
+| 2.084.1 | gdc-8 (2.081.2) |
+| 2.083.1 | gdc-7 (2.081.2) |
+| 2.082.1 |                 |
 
 ### Release management
 

appveyor.yml

@@ -3,6 +3,18 @@ os: Visual Studio 2015
 
 environment:
   matrix:
+    - DC: dmd
+      DVersion: 2.084.1
+      arch: x64
+    - DC: dmd
+      DVersion: 2.084.1
+      arch: x86
+    - DC: dmd
+      DVersion: 2.083.1
+      arch: x64
+    - DC: dmd
+      DVersion: 2.083.1
+      arch: x86
     - DC: dmd
       DVersion: 2.082.1
       arch: x64

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,14 +77,17 @@ private mixin template Take(R, bool exactly)
         }
         else
         {
-            return length == 0 || this.source.empty;
+            return this.length_ == 0 || this.source.empty;
         }
     }
 
+    static if (exactly || hasLength!R)
+    {
         @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)
+        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))
     {
-            auto opSlice(size_t i, size_t j)
-            in
+        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)
     {
-                assert(i <= j);
-                assert(j <= length);
+        // If the range is infinite then `take` is the same as `takeExactly`.
+        return Take!(R, true)(range, n);
     }
-            do
+    else
     {
-                return typeof(this)(this.source[i .. j], length);
+        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);
     }
 }
 
@@ -408,23 +454,9 @@ if (isInputRange!R)
     }
 }
 
-/**
- * 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)(Range range)
-if (isBidirectionalRange!Range)
+// Reverse-access-order range returned by `retro`.
+private struct Retro(Range)
 {
-    static struct Retro
-    {
     Range source;
 
     @disable this();
@@ -485,6 +517,22 @@ if (isBidirectionalRange!Range)
         }
     }
 
+    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)
@@ -526,9 +574,30 @@ if (isBidirectionalRange!Range)
             }
         }
     }
-    }
 
-    return Retro(range);
+    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);
 }
 
 ///
@@ -559,6 +628,10 @@ if (isBidirectionalRange!Range)
     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
@@ -576,3 +649,207 @@ if (isBidirectionalRange!Range)
     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)
@@ -19,6 +19,7 @@ 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)
 {
@@ -222,9 +223,16 @@ void move(T)(ref T source, ref T target)
 /// ditto
 T move(T)(ref T source) @trusted
 {
+    static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
+    {
         T target = void;
         moveEmplace(source, target);
         return target;
+    }
+    else
+    {
+        return source;
+    }
 }
 
 ///
@@ -301,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)
@@ -381,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;
         }
@@ -554,10 +559,6 @@ if (isInputRange!Range && hasLvalueElements!Range)
 
 @nogc nothrow pure @safe unittest
 {
-    static struct NonCopyable
-    {
-        @disable this(this);
-    }
     NonCopyable[] nonCopyable;
     initializeAll(nonCopyable);
 }
@@ -607,3 +608,89 @@ if (isInputRange!Range && hasLvalueElements!Range)
 
     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/container/array.d

@@ -15,14 +15,15 @@
 module tanya.container.array;
 
 import core.checkedint;
-import std.algorithm.mutation : bringToFront;
 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;
+version (unittest) import tanya.test.stub;
 
 /**
  * Random-access range for the $(D_PSYMBOL Array).
@@ -294,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);
@@ -349,9 +352,8 @@ struct Array(T)
         (() @trusted => allocator.deallocate(slice(capacity)))();
     }
 
-    /**
-     * Copies the array.
-     */
+    static if (isCopyable!T)
+    {
         this(this)
         {
             auto buf = slice(this.length);
@@ -359,6 +361,11 @@ struct Array(T)
             this.data = null;
             insertBack(buf);
         }
+    }
+    else
+    {
+        @disable this(this);
+    }
 
     /**
      * Removes all elements.
@@ -804,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;
     }
 
@@ -846,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;
     }
@@ -902,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;
     }
@@ -993,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
@@ -1027,7 +1035,7 @@ struct Array(T)
     }
 
     /// ditto
-    Range opIndexAssign(Range value)
+    Range opIndexAssign()(Range value)
     {
         return opSliceAssign(value, 0, length);
     }
@@ -1321,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);
@@ -1575,15 +1583,10 @@ struct Array(T)
     assert(v7[].equal(v8[]));
 }
 
+// Destructor can destroy empty arrays
 @nogc nothrow pure @safe unittest
 {
-    static 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
@@ -1594,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*)));
 }
 
@@ -1679,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);
@@ -759,7 +760,7 @@ if (isHashFunction!(hasher, Key))
      *
      * 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 (isHashFunction!(hasher, Key))
     }
 
     /// 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 (isHashFunction!(hasher, Key))
     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

@@ -23,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).
@@ -155,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)
@@ -182,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;
+        }
     }
 
     ///
@@ -271,15 +284,19 @@ struct SList(T)
         clear();
     }
 
-    /**
-     * Copies the list.
-     */
+    static if (isCopyable!T)
+    {
         this(this)
         {
             auto list = typeof(this)(this[], this.allocator);
             this.head = list.head;
             list.head = null;
         }
+    }
+    else
+    {
+        @disable this(this);
+    }
 
     ///
     @nogc nothrow pure @safe unittest
@@ -512,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));
@@ -1120,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)
@@ -1150,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;
     }
 
     ///
@@ -1242,9 +1273,8 @@ struct DList(T)
         clear();
     }
 
-    /**
-     * Copies the list.
-     */
+    static if (isCopyable!T)
+    {
         this(this)
         {
             auto list = typeof(this)(this[], this.allocator);
@@ -1252,6 +1282,11 @@ struct DList(T)
             this.tail = list.tail;
             list.head = list .tail = null;
         }
+    }
+    else
+    {
+        @disable this(this);
+    }
 
     ///
     @nogc nothrow pure @safe unittest
@@ -1641,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));
@@ -1758,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));
@@ -2355,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);
@@ -459,7 +460,7 @@ if (isHashFunction!(hasher, 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 (isHashFunction!(hasher, 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)
@@ -773,3 +774,14 @@ if (isHashFunction!(hasher, T))
 {
     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,7 +26,6 @@
  */
 module tanya.container.string;
 
-import std.algorithm.mutation : bringToFront;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.hash.lookup;
@@ -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)
@@ -27,6 +27,7 @@ import tanya.range.primitive;
 version (unittest)
 {
     import tanya.test.assertion;
+    import tanya.test.stub;
 }
 
 /**
@@ -61,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);
 
@@ -87,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);
 
@@ -140,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)
@@ -162,45 +142,51 @@ do
     return result;
 }
 
+private void initializeOne(T)(ref void[] memory, ref T* result) @trusted
+{
+    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 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)
+in (memory.length >= T.sizeof)
+out (result; memory.ptr is result)
 {
     auto result = (() @trusted => cast(T*) memory.ptr)();
-    alias trustedCopy = (ref arg) @trusted =>
-        copy((cast(void*) &arg)[0 .. T.sizeof], memory);
 
     static if (Args.length == 0)
     {
         static assert(is(typeof({ static T t; })),
                       "Default constructor is disabled");
+        initializeOne(memory, result);
     }
     else static if (is(typeof(result.__ctor(args))))
     {
-        static if (!hasElaborateAssign!T && isAssignable!T)
-        {
-            *result = T.init;
-        }
-        else
-        {
-            static if (__VERSION__ >= 2083 // __traits(isZeroInit) available.
-                && __traits(isZeroInit, T))
-            {
-                (() @trusted => memory.ptr[0 .. T.sizeof])().fill!0;
-            }
-            else
-            {
-                static immutable T init = T.init;
-                trustedCopy(init);
-            }
-        }
+        initializeOne(memory, result);
         result.__ctor(args);
     }
     else static if (Args.length == 1 && is(typeof({ T t = args[0]; })))
     {
-        trustedCopy(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); })))
     {
@@ -257,35 +243,56 @@ out(result; memory.ptr is result)
 // Can emplace structs without a constructor
 @nogc nothrow pure @safe unittest
 {
-    static struct SWithDtor
-    {
-        ~this() @nogc nothrow pure @safe
-        {
-        }
-    }
-    static assert(is(typeof(emplace!SWithDtor(null, SWithDtor()))));
-    static assert(is(typeof(emplace!SWithDtor(null))));
+    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 WithDtor
+    static struct SWithDtor
     {
         private bool canBeInvoked = false;
         ~this() @nogc nothrow pure @safe
         {
-            if (!this.canBeInvoked)
-            {
-                assert(false);
+            assert(this.canBeInvoked);
         }
     }
-    }
-    void[WithDtor.sizeof] memory = void;
-    auto actual = emplace!WithDtor(memory[], WithDtor(true));
+    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.
  */

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)
@@ -47,8 +55,7 @@ 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.
@@ -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;
     }
 
@@ -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,
+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/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)
     {
@@ -49,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)))
         {
@@ -72,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.");
+        }
+    }
 }
 
 /**
@@ -97,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.
  *
@@ -133,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;
     }
 }
 
@@ -146,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";
@@ -178,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
@@ -199,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

source/tanya/math/random.d

@@ -18,10 +18,6 @@ import std.digest.sha;
 import tanya.memory;
 import tanya.typecons;
 
-/// Block size of entropy accumulator (SHA-512).
-deprecated
-enum blockSize = 64;
-
 /// Maximum amount gathered from the entropy sources.
 enum maxGather = 128;
 
@@ -339,176 +335,3 @@ static if (is(PlatformEntropySource)) @nogc @system unittest
     assert(source.threshold == 32);
     assert(source.strong);
 }
-
-/**
- * Pseudorandom number generator.
- * ---
- * auto entropy = defaultAllocator.make!Entropy();
- *
- * ubyte[blockSize] output;
- *
- * output = entropy.random;
- *
- * defaultAllocator.dispose(entropy);
- * ---
- */
-deprecated
-class Entropy
-{
-    /// Entropy sources.
-    protected EntropySource[] sources;
-
-    private ubyte sourceCount_;
-
-    /// 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 @nogc nothrow pure @safe
-    {
-        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)
-    @nogc nothrow pure @safe
-    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.isNothing)
-                {
-                    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) @nogc nothrow pure @safe
-    {
-        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]);
-    }
-}

source/tanya/memory/op.d

@@ -224,41 +224,6 @@ do
     assert(equal(r1, r2));
 }
 
-/**
- * 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).
- */
-deprecated("Use tanya.memory.op.equal() or tanya.algorithm.comparison.compare() instead")
-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
-{
-    import core.stdc.string : memcmp;
-
-    if (r1.length > r2.length)
-    {
-        return 1;
-    }
-    return r1.length < r2.length ? -1 : memcmp(r1.ptr, r2.ptr, r1.length);
-}
-
 /**
  * Finds the first occurrence of $(D_PARAM needle) in $(D_PARAM haystack) if
  * any.
@@ -419,8 +384,8 @@ do
  * Compares two memory areas $(D_PARAM r1) and $(D_PARAM r2) for equality.
  *
  * Params:
- *  haystack = First memory block.
- *  needle   = First memory block.
+ *  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.

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

@@ -1801,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.
@@ -2854,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/net/ip.d

@@ -5,7 +5,7 @@
 /**
  * Internet Protocol implementation.
  *
- * 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)
@@ -15,6 +15,7 @@
 module tanya.net.ip;
 
 import tanya.algorithm.comparison;
+import tanya.algorithm.iteration;
 import tanya.algorithm.mutation;
 import tanya.container.string;
 import tanya.conv;
@@ -103,7 +104,7 @@ struct Address4
      *
      * Returns: Object that represents the Loopback address.
      */
-    static Address4 loopback() @nogc nothrow pure @safe
+    static @property Address4 loopback() @nogc nothrow pure @safe
     {
         typeof(return) address;
         address.address = Address4.loopback_;
@@ -121,7 +122,7 @@ struct Address4
      *
      * Returns: Object that represents any address.
      */
-    static Address4 any() @nogc nothrow pure @safe
+    static @property Address4 any() @nogc nothrow pure @safe
     {
         typeof(return) address;
         address.address = Address4.any_;
@@ -148,7 +149,7 @@ struct Address4
     ///
     @nogc nothrow pure @safe unittest
     {
-        assert(address4("127.0.0.1").isLoopback());
+        assert(address4("127.0.0.1").get.isLoopback());
     }
 
     /**
@@ -166,7 +167,7 @@ struct Address4
     ///
     @nogc nothrow pure @safe unittest
     {
-        assert(address4("0.0.0.0").isAny());
+        assert(address4("0.0.0.0").get.isAny());
     }
 
     /**
@@ -183,7 +184,7 @@ struct Address4
     ///
     @nogc nothrow pure @safe unittest
     {
-        assert(address4("255.255.255.255").isBroadcast());
+        assert(address4("255.255.255.255").get.isBroadcast());
     }
 
     /**
@@ -210,7 +211,7 @@ struct Address4
     ///
     @nogc nothrow pure @safe unittest
     {
-        assert(address4("224.0.0.3").isMulticast());
+        assert(address4("224.0.0.3").get.isMulticast());
     }
 
     /**
@@ -229,7 +230,7 @@ struct Address4
     ///
     @nogc nothrow pure @safe unittest
     {
-        assert(address4("192.168.0.1").isUnicast());
+        assert(address4("192.168.0.1").get.isUnicast());
     }
 
     /**
@@ -237,6 +238,7 @@ struct Address4
      *
      * Returns: This address in dotted-decimal notation.
      */
+    deprecated("Use Address4.toString() instead")
     String stringify() const @nogc nothrow pure @safe
     {
         const octets = (() @trusted => (cast(ubyte*) &this.address)[0 .. 4])();
@@ -251,12 +253,50 @@ struct Address4
         }
     }
 
+    /**
+     * Writes this IPv4 address in dotted-decimal notation.
+     *
+     * Params:
+     *  OR     = Type of the output range.
+     *  output = Output range.
+     *
+     * Returns: $(D_PARAM output).
+     */
+    OR toString(OR)(OR output) const @nogc nothrow pure @safe
+    if (isOutputRange!(OR, const(char)[]))
+    {
+        const octets = (() @trusted => (cast(ubyte*) &this.address)[0 .. 4])();
+        enum string fmt = "{}.{}.{}.{}";
+        version (LittleEndian)
+        {
+            return sformat!fmt(output,
+                               octets[0],
+                               octets[1],
+                               octets[2],
+                               octets[3]);
+        }
+        else
+        {
+            return sformat!fmt(output,
+                               octets[3],
+                               octets[2],
+                               octets[1],
+                               octets[0]);
+        }
+    }
+
     ///
     @nogc nothrow pure @safe unittest
     {
+        import tanya.container.string : String;
+        import tanya.range : backInserter;
+
         const dottedDecimal = "192.168.0.1";
+        String actual;
         const address = address4(dottedDecimal);
-        assert(address.get.stringify() == dottedDecimal);
+
+        address.get.toString(backInserter(actual));
+        assert(actual == dottedDecimal);
     }
 
     /**
@@ -276,7 +316,7 @@ struct Address4
     {
         const actual = address4("192.168.0.1");
         const ubyte[4] expected = [192, 168, 0, 1];
-        assert(actual.toBytes() == expected);
+        assert(actual.get.toBytes() == expected);
     }
 
     /**
@@ -293,7 +333,7 @@ struct Address4
     ///
     @nogc nothrow pure @safe unittest
     {
-        assert(address4("127.0.0.1").toUInt() == 0x7f000001U);
+        assert(address4("127.0.0.1").get.toUInt() == 0x7f000001U);
     }
 }
 
@@ -394,7 +434,7 @@ if (isInputRange!R && is(Unqual!(ElementType!R) == ubyte))
 {
     {
         ubyte[4] actual = [127, 0, 0, 1];
-        assert(address4(actual[]).isLoopback());
+        assert(address4(actual[]).get.isLoopback());
     }
     {
         ubyte[3] actual = [127, 0, 0];
@@ -499,7 +539,7 @@ struct Address6
      *
      * Returns: Object that represents any address.
      */
-    static Address6 any() @nogc nothrow pure @safe
+    static @property Address6 any() @nogc nothrow pure @safe
     {
         return Address6();
     }
@@ -515,7 +555,7 @@ struct Address6
      *
      * Returns: Object that represents the Loopback address.
      */
-    static Address6 loopback() @nogc nothrow pure @safe
+    static @property Address6 loopback() @nogc nothrow pure @safe
     {
         typeof(return) address;
         address.address[$ - 1] = 1;
@@ -543,7 +583,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("::").isAny());
+        assert(address6("::").get.isAny());
     }
 
     /**
@@ -560,7 +600,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("::1").isLoopback());
+        assert(address6("::1").get.isLoopback());
     }
 
     /**
@@ -579,7 +619,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("ff00::").isMulticast());
+        assert(address6("ff00::").get.isMulticast());
     }
 
     /**
@@ -598,7 +638,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("::1").isUnicast());
+        assert(address6("::1").get.isUnicast());
     }
 
     /**
@@ -615,7 +655,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("fe80::1").isLinkLocal());
+        assert(address6("fe80::1").get.isLinkLocal());
     }
 
     /**
@@ -632,7 +672,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("fd80:124e:34f3::1").isUniqueLocal());
+        assert(address6("fd80:124e:34f3::1").get.isUniqueLocal());
     }
 
     /**
@@ -640,34 +680,78 @@ struct Address6
      *
      * Returns: text representation of this address.
      */
+    deprecated("Use Address6.toString() instead")
     String stringify() const @nogc nothrow pure @safe
     {
         String output;
-        foreach (i, b; this.address)
-        {
-            ubyte low = b & 0xf;
-            ubyte high = b >> 4;
 
-            if (high < 10)
+        toString(backInserter(output));
+        return output;
+    }
+
+    /**
+     * Writes text representation of this address to an output range.
+     *
+     * Params:
+     *  OR     = Type of the output range.
+     *  output = Output range.
+     *
+     * Returns: $(D_PARAM output).
+     */
+    OR toString(OR)(OR output) const
+    if (isOutputRange!(OR, const(char)[]))
     {
-                output.insertBack(cast(char) (high + '0'));
+        ptrdiff_t largestGroupIndex = -1;
+        size_t largestGroupSize;
+        size_t zeroesInGroup;
+        size_t groupIndex;
+
+        // Look for the longest group of zeroes
+        for (size_t i; i < this.address.length; i += 2)
+        {
+            if (this.address[i] == 0 && this.address[i + 1] == 0)
+            {
+                if (zeroesInGroup++ == 0)
+                {
+                    groupIndex = i;
+                }
             }
             else
             {
-                output.insertBack(cast(char) (high - 10 + 'a'));
+                zeroesInGroup = 0;
             }
-            if (low < 10)
+            if (zeroesInGroup > largestGroupSize && zeroesInGroup > 1)
             {
-                output.insertBack(cast(char) (low + '0'));
+                largestGroupSize = zeroesInGroup;
+                largestGroupIndex = groupIndex;
             }
-            else
+        }
+
+        // Write the address
+        size_t i;
+        if (largestGroupIndex != 0)
         {
-                output.insertBack(cast(char) (low - 10 + 'a'));
+            writeGroup(output, i);
         }
-            if (i % 2 != 0 && i != (this.address.length - 1))
+        if (largestGroupIndex != -1)
         {
-                output.insertBack(':');
+            while (i < largestGroupIndex)
+            {
+                put(output, ":");
+                writeGroup(output, i);
             }
+            put(output, "::");
+            i += largestGroupSize + 2;
+            if (i < (this.address.length - 1))
+            {
+                writeGroup(output, i);
+            }
+        }
+
+        while (i < this.address.length - 1)
+        {
+            put(output, ":");
+            writeGroup(output, i);
         }
 
         return output;
@@ -676,10 +760,74 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        import tanya.algorithm.comparison : equal;
+        import tanya.container.string : String;
+        import tanya.range : backInserter;
 
-        assert(equal(address6("1:2:3:4:5:6:7:8").stringify()[],
-               "0001:0002:0003:0004:0005:0006:0007:0008"));
+        String actual;
+
+        address6("1:2:3:4:5:6:7:8").get.toString(backInserter(actual));
+        assert(actual == "1:2:3:4:5:6:7:8");
+    }
+
+    @nogc nothrow @safe unittest
+    {
+        char[18] actual;
+
+        address6("ff00:2:3:4:5:6:7:8").get.toString(arrayInserter(actual));
+        assert(actual[] == "ff00:2:3:4:5:6:7:8");
+    }
+
+    // Skips zero group in the middle
+    @nogc nothrow @safe unittest
+    {
+        char[12] actual;
+
+        address6("1::4:5:6:7:8").get.toString(arrayInserter(actual));
+        assert(actual[] == "1::4:5:6:7:8");
+    }
+
+    // Doesn't replace lonely zeroes
+    @nogc nothrow @safe unittest
+    {
+        char[15] actual;
+
+        address6("0:1:0:2:3:0:4:0").get.toString(arrayInserter(actual));
+        assert(actual[] == "0:1:0:2:3:0:4:0");
+    }
+
+    // Skips zero group at the beginning
+    @nogc nothrow @safe unittest
+    {
+        char[13] actual;
+
+        address6("::3:4:5:6:7:8").get.toString(arrayInserter(actual));
+        assert(actual[] == "::3:4:5:6:7:8");
+    }
+
+    // Skips zero group at the end
+    @nogc nothrow @safe unittest
+    {
+        char[13] actual;
+
+        address6("1:2:3:4:5:6::").get.toString(arrayInserter(actual));
+        assert(actual[] == "1:2:3:4:5:6::");
+    }
+
+    private void writeGroup(OR)(ref OR output, ref size_t i) const
+    {
+        ubyte low = this.address[i] & 0xf;
+        ubyte high = this.address[i] >> 4;
+
+        bool groupStarted = writeHexDigit!OR(output, high);
+        groupStarted = writeHexDigit!OR(output, low, groupStarted);
+
+        ++i;
+        low = this.address[i] & 0xf;
+        high = this.address[i] >> 4;
+
+        writeHexDigit!OR(output, high, groupStarted);
+        put(output, low.toHexDigit.singleton);
+        ++i;
     }
 
     /**
@@ -697,17 +845,36 @@ struct Address6
     {
         auto actual = address6("1:2:3:4:5:6:7:8");
         ubyte[16] expected = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8];
-        assert(actual.toBytes() == expected);
+        assert(actual.get.toBytes() == expected);
     }
 }
 
-private void write2Bytes(R)(ref R range, ubyte[] address)
+private void read2Bytes(R)(ref R range, ubyte[] address)
 {
     ushort group = readIntegral!ushort(range, 16);
     address[0] = cast(ubyte) (group >> 8);
     address[1] = group & 0xff;
 }
 
+private char toHexDigit(ubyte digit) @nogc nothrow pure @safe
+in (digit < 16)
+{
+    return cast(char) (digit >= 10 ? (digit - 10 + 'a') : (digit + '0'));
+}
+
+private bool writeHexDigit(OR)(ref OR output,
+                               ubyte digit,
+                               bool groupStarted = false)
+in (digit < 16)
+{
+    if (digit != 0 || groupStarted)
+    {
+        put(output, digit.toHexDigit.singleton);
+        return true;
+    }
+    return groupStarted;
+}
+
 /**
  * Parses a string containing an IPv6 address.
  *
@@ -767,7 +934,7 @@ if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
             {
                 auto state = range.save();
             }
-            write2Bytes(range, result.address[i * 2 .. $]);
+            read2Bytes(range, result.address[i * 2 .. $]);
             if (range.empty)
             {
                 return typeof(return)();
@@ -796,7 +963,7 @@ if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
             }
         }
     }
-    write2Bytes(range, result.address[14 .. $]);
+    read2Bytes(range, result.address[14 .. $]);
 
     if (range.empty)
     {
@@ -827,7 +994,7 @@ ParseTail: // after ::
     { // To make "state" definition local
         auto state = range.save();
 
-        write2Bytes(range, tail[j .. $]);
+        read2Bytes(range, tail[j .. $]);
         if (range.empty)
         {
             goto CopyTail;
@@ -856,7 +1023,7 @@ ParseTail: // after ::
             return typeof(return)();
         }
         auto state = range.save();
-        write2Bytes(range, tail[j .. $]);
+        read2Bytes(range, tail[j .. $]);
 
         if (range.empty)
         {
@@ -935,26 +1102,30 @@ CopyTail:
 
 @nogc nothrow @safe unittest
 {
-    {
     ubyte[16] expected = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8];
     auto actual = address6("1:2:3:4:5:6:7:8");
-        assert(actual.address == expected);
-    }
-    {
+    assert(actual.get.address == expected);
+}
+
+@nogc nothrow @safe unittest
+{
     ubyte[16] expected;
     auto actual = address6("::");
-        assert(actual.address == expected);
-    }
-    {
+    assert(actual.get.address == expected);
+}
+
+@nogc nothrow @safe unittest
+{
     ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
     auto actual = address6("::1");
-        assert(actual.address == expected);
-    }
-    {
+    assert(actual.get.address == expected);
+}
+
+@nogc nothrow @safe unittest
+{
     ubyte[16] expected = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
     auto actual = address6("1::");
-        assert(actual.address == expected);
-    }
+    assert(actual.get.address == expected);
 }
 
 // Rejects malformed addresses
@@ -971,25 +1142,31 @@ CopyTail:
 // Parses embedded IPv4 address
 @nogc nothrow @safe unittest
 {
-    {
     ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4];
     auto actual = address6("0:0:0:0:0:0:1.2.3.4");
-        assert(actual.address == expected);
-    }
-    {
+    assert(actual.get.address == expected);
+}
+
+@nogc nothrow @safe unittest
+{
     ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4];
     auto actual = address6("::1.2.3.4");
-        assert(actual.address == expected);
-    }
-    {
+    assert(actual.get.address == expected);
+}
+
+@nogc nothrow @safe unittest
+{
     ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 1, 2, 3, 4];
     auto actual = address6("::5:6:1.2.3.4");
-        assert(actual.address == expected);
-    }
+    assert(actual.get.address == expected);
+}
+
+@nogc nothrow @safe unittest
+{
     assert(address6("0:0:0:0:0:0:1.2.3.").isNothing);
     assert(address6("0:0:0:0:0:0:1.2:3.4").isNothing);
     assert(address6("0:0:0:0:0:0:1.2.3.4.").isNothing);
-    assert(address6("fe80:0:0:0:0:0:1.2.3.4%1").scopeID == 1);
+    assert(address6("fe80:0:0:0:0:0:1.2.3.4%1").get.scopeID == 1);
 }
 
 /**
@@ -1041,3 +1218,261 @@ if (isInputRange!R && is(Unqual!(ElementType!R) == ubyte))
         assert(address6(cast(ubyte[]) []).isNothing);
     }
 }
+
+/**
+ * Address storage, that can hold either an IPv4 or IPv6 address.
+ */
+struct Address
+{
+    private Variant!(Address4, Address6) address;
+
+    @disable this();
+
+    /**
+     * Initializes the addres with an IPv4 address.
+     *
+     * Params:
+     *  address = IPv6 address.
+     */
+    this(Address4 address) @nogc nothrow pure @safe
+    {
+        this.address = address;
+    }
+
+    /**
+     * Initializes the addres with an IPv4 address.
+     *
+     * Params:
+     *  address = IPv6 address.
+     */
+    this(Address6 address) @nogc nothrow pure @safe
+    {
+        this.address = address;
+    }
+
+    /**
+     * Determines whether this is an IPv4 address.
+     *
+     * Returns: $(D_KEYWORD true) if this is an IPv4 address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isV4() const @nogc nothrow pure @safe
+    {
+        return this.address.peek!Address4;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address(Address4.any()).isV4());
+    }
+
+    /**
+     * Determines whether this is an IPv6 address.
+     *
+     * Returns: $(D_KEYWORD true) if this is an IPv6 address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isV6() const @nogc nothrow pure @safe
+    {
+        return this.address.peek!Address6;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address(Address6.any()).isV6());
+    }
+
+    /**
+     * Get the address as an IPv4 address.
+     *
+     * This method doesn't convert the address, so the address should be
+     * already an IPv4 one.
+     *
+     * Returns: IPv4 address.
+     *
+     * Precondition: This is an IPv4 address.
+     */
+    ref inout(Address4) toV4() inout @nogc nothrow pure @safe
+    in (this.address.peek!Address4)
+    {
+        return this.address.get!Address4;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        auto expected = Address4.loopback;
+        assert(Address(expected).toV4() == expected);
+    }
+
+    /**
+     * Get the address as an IPv6 address.
+     *
+     * This method doesn't convert the address, so the address should be
+     * already an IPv6 one.
+     *
+     * Returns: IPv6 address.
+     *
+     * Precondition: This is an IPv6 address.
+     */
+    ref inout(Address6) toV6() inout @nogc nothrow pure @safe
+    in (this.address.peek!Address6)
+    {
+        return this.address.get!Address6;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        auto expected = Address6.loopback;
+        assert(Address(expected).toV6() == expected);
+    }
+
+    /**
+     * Determines whether this is a loopback address.
+     *
+     * Returns: $(D_KEYWORD true) if this is a loopback address,
+     *          $(D_KEYWORD false) otherwise.
+     *
+     * See_Also: $(D_PSYMBOL Address4.loopback),
+     *           $(D_PSYMBOL Address6.loopback).
+     */
+    bool isLoopback() const @nogc nothrow pure @safe
+    in (this.address.hasValue)
+    {
+        if (this.address.peek!Address4)
+        {
+            return this.address.get!Address4.isLoopback();
+        }
+        return this.address.get!Address6.isLoopback();
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address(Address4.loopback()).isLoopback());
+        assert(Address(Address6.loopback()).isLoopback());
+    }
+
+    /**
+     * Determines whether this address' destination is a group of endpoints.
+     *
+     * Returns: $(D_KEYWORD true) if this is a multicast address,
+     *          $(D_KEYWORD false) otherwise.
+     *
+     * See_Also: $(D_PSYMBOL Address4.isMulticast),
+     *           $(D_PSYMBOL Address6.isMulticast).
+     */
+    bool isMulticast() const @nogc nothrow pure @safe
+    in (this.address.hasValue)
+    {
+        if (this.address.peek!Address4)
+        {
+            return this.address.get!Address4.isMulticast();
+        }
+        return this.address.get!Address6.isMulticast();
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        assert(Address(address4("224.0.0.3").get).isMulticast());
+        assert(Address(address6("ff00::").get).isMulticast());
+    }
+
+    /**
+     * Determines whether this is an unspecified address.
+     *
+     * Returns: $(D_KEYWORD true) if this is an unspecified address,
+     *          $(D_KEYWORD false) otherwise.
+     *
+     * See_Also: $(D_PSYMBOL Address4.isAny), $(D_PSYMBOL Address6.isAny).
+     */
+    bool isAny() const @nogc nothrow pure @safe
+    in (this.address.hasValue)
+    {
+        if (this.address.peek!Address4)
+        {
+            return this.address.get!Address4.isAny();
+        }
+        return this.address.get!Address6.isAny();
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address(Address4.any).isAny());
+        assert(Address(Address6.any).isAny());
+    }
+
+    /**
+     * Compares two addresses for equality.
+     *
+     * Params:
+     *  T    = The type of the other address. It can be $(D_PSYMBOL Address),
+     *         $(D_PSYMBOL Address4) or $(D_PSYMBOL Address6).
+     *  that = The address to compare with.
+     *
+     * Returns: $(D_KEYWORD true) if this and $(D_PARAM that) addresses are
+     *          representations of the same IP address, $(D_KEYWORD false)
+     *          otherwise.
+     */
+    bool opEquals(T)(T that) const
+    if (is(Unqual!T == Address4) || is(Unqual!T == Address6))
+    {
+        alias AddressType = Unqual!T;
+        if (this.address.peek!AddressType)
+        {
+            return this.address.get!AddressType == that;
+        }
+        return false;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address(Address4.loopback) == Address4.loopback);
+        assert(Address(Address6.loopback) == Address6.loopback);
+        assert(Address(Address4.loopback) != Address6.loopback);
+    }
+
+    /// ditto
+    bool opEquals(T)(T that) const
+    if (is(Unqual!T == Address))
+    {
+        return this.address == that.address;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address(Address6.loopback) == Address(Address6.loopback));
+        assert(Address(Address4.loopback) != Address(Address6.loopback));
+    }
+
+    ref Address opAssign(T)(T that)
+    if (is(Unqual!T == Address4) || is(Unqual!T == Address6))
+    {
+        this.address = that;
+        return this;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        Address address = Address4.any;
+        address = Address4.loopback;
+        assert(address == Address4.loopback);
+    }
+}
+
+// Can assign another address
+@nogc nothrow pure @safe unittest
+{
+    Address actual = Address4.loopback;
+    Address expected = Address6.loopback;
+    actual = expected;
+    assert(actual == expected);
+}

source/tanya/range/adapter.d

@@ -3,9 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Range adapters.
+ * Range adapters transform some data structures into ranges.
  *
- * 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)
@@ -13,3 +13,218 @@
  *                 tanya/range/adapter.d)
  */
 module tanya.range.adapter;
+
+import tanya.algorithm.mutation;
+import tanya.functional;
+import tanya.meta.trait;
+import tanya.range;
+
+version (unittest)
+{
+    static struct Container
+    {
+        void insertBack(const(char)[])
+        {
+        }
+    }
+}
+
+private mixin template InserterCtor()
+{
+    private Container* container;
+
+    private this(ref Container container) @trusted
+    {
+        this.container = &container;
+    }
+}
+
+/**
+ * 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`.
+ *
+ * The resulting output range supports all types `insertBack` supports.
+ *
+ * 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:
+ *  Container = Container type.
+ *  container = Container used as an output range.
+ *
+ * Returns: `insertBack`-based output range.
+ */
+auto backInserter(Container)(return scope ref Container container)
+if (hasMember!(Container, "insertBack"))
+{
+    static struct Inserter
+    {
+        void opCall(T)(auto ref T data)
+        {
+            this.container.insertBack(forward!data);
+        }
+
+        mixin InserterCtor;
+    }
+    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));
+}
+
+/**
+ * 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`.
+ *
+ * The resulting output range supports all types `insertFront` supports.
+ *
+ * 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:
+ *  Container = Container type.
+ *  container = Container used as an output range.
+ *
+ * Returns: `insertFront`-based output range.
+ */
+auto frontInserter(Container)(return scope ref Container container)
+if (hasMember!(Container, "insertFront"))
+{
+    static struct Inserter
+    {
+        void opCall(T)(auto ref T data)
+        {
+            this.container.insertFront(forward!data);
+        }
+
+        mixin InserterCtor;
+    }
+    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,18 +784,27 @@ 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). It doesn't mean
- * that everything $(D_PARAM range) is an output range for can be put into it,
- * but only if one of the following conditions is 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_PARAM R) defines a `put`-method for $(D_PARAM E))
- *  $(LI $(D_PARAM e) can be assigned to $(D_INLINECODE range.front))
  *  $(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))
  *  )
  * )
  *
@@ -848,18 +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 assert(false, R.stringof ~ " is not an output range for "
@@ -877,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
 {
@@ -925,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)
 {
@@ -964,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)));
     }
@@ -978,7 +942,7 @@ template isOutputRange(R, E)
 {
     static struct R1
     {
-        void put(int) @nogc nothrow pure @safe
+        void opCall(int) @nogc nothrow pure @safe
         {
         }
     }
@@ -987,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;
@@ -1006,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));
 }
 
 /**
@@ -1097,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);
@@ -1348,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;
@@ -1376,8 +1322,6 @@ if (isBidirectionalRange!R)
         {
             return this.i;
         }
-
-        enum bool empty = false;
     }
     {
         InfiniteRange range;
@@ -1497,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()))));
 }
@@ -1582,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()))));
 }
@@ -1680,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))));
 }
@@ -1889,10 +1734,6 @@ template hasLvalueElements(R)
 // Works with non-copyable elements
 @nogc nothrow pure @safe unittest
 {
-    static struct NonCopyable
-    {
-        @disable this(this);
-    }
     static assert(hasLvalueElements!(NonCopyable[]));
 }
 
@@ -2051,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,10 +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.
@@ -226,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;
     }
@@ -366,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;
     }
 
@@ -398,7 +411,7 @@ struct Option(T)
         }
     }
 
-    alias get this;
+    alias get_ this;
 }
 
 ///
@@ -454,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);
     }
 }
@@ -507,30 +515,25 @@ 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
 {
-    static struct ToHash
-    {
-        size_t toHash() const @nogc nothrow pure @safe
-        {
-            return 1U;
-        }
-    }
-    {
-        Option!ToHash toHash;
-        assert(toHash.toHash() == 0U);
-    }
-    {
-        auto toHash = Option!ToHash(ToHash());
-        assert(toHash.toHash() == 1U);
-    }
+    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);
 }
 
 /**
@@ -559,3 +562,373 @@ Option!T option(T)()
     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...)
+    {
+        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)));
+}