move(): Give compiler an opportunity to optimize

Fix #75.

.travis.yml

@@ -28,6 +28,11 @@ matrix:
     d: dmd-$LATEST
     env: DDOC=true
     os: linux
+  allow_failures:
+  - name: D-Scanner
+    d: dmd-$LATEST
+    env: DSCANNER=0.5.11
+    os: linux
 
 addons:
   apt:

source/tanya/algorithm/iteration.d

@@ -514,6 +514,22 @@ private struct Retro(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)
@@ -609,6 +625,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

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)
@@ -223,9 +223,16 @@ void move(T)(ref T source, ref T target)
 /// ditto
 T move(T)(ref T source) @trusted
 {
-    T target = void;
-    moveEmplace(source, target);
-    return target;
+    static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
+    {
+        T target = void;
+        moveEmplace(source, target);
+        return target;
+    }
+    else
+    {
+        return source;
+    }
 }
 
 ///

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)
@@ -62,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);
 
@@ -88,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);
 
@@ -141,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)
@@ -184,8 +163,8 @@ private void initializeOne(T)(ref void[] memory, ref T* result) @trusted
 /// 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)();
 
@@ -204,6 +183,10 @@ out(result; memory.ptr is result)
     {
         ((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); })))
     {
@@ -292,6 +275,24 @@ out(result; memory.ptr is result)
     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/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.

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/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)
@@ -103,7 +103,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 +121,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 +148,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 +166,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 +183,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 +210,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 +229,7 @@ struct Address4
     ///
     @nogc nothrow pure @safe unittest
     {
-        assert(address4("192.168.0.1").isUnicast());
+        assert(address4("192.168.0.1").get.isUnicast());
     }
 
     /**
@@ -276,7 +276,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 +293,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 +394,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 +499,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 +515,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 +543,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("::").isAny());
+        assert(address6("::").get.isAny());
     }
 
     /**
@@ -560,7 +560,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("::1").isLoopback());
+        assert(address6("::1").get.isLoopback());
     }
 
     /**
@@ -579,7 +579,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("ff00::").isMulticast());
+        assert(address6("ff00::").get.isMulticast());
     }
 
     /**
@@ -598,7 +598,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("::1").isUnicast());
+        assert(address6("::1").get.isUnicast());
     }
 
     /**
@@ -615,7 +615,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("fe80::1").isLinkLocal());
+        assert(address6("fe80::1").get.isLinkLocal());
     }
 
     /**
@@ -632,7 +632,7 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        assert(address6("fd80:124e:34f3::1").isUniqueLocal());
+        assert(address6("fd80:124e:34f3::1").get.isUniqueLocal());
     }
 
     /**
@@ -678,7 +678,7 @@ struct Address6
     {
         import tanya.algorithm.comparison : equal;
 
-        assert(equal(address6("1:2:3:4:5:6:7:8").stringify()[],
+        assert(equal(address6("1:2:3:4:5:6:7:8").get.stringify()[],
                "0001:0002:0003:0004:0005:0006:0007:0008"));
     }
 
@@ -697,7 +697,7 @@ 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);
     }
 }
 
@@ -935,26 +935,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);
-    }
-    {
-        ubyte[16] expected;
-        auto actual = address6("::");
-        assert(actual.address == expected);
-    }
-    {
-        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);
-    }
-    {
-        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);
-    }
+    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.get.address == expected);
+}
+
+@nogc nothrow @safe unittest
+{
+    ubyte[16] expected;
+    auto actual = address6("::");
+    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.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.get.address == expected);
 }
 
 // Rejects malformed addresses
@@ -971,25 +975,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);
-    }
-    {
-        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);
-    }
-    {
-        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);
-    }
+    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.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.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.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 +1051,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/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,6 +18,7 @@
 module tanya.typecons;
 
 import tanya.algorithm.mutation;
+import tanya.conv;
 import tanya.format;
 import tanya.functional;
 import tanya.meta.metafunction;
@@ -227,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;
     }
@@ -367,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;
     }
 
@@ -399,7 +411,7 @@ struct Option(T)
         }
     }
 
-    alias get this;
+    alias get_ this;
 }
 
 ///
@@ -515,6 +527,15 @@ struct Option(T)
     assert(OptionT(Hashable(1U)).toHash() == 1U);
 }
 
+// Can assign Option that is nothing
+@nogc nothrow pure @safe unittest
+{
+    auto option1 = Option!int(5);
+    Option!int option2;
+    option1 = option2;
+    assert(option1.isNothing);
+}
+
 /**
  * Creates a new $(D_PSYMBOL Option).
  *
@@ -541,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)));
+}