algorithm.mutation.destroyAll: New

Fix #71.

.gitignore

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

.travis.yml

@@ -7,8 +7,7 @@ os:
 language: d
 
 d:
-- dmd-2.082.0
-- dmd-2.081.2
+- dmd-2.082.1
 
 env:
   matrix:
@@ -18,8 +17,8 @@ env:
 matrix:
   include:
   - name: "D-Scanner"
-    d: dmd-2.082.0
-    env: DSCANNER=0.5.10
+    d: dmd-2.082.1
+    env: DSCANNER=0.5.11
     os: linux
 
 addons:
@@ -28,7 +27,7 @@ addons:
     - gcc-multilib
 
 before_script:
-- if [ "`$DC --version | head -n 1 | grep 'v2.082.0'`" ] &&
+- if [ "`$DC --version | head -n 1 | grep 'v2.082.1'`" ] &&
      [ -z "$DSCANNER" ]; then
     export UNITTEST="unittest-cov";
   fi

README.md

@@ -174,9 +174,9 @@ parameter is used)
 ### Supported compilers
 
 | DMD     | GCC             |
-|:-------:|:------:|
-| 2.082.0 | gdc-8  |
-| 2.081.2 | gdc-7  |
+|:-------:|:---------------:|
+| 2.082.1 | gdc-8 (2.081.2) |
+|         | gdc-7 (2.081.2) |
 
 ### Release management
 

appveyor.yml

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

arch/build.ninja

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

arch/x64/linux/memory/equal.S

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

source/tanya/algorithm/comparison.d

@@ -15,8 +15,8 @@
 module tanya.algorithm.comparison;
 
 import tanya.algorithm.mutation;
-import tanya.math : isNaN;
-import tanya.memory.op;
+import tanya.math;
+static import tanya.memory.op;
 import tanya.meta.metafunction;
 import tanya.meta.trait;
 import tanya.meta.transform;
@@ -296,7 +296,7 @@ if (allSatisfy!(isInputRange, R1, R2)
             && is(R1 == R2)
             && __traits(isPOD, ElementType!R1))
     {
-        return cmp(r1, r2) == 0;
+        return tanya.memory.op.equal(r1, r2);
     }
     else
     {

source/tanya/algorithm/mutation.d

@@ -14,6 +14,7 @@
  */
 module tanya.algorithm.mutation;
 
+import tanya.conv;
 static import tanya.memory.op;
 import tanya.meta.trait;
 import tanya.meta.transform;
@@ -87,6 +88,12 @@ do
         tanya.memory.op.copy((&source)[0 .. 1], (&target)[0 .. 1]);
 
         static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
+        {
+            static if (__VERSION__ >= 2083) // __traits(isZeroInit) available.
+            {
+                deinitialize!(__traits(isZeroInit, T))(source);
+            }
+            else
             {
                 if (typeid(T).initializer().ptr is null)
                 {
@@ -98,6 +105,7 @@ do
                 }
             }
         }
+    }
     else
     {
         target = source;
@@ -388,3 +396,214 @@ do
 
     assert(copy(source[], target).value == 5);
 }
+
+/**
+ * Fills $(D_PARAM range) with $(D_PARAM value).
+ *
+ * Params:
+ *  Range = Input range type.
+ *  Value = Filler type.
+ *  range = Input range.
+ *  value = Filler.
+ */
+void fill(Range, Value)(Range range, auto ref Value value)
+if (isInputRange!Range && isAssignable!(ElementType!Range, Value))
+{
+    static if (!isDynamicArray!Range && is(typeof(range[] = value)))
+    {
+        range[] = value;
+    }
+    else
+    {
+        for (; !range.empty; range.popFront())
+        {
+            range.front = value;
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    int[6] actual;
+    const int[6] expected = [1, 1, 1, 1, 1, 1];
+
+    fill(actual[], 1);
+    assert(equal(actual[], expected[]));
+}
+
+// [] is called where possible
+@nogc nothrow pure @system unittest
+{
+    static struct Slice
+    {
+        bool* slicingCalled;
+
+        int front() @nogc nothrow pure @safe
+        {
+            return 0;
+        }
+
+        void front(int) @nogc nothrow pure @safe
+        {
+        }
+
+        void popFront() @nogc nothrow pure @safe
+        {
+        }
+
+        bool empty() @nogc nothrow pure @safe
+        {
+            return true;
+        }
+
+        void opIndexAssign(int) @nogc nothrow pure @safe
+        {
+            *this.slicingCalled = true;
+        }
+    }
+    bool slicingCalled;
+    auto range = Slice(&slicingCalled);
+    fill(range, 0);
+    assert(slicingCalled);
+}
+
+/**
+ * Fills $(D_PARAM range) with $(D_PARAM value) assuming the elements of the
+ * $(D_PARAM range) aren't initialized.
+ *
+ * Params:
+ *  Range = Input range type.
+ *  Value = Initializer type.
+ *  range = Input range.
+ *  value = Initializer.
+ */
+void uninitializedFill(Range, Value)(Range range, auto ref Value value)
+if (isInputRange!Range && hasLvalueElements!Range
+ && isAssignable!(ElementType!Range, Value))
+{
+    static if (hasElaborateDestructor!(ElementType!Range))
+    {
+        for (; !range.empty; range.popFront())
+        {
+            ElementType!Range* p = &range.front;
+            emplace!(ElementType!Range)(cast(void[]) (p[0 .. 1]), value);
+        }
+    }
+    else
+    {
+        fill(range, value);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    int[6] actual = void;
+    const int[6] expected = [1, 1, 1, 1, 1, 1];
+
+    uninitializedFill(actual[], 1);
+    assert(equal(actual[], expected[]));
+}
+
+/**
+ * Initializes all elements of the $(D_PARAM range) assuming that they are
+ * uninitialized.
+ *
+ * Params:
+ *  Range = Input range type
+ *  range = Input range.
+ */
+void initializeAll(Range)(Range range) @trusted
+if (isInputRange!Range && hasLvalueElements!Range)
+{
+    import tanya.memory.op : copy, fill;
+    alias T = ElementType!Range;
+
+    static if (__VERSION__ >= 2083
+            && isDynamicArray!Range
+            && __traits(isZeroInit, T))
+    {
+        fill!0(range);
+    }
+    else
+    {
+        static immutable init = T.init;
+        for (; !range.empty; range.popFront())
+        {
+            copy((&init)[0 .. 1], (&range.front)[0 .. 1]);
+        }
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    int[2] actual = void;
+    const int[2] expected = [0, 0];
+
+    initializeAll(actual[]);
+    assert(equal(actual[], expected[]));
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static struct NonCopyable
+    {
+        @disable this(this);
+    }
+    NonCopyable[] nonCopyable;
+    initializeAll(nonCopyable);
+}
+
+/**
+ * Destroys all elements in the $(D_PARAM range).
+ *
+ * This function has effect only if the element type of $(D_PARAM Range) has
+ * an elaborate destructor, i.e. it is a $(D_PSYMBOL struct) with an explicit
+ * or generated by the compiler destructor.
+ *
+ * Params:
+ *  Range = Input range type.
+ *  range = Input range.
+ */
+void destroyAll(Range)(Range range)
+if (isInputRange!Range && hasLvalueElements!Range)
+{
+    static if (hasElaborateDestructor!(ElementType!Range))
+    {
+        foreach (ref e; range)
+        {
+            destroy(e);
+        }
+    }
+}
+
+///
+@nogc nothrow pure @trusted unittest
+{
+    static struct WithDtor
+    {
+        private size_t* counter;
+        ~this() @nogc nothrow pure
+        {
+            if (this.counter !is null)
+            {
+                ++(*this.counter);
+            }
+        }
+    }
+
+    size_t counter;
+    WithDtor[2] withDtor = [WithDtor(&counter), WithDtor(&counter)];
+
+    destroyAll(withDtor[]);
+
+    assert(counter == 2);
+}

source/tanya/algorithm/searching.d

@@ -0,0 +1,78 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Searching algorithms.
+ *
+ * Copyright: Eugene Wissner 2018.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/algorithm/searching.d,
+ *                 tanya/algorithm/searching.d)
+ */
+module tanya.algorithm.searching;
+
+import tanya.range;
+
+/**
+ * Counts the elements in an input range.
+ *
+ * If $(D_PARAM R) has length, $(D_PSYMBOL count) returns it, otherwise it
+ * iterates over the range and counts the elements.
+ *
+ * Params:
+ *  R     = Input range type.
+ *  range = Input range.
+ *
+ * Returns: $(D_PARAM range) length.
+ */
+size_t count(R)(R range)
+if (isInputRange!R)
+{
+    static if (hasLength!R)
+    {
+        return range.length;
+    }
+    else
+    {
+        size_t counter;
+        for (; !range.empty; range.popFront(), ++counter)
+        {
+        }
+        return counter;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    int[3] array;
+    assert(count(array) == 3);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static struct Range
+    {
+        private int counter = 3;
+
+        int front() const @nogc nothrow pure @safe
+        {
+            return this.counter;
+        }
+
+        void popFront() @nogc nothrow pure @safe
+        {
+            --this.counter;
+        }
+
+        bool empty() const @nogc nothrow pure @safe
+        {
+            return this.counter == 0;
+        }
+    }
+    Range range;
+    assert(count(range) == 3);
+}

source/tanya/container/array.d

@@ -15,19 +15,14 @@
 module tanya.container.array;
 
 import core.checkedint;
-import std.algorithm.mutation : bringToFront,
-                                copy,
-                                fill,
-                                initializeAll,
-                                uninitializedFill;
-import std.meta;
+import std.algorithm.mutation : bringToFront;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.exception;
 import tanya.memory;
 import tanya.meta.trait;
 import tanya.meta.transform;
-import tanya.range.primitive;
+import tanya.range;
 
 /**
  * Random-access range for the $(D_PSYMBOL Array).
@@ -419,28 +414,20 @@ struct Array(T)
      */
     @property void length(size_t len) @trusted
     {
-        if (len == length)
-        {
-            return;
-        }
-        else if (len > length)
+        if (len > length)
         {
             reserve(len);
             initializeAll(this.data[length_ .. len]);
         }
         else
         {
-            static if (hasElaborateDestructor!T)
+            destroyAll(this.data[len .. this.length_]);
+        }
+        if (len != length)
         {
-                const T* end = this.data + length_ - 1;
-                for (T* e = this.data + len; e != end; ++e)
-                {
-                    destroy(*e);
-                }
-            }
-        }
             length_ = len;
         }
+    }
 
     ///
     @nogc nothrow pure @safe unittest
@@ -1590,7 +1577,7 @@ struct Array(T)
 
 @nogc nothrow pure @safe unittest
 {
-    struct SWithDtor
+    static struct SWithDtor
     {
         ~this() @nogc nothrow pure @safe
         {

source/tanya/container/list.d

@@ -15,7 +15,6 @@
  */
 module tanya.container.list;
 
-import std.algorithm.searching;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.container.entry;

source/tanya/container/string.d

@@ -27,7 +27,6 @@
 module tanya.container.string;
 
 import std.algorithm.mutation : bringToFront;
-import std.algorithm.searching : count;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.hash.lookup;
@@ -1485,6 +1484,8 @@ struct String
     ///
     @nogc pure @safe unittest
     {
+        import tanya.algorithm.searching : count;
+
         auto s = String("Из пословицы слова не выкинешь.");
 
         assert(s.remove(s[5 .. 24]).length == 33);

source/tanya/conv.d

@@ -14,6 +14,7 @@
  */
 module tanya.conv;
 
+import tanya.algorithm.mutation;
 import tanya.container.string;
 import tanya.format;
 import tanya.memory;
@@ -164,40 +165,48 @@ do
 /// ditto
 T* emplace(T, Args...)(void[] memory, auto ref Args args)
 if (!isPolymorphicType!T && isAggregateType!T)
-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 (!hasElaborateAssign!T && isAssignable!T)
-    {
-        *result = T.init;
-    }
-    else
-    {
-        static const T init = T.init;
-        copy((cast(void*) &init)[0 .. T.sizeof], memory);
-    }
+    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");
     }
-    else static if (is(typeof(T(args))))
-    {
-        *result = T(args);
-    }
     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);
+            }
+        }
         result.__ctor(args);
     }
+    else static if (Args.length == 1 && is(typeof({ T t = args[0]; })))
+    {
+        trustedCopy(args[0]);
+    }
+    else static if (is(typeof({ T t = T(args); })))
+    {
+        auto init = T(args);
+        (() @trusted => moveEmplace(init, *result))();
+    }
     else
     {
         static assert(false,
@@ -245,6 +254,38 @@ do
     static assert(is(typeof(emplace!F((void[]).init))));
 }
 
+// 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))));
+}
+
+// Doesn't call a destructor on uninitialized elements
+@nogc nothrow pure @system unittest
+{
+    static struct WithDtor
+    {
+        private bool canBeInvoked = false;
+        ~this() @nogc nothrow pure @safe
+        {
+            if (!this.canBeInvoked)
+            {
+                assert(false);
+            }
+        }
+    }
+    void[WithDtor.sizeof] memory = void;
+    auto actual = emplace!WithDtor(memory[], WithDtor(true));
+    assert(actual.canBeInvoked);
+}
+
 /**
  * Thrown if a type conversion fails.
  */
@@ -856,13 +897,6 @@ if (is(Unqual!From == bool) && isNumeric!To && !is(Unqual!To == Unqual!From))
     assert(false.to!int == 0);
 }
 
-deprecated("Use tanya.format.format instead")
-To to(To, From)(auto ref From from)
-if (is(Unqual!To == String))
-{
-    return format!"{}"(from);
-}
-
 /**
  * Converts a stringish range to an integral value.
  *

source/tanya/format.d

@@ -43,7 +43,7 @@ import tanya.algorithm.comparison;
 import tanya.container.string;
 import tanya.encoding.ascii;
 import tanya.math;
-import tanya.memory.op;
+static import tanya.memory.op;
 import tanya.meta.metafunction;
 import tanya.meta.trait;
 import tanya.meta.transform;
@@ -1351,7 +1351,7 @@ do
         intSlice.popBack();
     }
     const begin = buffer.length - intSlice.length;
-    copy(intSlice, buffer[begin .. $]);
+    tanya.memory.op.copy(intSlice, buffer[begin .. $]);
 
     exponent = cast(int) (intSlice.length + mismatch);
 
@@ -1388,7 +1388,7 @@ do
 
     char[21] intBuffer;
     auto intSlice = integral2String(decimal, intBuffer);
-    copy(intSlice, buffer);
+    tanya.memory.op.copy(intSlice, buffer);
     exponent = cast(int) intSlice.length;
 
     size_t position = exponent;
@@ -1903,7 +1903,7 @@ private char[] errol3(double value,
         if (pathologies[middle].representation == bits.integral)
         {
             exponent = pathologies[middle].exponent;
-            copy(pathologies[middle].digits, buffer);
+            tanya.memory.op.copy(pathologies[middle].digits, buffer);
             return buffer[0 .. pathologies[middle].digits.length];
         }
         else if (pathologies[middle].representation < bits.integral)
@@ -2054,7 +2054,7 @@ if (isFloatingPoint!T)
         {
             length = precision + 1;
         }
-        realString[1 .. length].copy(bufferSlice);
+        tanya.memory.op.copy(realString[1 .. length], bufferSlice);
         bufferSlice.popFrontExactly(length - 1);
 
         // Dump the exponent.
@@ -2116,7 +2116,7 @@ if (isFloatingPoint!T)
                 n = precision;
             }
 
-            fill!'0'(bufferSlice[0 .. n]);
+            tanya.memory.op.fill!'0'(bufferSlice[0 .. n]);
             bufferSlice.popFrontExactly(n);
 
             if ((length + n) > precision)
@@ -2124,7 +2124,7 @@ if (isFloatingPoint!T)
                 length = precision - n;
             }
 
-            realString[0 .. length].copy(bufferSlice);
+            tanya.memory.op.copy(realString[0 .. length], bufferSlice);
             bufferSlice.popFrontExactly(length);
         }
         else if (cast(uint) decimalPoint >= length)
@@ -2142,7 +2142,7 @@ if (isFloatingPoint!T)
             {
                 n = decimalPoint - n;
 
-                fill!'0'(bufferSlice[0 .. n]);
+                tanya.memory.op.fill!'0'(bufferSlice[0 .. n]);
                 bufferSlice.popFrontExactly(n);
             }
             if (precision != 0)
@@ -2173,7 +2173,7 @@ if (isFloatingPoint!T)
                 length = precision + decimalPoint;
             }
 
-            realString[n .. length].copy(bufferSlice);
+            tanya.memory.op.copy(realString[n .. length], bufferSlice);
             bufferSlice.popFrontExactly(length - n);
         }
     }

source/tanya/hash/lookup.d

@@ -29,6 +29,11 @@ private struct FNV
         enum ulong offsetBasis = 14695981039346656037UL;
         enum ulong prime = 1099511628211UL;
     }
+    else static if (size_t.sizeof == 16)
+    {
+        enum size_t offsetBasis = (size_t(0x6c62272e07bb0142UL) << 64) + 0x62b821756295c58dUL;
+        enum size_t prime = (size_t(1) << 88) + (1 << 8) + 0x3b;
+    }
     else
     {
         static assert(false, "FNV requires at least 32-bit hash length");

source/tanya/math/mp.d

@@ -14,7 +14,6 @@
  */
 module tanya.math.mp;
 
-import std.algorithm.mutation : fill;
 import tanya.algorithm.comparison;
 import tanya.algorithm.iteration;
 import tanya.algorithm.mutation;

source/tanya/math/random.d

@@ -15,10 +15,11 @@
 module tanya.math.random;
 
 import std.digest.sha;
-import std.typecons;
 import tanya.memory;
+import tanya.typecons;
 
 /// Block size of entropy accumulator (SHA-512).
+deprecated
 enum blockSize = 64;
 
 /// Maximum amount gathered from the entropy sources.
@@ -39,7 +40,7 @@ class EntropyException : Exception
     this(string msg,
          string file = __FILE__,
          size_t line = __LINE__,
-         Throwable next = null) pure @safe nothrow const @nogc
+         Throwable next = null) const @nogc nothrow pure @safe
     {
         super(msg, file, line, next);
     }
@@ -56,17 +57,17 @@ abstract class EntropySource
     /**
      * Returns: Minimum bytes required from the entropy source.
      */
-    @property ubyte threshold() const pure nothrow @safe @nogc;
+    @property ubyte threshold() const @nogc nothrow pure @safe;
 
     /**
      * Returns: Whether this entropy source is strong.
      */
-    @property bool strong() const pure nothrow @safe @nogc;
+    @property bool strong() const @nogc nothrow pure @safe;
 
     /**
      * Returns: Amount of already generated entropy.
      */
-    @property ushort size() const pure nothrow @safe @nogc
+    @property ushort size() const @nogc nothrow pure @safe
     {
         return size_;
     }
@@ -76,7 +77,7 @@ abstract class EntropySource
      *  size = Amount of already generated entropy. Cannot be smaller than the
      *         already set value.
      */
-    @property void size(ushort size) pure nothrow @safe @nogc
+    @property void size(ushort size) @nogc nothrow pure @safe
     {
         size_ = size;
     }
@@ -89,9 +90,13 @@ abstract class EntropySource
      *           to fill the buffer).
      *
      * Returns: Number of bytes that were copied to the $(D_PARAM output)
-     *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+     *          or nothing on error.
+     *
+     * Postcondition: Returned length is less than or equal to
+     *                $(D_PARAM output) length.
      */
-    Nullable!ubyte poll(out ubyte[maxGather] output) @nogc;
+    Option!ubyte poll(out ubyte[maxGather] output) @nogc
+    out (length; length.isNothing || length.get <= maxGather);
 }
 
 version (CRuntime_Bionic)
@@ -118,7 +123,7 @@ else version (Solaris)
 version (linux)
 {
     import core.stdc.config : c_long;
-    extern (C) c_long syscall(c_long number, ...) nothrow @system @nogc;
+    private extern(C) c_long syscall(c_long number, ...) @nogc nothrow @system;
 
     /**
      * Uses getrandom system call.
@@ -128,7 +133,7 @@ version (linux)
         /**
          * Returns: Minimum bytes required from the entropy source.
          */
-        override @property ubyte threshold() const pure nothrow @safe @nogc
+        override @property ubyte threshold() const @nogc nothrow pure @safe
         {
             return 32;
         }
@@ -136,7 +141,7 @@ version (linux)
         /**
          * Returns: Whether this entropy source is strong.
          */
-        override @property bool strong() const pure nothrow @safe @nogc
+        override @property bool strong() const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -149,19 +154,14 @@ version (linux)
          *           to fill the buffer).
          *
          * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+         *          or nothing on error.
          */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) nothrow @nogc
-        out (length)
-        {
-            assert(length <= maxGather);
-        }
-        do
+        override Option!ubyte poll(out ubyte[maxGather] output) @nogc nothrow
         {
             // int getrandom(void *buf, size_t buflen, unsigned int flags);
             import mir.linux._asm.unistd : NR_getrandom;
             auto length = syscall(NR_getrandom, output.ptr, output.length, 0);
-            Nullable!ubyte ret;
+            Option!ubyte ret;
 
             if (length >= 0)
             {
@@ -170,19 +170,11 @@ version (linux)
             return ret;
         }
     }
-
-    @nogc @system unittest
-    {
-        auto entropy = defaultAllocator.make!Entropy();
-        ubyte[blockSize] output;
-        output = entropy.random;
-
-        defaultAllocator.dispose(entropy);
-    }
 }
 else version (SecureARC4Random)
 {
-    private extern (C) void arc4random_buf(scope void* buf, size_t nbytes) nothrow @nogc @system;
+    private extern(C) void arc4random_buf(scope void* buf, size_t nbytes)
+    @nogc nothrow @system;
 
     /**
      * Uses arc4random_buf.
@@ -192,7 +184,7 @@ else version (SecureARC4Random)
         /**
          * Returns: Minimum bytes required from the entropy source.
          */
-        override @property ubyte threshold() const pure nothrow @safe @nogc
+        override @property ubyte threshold() const @nogc nothrow pure @safe
         {
             return 32;
         }
@@ -200,7 +192,7 @@ else version (SecureARC4Random)
         /**
          * Returns: Whether this entropy source is strong.
          */
-        override @property bool strong() const pure nothrow @safe @nogc
+        override @property bool strong() const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -213,23 +205,15 @@ else version (SecureARC4Random)
          *           to fill the buffer).
          *
          * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+         *          or nothing on error.
          */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) nothrow @nogc @safe
+        override Option!ubyte poll(out ubyte[maxGather] output)
+        @nogc nothrow @safe
         {
             (() @trusted => arc4random_buf(output.ptr, output.length))();
-            return Nullable!ubyte(cast(ubyte) (output.length));
+            return Option!ubyte(cast(ubyte) (output.length));
         }
     }
-
-    @nogc @system unittest
-    {
-        auto entropy = defaultAllocator.make!Entropy();
-        ubyte[blockSize] output;
-        output = entropy.random;
-
-        defaultAllocator.dispose(entropy);
-    }
 }
 else version (Windows)
 {
@@ -248,22 +232,31 @@ else version (Windows)
         BOOL CryptReleaseContext(HCRYPTPROV, ULONG_PTR);
     }
 
-    private bool initCryptGenRandom(scope ref HCRYPTPROV hProvider) @nogc nothrow @trusted
+    private bool initCryptGenRandom(scope ref HCRYPTPROV hProvider)
+    @nogc nothrow @trusted
     {
         // https://msdn.microsoft.com/en-us/library/windows/desktop/aa379886(v=vs.85).aspx
         // For performance reasons, we recommend that you set the pszContainer
         // parameter to NULL and the dwFlags parameter to CRYPT_VERIFYCONTEXT
         // in all situations where you do not require a persisted key.
-        // CRYPT_SILENT is intended for use with applications for which the UI cannot be displayed by the CSP.
-        if (!CryptAcquireContextW(&hProvider, null, null, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
+        // CRYPT_SILENT is intended for use with applications for which the UI
+        // cannot be displayed by the CSP.
+        if (!CryptAcquireContextW(&hProvider,
+                                  null,
+                                  null,
+                                  PROV_RSA_FULL,
+                                  CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
         {
-            if (GetLastError() == NTE_BAD_KEYSET)
+            if (GetLastError() != NTE_BAD_KEYSET)
             {
-                // Attempt to create default container
-                if (!CryptAcquireContextA(&hProvider, null, null, PROV_RSA_FULL, CRYPT_NEWKEYSET | CRYPT_SILENT))
                 return false;
             }
-            else
+            // Attempt to create default container
+            if (!CryptAcquireContextA(&hProvider,
+                                      null,
+                                      null,
+                                      PROV_RSA_FULL,
+                                      CRYPT_NEWKEYSET | CRYPT_SILENT))
             {
                 return false;
             }
@@ -299,7 +292,7 @@ else version (Windows)
         /**
          * Returns: Minimum bytes required from the entropy source.
          */
-        override @property ubyte threshold() const pure nothrow @safe @nogc
+        override @property ubyte threshold() const @nogc nothrow pure @safe
         {
             return 32;
         }
@@ -307,7 +300,7 @@ else version (Windows)
         /**
          * Returns: Whether this entropy source is strong.
          */
-        override @property bool strong() const pure nothrow @safe @nogc
+        override @property bool strong() const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -320,16 +313,14 @@ else version (Windows)
          *           to fill the buffer).
          *
          * Returns: Number of bytes that were copied to the $(D_PARAM output)
-         *          or $(D_PSYMBOL Nullable!ubyte.init) on error.
+         *          or nothing on error.
          */
-        override Nullable!ubyte poll(out ubyte[maxGather] output) @nogc nothrow @safe
-        in
+        override Option!ubyte poll(out ubyte[maxGather] output)
+        @nogc nothrow @safe
         {
-            assert(hProvider > 0, "hProvider not properly initialized.");
-        }
-        do
-        {
-            Nullable!ubyte ret;
+            Option!ubyte ret;
+
+            assert(hProvider > 0, "hProvider not properly initialized");
             if ((() @trusted => CryptGenRandom(hProvider, output.length, cast(PBYTE) output.ptr))())
             {
                 ret = cast(ubyte) (output.length);
@@ -337,15 +328,16 @@ else version (Windows)
             return ret;
         }
     }
-
-    @nogc @system unittest
-    {
-        auto entropy = defaultAllocator.make!Entropy();
-        ubyte[blockSize] output;
-        output = entropy.random;
-
-        defaultAllocator.dispose(entropy);
 }
+
+static if (is(PlatformEntropySource)) @nogc @system unittest
+{
+    import tanya.memory.smartref : unique;
+
+    auto source = defaultAllocator.unique!PlatformEntropySource();
+
+    assert(source.threshold == 32);
+    assert(source.strong);
 }
 
 /**
@@ -360,6 +352,7 @@ else version (Windows)
  * defaultAllocator.dispose(entropy);
  * ---
  */
+deprecated
 class Entropy
 {
     /// Entropy sources.
@@ -396,7 +389,7 @@ class Entropy
     /**
      * Returns: Amount of the registered entropy sources.
      */
-    @property ubyte sourceCount() const pure nothrow @safe @nogc
+    @property ubyte sourceCount() const @nogc nothrow pure @safe
     {
         return sourceCount_;
     }
@@ -413,7 +406,7 @@ class Entropy
      *  $(D_PSYMBOL EntropySource)
      */
     Entropy opOpAssign(string op)(EntropySource source)
-    pure nothrow @safe @nogc
+    @nogc nothrow pure @safe
     if (op == "~")
     in
     {
@@ -451,7 +444,7 @@ class Entropy
             {
                 auto outputLength = sources[i].poll(buffer);
 
-                if (!outputLength.isNull)
+                if (!outputLength.isNothing)
                 {
                     if (outputLength > 0)
                     {
@@ -502,7 +495,7 @@ class Entropy
      */
     protected void update(in ubyte sourceId,
                           ref ubyte[maxGather] data,
-                          ubyte length) pure nothrow @safe @nogc
+                          ubyte length) @nogc nothrow pure @safe
     {
         ubyte[2] header;
 

source/tanya/memory/op.d

@@ -24,7 +24,7 @@ version (TanyaNative)
     extern private void moveMemory(const void[], void[])
     pure nothrow @system @nogc;
 
-    extern private int cmpMemory(const void[], const void[])
+    extern private bool equalMemory(const void[], const void[])
     pure nothrow @system @nogc;
 }
 else
@@ -43,7 +43,7 @@ version (TanyaNative)
 
     @nogc nothrow pure @safe unittest
     {
-        assert(cmp(null, null) == 0);
+        assert(equal(null, null));
     }
 }
 
@@ -91,7 +91,7 @@ do
     ubyte[9] source = [1, 2, 3, 4, 5, 6, 7, 8, 9];
     ubyte[9] target;
     source.copy(target);
-    assert(cmp(source, target) == 0);
+    assert(equal(source, target));
 }
 
 @nogc nothrow pure @safe unittest
@@ -110,7 +110,7 @@ do
         ubyte[8] source = [1, 2, 3, 4, 5, 6, 7, 8];
         ubyte[8] target;
         source.copy(target);
-        assert(cmp(source, target) == 0);
+        assert(equal(source, target));
     }
 }
 
@@ -212,7 +212,7 @@ do
     ubyte[6] expected = [ 'a', 'a', 'a', 'a', 'b', 'b' ];
 
     copyBackward(mem[0 .. 4], mem[2 .. $]);
-    assert(cmp(expected, mem) == 0);
+    assert(equal(expected, mem));
 }
 
 @nogc nothrow pure @safe unittest
@@ -221,7 +221,7 @@ do
     ubyte[9] r2;
 
     copyBackward(r1, r2);
-    assert(cmp(r1, r2) == 0);
+    assert(equal(r1, r2));
 }
 
 /**
@@ -241,6 +241,7 @@ do
  *          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
 {
@@ -249,49 +250,14 @@ in
 }
 do
 {
-    version (TanyaNative)
-    {
-        return cmpMemory(r1, r2);
-    }
-    else
-    {
+    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);
 }
-}
-
-///
-@nogc nothrow pure @safe unittest
-{
-    ubyte[4] r1 = [ 'a', 'b', 'c', 'd' ];
-    ubyte[3] r2 = [ 'c', 'a', 'b' ];
-
-    assert(cmp(r1[0 .. 3], r2[]) < 0);
-    assert(cmp(r2[], r1[0 .. 3]) > 0);
-
-    assert(cmp(r1, r2) > 0);
-    assert(cmp(r2, r1) < 0);
-}
-
-@nogc nothrow pure @safe unittest
-{
-    ubyte[16] r1 = [
-        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
-    ];
-    ubyte[16] r2 = [
-        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
-    ];
-
-    assert(cmp(r1, r2) == 0);
-    assert(cmp(r1[1 .. $], r2[1 .. $]) == 0);
-    assert(cmp(r1[0 .. $ - 1], r2[0 .. $ - 1]) == 0);
-    assert(cmp(r1[0 .. 8], r2[0 .. 8]) == 0);
-}
 
 /**
  * Finds the first occurrence of $(D_PARAM needle) in $(D_PARAM haystack) if
@@ -362,13 +328,13 @@ do
 {
     const ubyte[9] haystack = ['a', 'b', 'c', 'd', 'e', 'f', 'b', 'g', 'h'];
 
-    assert(cmp(find(haystack, 'a'), haystack[]) == 0);
-    assert(cmp(find(haystack, 'b'), haystack[1 .. $]) == 0);
-    assert(cmp(find(haystack, 'c'), haystack[2 .. $]) == 0);
-    assert(cmp(find(haystack, 'd'), haystack[3 .. $]) == 0);
-    assert(cmp(find(haystack, 'e'), haystack[4 .. $]) == 0);
-    assert(cmp(find(haystack, 'f'), haystack[5 .. $]) == 0);
-    assert(cmp(find(haystack, 'h'), haystack[8 .. $]) == 0);
+    assert(equal(find(haystack, 'a'), haystack[]));
+    assert(equal(find(haystack, 'b'), haystack[1 .. $]));
+    assert(equal(find(haystack, 'c'), haystack[2 .. $]));
+    assert(equal(find(haystack, 'd'), haystack[3 .. $]));
+    assert(equal(find(haystack, 'e'), haystack[4 .. $]));
+    assert(equal(find(haystack, 'f'), haystack[5 .. $]));
+    assert(equal(find(haystack, 'h'), haystack[8 .. $]));
     assert(find(haystack, 'i').length == 0);
 
     assert(find(null, 'a').length == 0);
@@ -441,10 +407,66 @@ do
 ///
 @nogc nothrow pure @safe unittest
 {
-    assert(cmp(findNullTerminated("abcdef\0gh"), "abcdef") == 0);
-    assert(cmp(findNullTerminated("\0garbage"), "") == 0);
-    assert(cmp(findNullTerminated("\0"), "") == 0);
-    assert(cmp(findNullTerminated("cstring\0"), "cstring") == 0);
+    assert(equal(findNullTerminated("abcdef\0gh"), "abcdef"));
+    assert(equal(findNullTerminated("\0garbage"), ""));
+    assert(equal(findNullTerminated("\0"), ""));
+    assert(equal(findNullTerminated("cstring\0"), "cstring"));
     assert(findNullTerminated(null) is null);
     assert(findNullTerminated("abcdef") is null);
 }
+
+/**
+ * Compares two memory areas $(D_PARAM r1) and $(D_PARAM r2) for equality.
+ *
+ * Params:
+ *  haystack = First memory block.
+ *  needle   = First memory block.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM r1) and $(D_PARAM r2) are equal,
+ *          $(D_KEYWORD false) otherwise.
+ */
+bool equal(const void[] r1, const void[] r2) @nogc nothrow pure @trusted
+in
+{
+    assert(r1.length == 0 || r1.ptr !is null);
+    assert(r2.length == 0 || r2.ptr !is null);
+}
+do
+{
+    version (TanyaNative)
+    {
+        return equalMemory(r1, r2);
+    }
+    else
+    {
+        return r1.length == r2.length
+            && memcmp(r1.ptr, r2.ptr, r1.length) == 0;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(equal("asdf", "asdf"));
+    assert(!equal("asd", "asdf"));
+    assert(!equal("asdf", "asd"));
+    assert(!equal("asdf", "qwer"));
+}
+
+// Compares unanligned memory
+@nogc nothrow pure @safe unittest
+{
+    ubyte[16] r1 = [
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
+    ];
+    ubyte[16] r2 = [
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
+    ];
+
+    assert(equal(r1, r2));
+    assert(equal(r1[1 .. $], r2[1 .. $]));
+    assert(equal(r1[0 .. $ - 1], r2[0 .. $ - 1]));
+    assert(equal(r1[0 .. 8], r2[0 .. 8]));
+}

source/tanya/memory/package.d

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

source/tanya/meta/metafunction.d

@@ -238,18 +238,6 @@ struct Pack(Args...)
     alias Seq this;
 }
 
-deprecated("Use Pack instead")
-struct Tuple(Args...)
-{
-    /// Elements in this tuple as $(D_PSYMBOL AliasSeq).
-    alias Seq = Args;
-
-    /// The length of the tuple.
-    enum size_t length = Args.length;
-
-    alias Seq this;
-}
-
 ///
 @nogc nothrow pure @safe unittest
 {

source/tanya/net/ip.d

@@ -490,8 +490,8 @@ struct Address6
         assert(address6("::14") > address6("::1"));
         assert(address6("::1") < address6("::14"));
         assert(address6("::1") == address6("::1"));
-        assert(address6("::1%1") < address6("::1%2"));
-        assert(address6("::1%2") > address6("::1%1"));
+        assert(address6("fe80::1%1") < address6("fe80::1%2"));
+        assert(address6("fe80::1%2") > address6("fe80::1%1"));
     }
 
     /**
@@ -716,20 +716,17 @@ private void write2Bytes(R)(ref R range, ubyte[] address)
  * is specified (i.e. first character after `%` is not a digit), the parser
  * tries to convert it to the ID of that interface. If the interface with the
  * given name can't be found, the parser doesn't fail, but just ignores the
- * invalid interface name.
+ * invalid interface name, scope ID is `0` then.
  *
  * If an ID is given (i.e. first character after `%` is a digit),
  * $(D_PSYMBOL address6) just stores it in $(D_PSYMBOL Address6.scopeID) without
  * checking whether an interface with this ID really exists. If the ID is
  * invalid (if it is too long or contains non decimal characters), parsing
- * and nothing is returned.
+ * fails and nothing is returned.
  *
  * If neither an ID nor a name is given, $(D_PSYMBOL Address6.scopeID) is set
  * to `0`.
  *
- * The parser doesn't support notation with an embedded IPv4 address (e.g.
- * ::1.2.3.4).
- *
  * Params:
  *  R     = Input range type.
  *  range = Stringish range containing the address.
@@ -746,7 +743,6 @@ if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
     }
     Address6 result;
     ubyte[12] tail;
-    size_t i;
     size_t j;
 
     // An address begins with a number, not ':'. But there is a special case
@@ -764,10 +760,27 @@ if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
 
     // Parse the address before '::'.
     // This loop parses the whole address if it doesn't contain '::'.
-    for (; i < 13; i += 2)
+    static foreach (i; 0 .. 7)
     {
-        write2Bytes(range, result.address[i .. $]);
-        if (range.empty || range.front != ':')
+        { // To make "state" definition local
+            static if (i == 6) // Can be embedded IPv4
+            {
+                auto state = range.save();
+            }
+            write2Bytes(range, result.address[i * 2 .. $]);
+            if (range.empty)
+            {
+                return typeof(return)();
+            }
+            static if (i == 6)
+            {
+                if (range.front == '.')
+                {
+                    swap(range, state);
+                    goto ParseIPv4;
+                }
+            }
+            if (range.front != ':')
             {
                 return typeof(return)();
             }
@@ -782,6 +795,7 @@ if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
                 goto ParseTail;
             }
         }
+    }
     write2Bytes(range, result.address[14 .. $]);
 
     if (range.empty)
@@ -810,6 +824,9 @@ ParseTail: // after ::
     {
         return typeof(return)();
     }
+    { // To make "state" definition local
+        auto state = range.save();
+
         write2Bytes(range, tail[j .. $]);
         if (range.empty)
         {
@@ -819,18 +836,26 @@ ParseTail: // after ::
         {
             goto ParseIface;
         }
+        else if (range.front == '.')
+        {
+            swap(range, state);
+            goto ParseIPv4;
+        }
         else if (range.front != ':')
         {
             return typeof(return)();
         }
         range.popFront();
+    }
 
-    for (i = 2, j = 2; i <= 11; i += 2, j += 2, range.popFront())
+    j = 2;
+    for (size_t i = 2; i <= 11; i += 2, j += 2, range.popFront())
     {
         if (range.empty || range.front == ':')
         {
             return typeof(return)();
         }
+        auto state = range.save();
         write2Bytes(range, tail[j .. $]);
 
         if (range.empty)
@@ -841,12 +866,45 @@ ParseTail: // after ::
         {
             goto ParseIface;
         }
+        else if (range.front == '.')
+        {
+            swap(range, state);
+            goto ParseIPv4;
+        }
         else if (range.front != ':')
         {
             return typeof(return)();
         }
     }
 
+ParseIPv4:
+    // We know there is a number followed by '.'. We have to ensure this number
+    // is an octet
+    tail[j] = readIntegral!ubyte(range);
+    static foreach (i; 1 .. 4)
+    {
+        if (range.empty || range.front != '.')
+        {
+            return typeof(return)();
+        }
+        range.popFront();
+        if (range.empty)
+        {
+            return typeof(return)();
+        }
+        tail[j + i] = readIntegral!ubyte(range);
+    }
+    j += 2;
+
+    if (range.empty)
+    {
+        goto CopyTail;
+    }
+    else if (range.front != '%')
+    {
+        return typeof(return)();
+    }
+
 ParseIface: // Scope name or ID
     range.popFront();
     if (range.empty)
@@ -907,7 +965,31 @@ CopyTail:
     assert(address6(":a").isNothing);
     assert(address6("a:").isNothing);
     assert(address6("1:2:3:4::6:").isNothing);
-    assert(address6("1:2:3:4::6:7:8%").isNothing);
+    assert(address6("fe80:2:3:4::6:7:8%").isNothing);
+}
+
+// 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);
+    }
+    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);
 }
 
 /**

source/tanya/network/socket.d

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

source/tanya/range/adapter.d

@@ -5,12 +5,6 @@
 /**
  * Range adapters.
  *
- * A range adapter wraps another range and modifies the way, how the original
- * range is iterated, or the order in which its elements are accessed.
- *
- * All adapters are lazy algorithms, they request the next element of the
- * adapted range on demand.
- *
  * Copyright: Eugene Wissner 2018.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
@@ -18,245 +12,4 @@
  * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/range/adapter.d,
  *                 tanya/range/adapter.d)
  */
-deprecated("Use tanya.algorithm.iteration instead")
 module tanya.range.adapter;
-
-import tanya.algorithm.mutation;
-import tanya.math;
-import tanya.range.primitive;
-
-private mixin template Take(R, bool exactly)
-{
-    private R source;
-    size_t length_;
-
-    @disable this();
-
-    private this(R source, size_t length)
-    {
-        this.source = source;
-        static if (!exactly && hasLength!R)
-        {
-            this.length_ = min(source.length, length);
-        }
-        else
-        {
-            this.length_ = length;
-        }
-    }
-
-    @property auto ref front()
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        return this.source.front;
-    }
-
-    void popFront()
-    in
-    {
-        assert(!empty);
-    }
-    do
-    {
-        this.source.popFront();
-        --this.length_;
-    }
-
-    @property bool empty()
-    {
-        static if (exactly || isInfinite!R)
-        {
-            return length == 0;
-        }
-        else
-        {
-            return length == 0 || this.source.empty;
-        }
-    }
-
-    @property size_t length()
-    {
-        return this.length_;
-    }
-
-    static if (hasAssignableElements!R)
-    {
-        @property void front(ref ElementType!R value)
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            this.source.front = value;
-        }
-
-        @property void front(ElementType!R value)
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            this.source.front = move(value);
-        }
-    }
-
-    static if (isForwardRange!R)
-    {
-        typeof(this) save()
-        {
-            return typeof(this)(this.source.save(), length);
-        }
-    }
-    static if (isRandomAccessRange!R)
-    {
-        @property auto ref back()
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            return this.source[this.length - 1];
-        }
-
-        void popBack()
-        in
-        {
-            assert(!empty);
-        }
-        do
-        {
-            --this.length_;
-        }
-
-        auto ref opIndex(size_t i)
-        in
-        {
-            assert(i < length);
-        }
-        do
-        {
-            return this.source[i];
-        }
-
-        static if (hasAssignableElements!R)
-        {
-            @property void back(ref ElementType!R value)
-            in
-            {
-                assert(!empty);
-            }
-            do
-            {
-                this.source[length - 1] = value;
-            }
-
-            @property void back(ElementType!R value)
-            in
-            {
-                assert(!empty);
-            }
-            do
-            {
-                this.source[length - 1] = move(value);
-            }
-
-            void opIndexAssign(ref ElementType!R value, size_t i)
-            in
-            {
-                assert(i < length);
-            }
-            do
-            {
-                this.source[i] = value;
-            }
-
-            void opIndexAssign(ElementType!R value, size_t i)
-            in
-            {
-                assert(i < length);
-            }
-            do
-            {
-                this.source[i] = move(value);
-            }
-        }
-    }
-    static if (hasSlicing!R)
-    {
-        auto opSlice(size_t i, size_t j)
-        in
-        {
-            assert(i <= j);
-            assert(j <= length);
-        }
-        do
-        {
-            return take(this.source[i .. j], length);
-        }
-    }
-}
-
-/**
- * Takes $(D_PARAM n) elements from $(D_PARAM range).
- *
- * If $(D_PARAM range) doesn't have $(D_PARAM n) elements, the resulting range
- * spans all elements of $(D_PARAM range).
- *
- * $(D_PSYMBOL take) is particulary useful with infinite ranges. You can take
- ` $(B n) elements from such range and pass the result to an algorithm which
- * expects a finit range.
- *
- * Params:
- *  R     = Type of the adapted range.
- *  range = The range to take the elements from.
- *  n     = The number of elements to take.
- *
- * Returns: A range containing maximum $(D_PARAM n) first elements of
- *          $(D_PARAM range).
- *
- * See_Also: $(D_PSYMBOL takeExactly).
- */
-auto take(R)(R range, size_t n)
-if (isInputRange!R)
-{
-    struct Take
-    {
-        mixin .Take!(R, false);
-    }
-    return Take(range, n);
-}
-
-/**
- * Takes exactly $(D_PARAM n) elements from $(D_PARAM range).
- *
- * $(D_PARAM range) must have at least $(D_PARAM n) elements.
- *
- * $(D_PSYMBOL takeExactly) is particulary useful with infinite ranges. You can
- ` take $(B n) elements from such range and pass the result to an algorithm
- * which expects a finit range.
- *
- * Params:
- *  R     = Type of the adapted range.
- *  range = The range to take the elements from.
- *  n     = The number of elements to take.
- *
- * Returns: A range containing $(D_PARAM n) first elements of $(D_PARAM range).
- *
- * See_Also: $(D_PSYMBOL take).
- */
-auto takeExactly(R)(R range, size_t n)
-if (isInputRange!R)
-{
-    struct TakeExactly
-    {
-        mixin Take!(R, true);
-    }
-    return TakeExactly(range, n);
-}

source/tanya/range/primitive.d

@@ -813,16 +813,27 @@ template isRandomAccessRange(R)
 /**
  * Puts $(D_PARAM e) into the $(D_PARAM range).
  *
- * $(D_PSYMBOL R) should be an output range for $(D_PARAM E).
- *
- * $(D_PARAM range) is advanced after putting an element into it if all of the
- * following conditions are met:
+ * $(D_PSYMBOL R) should be an output range for $(D_PARAM E). 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:
  *
  * $(OL
- *  $(LI $(D_PSYMBOL R) is an input range)
- *  $(LI $(D_PSYMBOL R) doesn't define a `put`-method)
+ *  $(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))
  *  )
+ * )
+ *
+ * The method to put $(D_PARAM e) into $(D_PARAM range) is chosen based on the
+ * order specified above.
+ *
+ * If $(D_PARAM E) is an input range and $(D_PARAM R) is an output range for
+ * its elements as well, use $(D_PSYMBOL tanya.algorithm.mutation.copy)
+ * instead.
+ *
+ * $(D_PARAM range) is advanced after putting an element into it if it is an
+ * input range that doesn't define a `put`-method.
  *
  * Params:
  *  R     = Target range type.
@@ -849,15 +860,6 @@ void put(R, E)(ref R range, auto ref E e)
     {
         range(e);
     }
-    else static if (isInputRange!E)
-    {
-        pragma(msg, "Putting an input range into an output range is "
-                  ~ "deprecated. Use tanya.algorithm.mutation.copy instead");
-        for (; !e.empty; e.popFront())
-        {
-            put(range, e.front);
-        }
-    }
     else
     {
         static assert(false, R.stringof ~ " is not an output range for "
@@ -1826,7 +1828,7 @@ template hasMobileElements(R)
  */
 template hasLvalueElements(R)
 {
-    private alias refDg = (ref ElementType!R e) => e;
+    private alias refDg = (ref ElementType!R e) => &e;
 
     static if (isRandomAccessRange!R)
     {
@@ -1884,6 +1886,16 @@ template hasLvalueElements(R)
     static assert(hasLvalueElements!R2);
 }
 
+// Works with non-copyable elements
+@nogc nothrow pure @safe unittest
+{
+    static struct NonCopyable
+    {
+        @disable this(this);
+    }
+    static assert(hasLvalueElements!(NonCopyable[]));
+}
+
 /**
  * Determines whether the elements of $(D_PARAM R) are assignable.
  *