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,30 +7,39 @@ os:
 language: d
 
 d:
-  - dmd-2.082.0
-  - dmd-2.081.2
+- dmd-2.082.1
 
 env:
   matrix:
   - ARCH=x86_64
   - ARCH=x86
 
+matrix:
+  include:
+  - name: "D-Scanner"
+    d: dmd-2.082.1
+    env: DSCANNER=0.5.11
+    os: linux
+
 addons:
   apt:
     packages:
     - gcc-multilib
 
 before_script:
-  - if [ "`$DC --version | head -n 1 | grep 'v2.082.0'`" ]; then
+- if [ "`$DC --version | head -n 1 | grep 'v2.082.1'`" ] &&
+     [ -z "$DSCANNER" ]; then
     export UNITTEST="unittest-cov";
   fi
 
 script:
-  - dub test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC
-  - if [ "$UNITTEST" ] && [ "$ARCH" = "x86_64" ] && [ "$TRAVIS_OS_NAME" = "linux" ];
-    then
-      dub fetch dscanner --version=0.5.10;
-      dub run dscanner -- --styleCheck ./source/;
+- if [ -z "$DSCANNER" ]; then
+    dub test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
+  else
+    dub fetch dscanner --version=$DSCANNER;
+
+    FILES=$(find source -type f);
+    dub run dscanner -- --styleCheck $FILES;
   fi
 
 after_success:

README.md

@@ -25,6 +25,7 @@ Tanya consists of the following packages and (top-level) modules:
 
 * `algorithm`: Collection of generic algorithms.
 * `async`: Event loop (epoll, kqueue and IOCP).
+* `bitmanip`: Bit manipulation.
 * `container`: Queue, Array, Singly and doubly linked lists, Buffers, UTF-8
 string, Set, Hash table.
 * `conv`: This module provides functions for converting between different
@@ -173,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;
@@ -278,6 +278,7 @@ if (isForwardRange!Range && isOrderingComparable!(ElementType!Range))
  * If the ranges have different lengths, they aren't equal.
  *
  * Params:
+ *  pred = Predicate used to compare individual element pairs.
  *  R1   = First range type.
  *  R2   = Second range type.
  *  r1   = First range.
@@ -286,14 +287,16 @@ if (isForwardRange!Range && isOrderingComparable!(ElementType!Range))
  * Returns: $(D_KEYWORD true) if both ranges are equal, $(D_KEYWORD false)
  *          otherwise.
  */
-bool equal(R1, R2)(R1 r1, R2 r2)
-if (allSatisfy!(isInputRange, R1, R2) && is(typeof(r1.front == r2.front)))
+bool equal(alias pred = (auto ref a, auto ref b) => a == b, R1, R2)
+          (R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(pred(r1.front, r2.front)) == bool))
 {
     static if (isDynamicArray!R1
             && is(R1 == R2)
             && __traits(isPOD, ElementType!R1))
     {
-        return cmp(r1, r2) == 0;
+        return tanya.memory.op.equal(r1, r2);
     }
     else
     {
@@ -306,7 +309,7 @@ if (allSatisfy!(isInputRange, R1, R2) && is(typeof(r1.front == r2.front)))
         }
         for (; !r1.empty && !r2.empty; r1.popFront(), r2.popFront())
         {
-            if (r1.front != r2.front)
+            if (!pred(r1.front, r2.front))
             {
                 return false;
             }
@@ -331,3 +334,130 @@ if (allSatisfy!(isInputRange, R1, R2) && is(typeof(r1.front == r2.front)))
     int[3] range2 = [1, 2, 3];
     assert(!equal(range1[], range2[]));
 }
+
+/**
+ * Compares element-wise two ranges for ordering.
+ *
+ * $(D_PSYMBOL compare) returns a negative value if $(D_PARAM r1) is less than
+ * $(D_PARAM r2), a positive value if $(D_PARAM r2) is less than $(D_PARAM r1),
+ * or `0` if $(D_PARAM r1) and $(D_PARAM r2) equal.
+ *
+ * $(D_PSYMBOL compare) iterates both ranges in lockstep. Whichever of them
+ * contains an element that is greater than the respective element at the same
+ * position in the other range is the greater one of the two.
+ *
+ * If one of the ranges becomes empty when iterating, but all elements equal so
+ * far, the range with more elements is the greater one.
+ *
+ * If $(D_PARAM pred) is given, it is used for comparison. $(D_PARAM pred) is
+ * called as $(D_INLINECODE pred(r1.front, r2.front)) and
+ * $(D_INLINECODE pred(r2.front, r1.front)) to perform three-way comparison.
+ * $(D_PARAM pred) should return a $(D_KEYWORD bool).
+ *
+ * If $(D_PARAM pred) is not given, but the element type of $(D_PARAM R1)
+ * defines `opCmp()` for the element type of $(D_PARAM R2), `opCmp()` is used.
+ *
+ * Otherwise the comparison is perfomed using the basic comparison operators.
+ *
+ * Params:
+ *  pred = Predicate used for comparison.
+ *  R1   = First range type.
+ *  R2   = Second range type.
+ *  r1   = First range.
+ *  r2   = Second range.
+ *
+ * Returns: A negative value if $(D_PARAM r1) is less than $(D_PARAM r2), a
+ *          positive value if $D(_PARAM r2) is less than $(D_PARAM r1), `0`
+ *          otherwise.
+ */
+int compare(alias pred, R1, R2)(R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(pred(r1.front, r2.front)) == bool)
+ && is(typeof(pred(r2.front, r1.front)) == bool))
+{
+    alias predImpl = (ref r1, ref r2) {
+        return pred(r2.front, r1.front) - pred(r1.front, r2.front);
+    };
+    return compareImpl!(predImpl, R1, R2)(r1, r2);
+}
+
+/// ditto
+int compare(R1, R2)(R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(r1.front < r2.front || r2.front < r1.front)))
+{
+    static if (is(typeof(r1.front.opCmp(r2.front)) == int))
+    {
+        alias pred = (ref r1, ref r2) => r1.front.opCmp(r2.front);
+    }
+    else
+    {
+        alias pred = (ref r1, ref r2) {
+            return (r2.front < r1.front) - (r1.front < r2.front);
+        };
+    }
+    return compareImpl!(pred, R1, R2)(r1, r2);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(compare("abc", "abc") == 0);
+    assert(compare("abcd", "abc") > 0);
+    assert(compare("ab", "abc") < 0);
+    assert(compare("abc", "abcd") < 0);
+    assert(compare("abc", "ab") > 0);
+    assert(compare("aec", "abc") > 0);
+    assert(compare("aac", "abc") < 0);
+    assert(compare("abc", "aec") < 0);
+    assert(compare("abc", "aab") > 0);
+    assert(compare("aacd", "abc") < 0);
+    assert(compare("abc", "aacd") > 0);
+
+    assert(compare!((a, b) => a > b)("aec", "abc") < 0);
+    assert(compare!((a, b) => a > b)("aac", "abc") > 0);
+}
+
+private int compareImpl(alias pred, R1, R2)(ref R1 r1, ref R2 r2)
+{
+    for (; !r1.empty || !r2.empty; r1.popFront(), r2.popFront())
+    {
+        if (r1.empty)
+        {
+            return -1;
+        }
+        else if (r2.empty)
+        {
+            return 1;
+        }
+        const comparison = pred(r1, r2);
+        if (comparison != 0)
+        {
+            return comparison;
+        }
+    }
+    return 0;
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static struct OpCmp(int value)
+    {
+        int opCmp(OpCmp) @nogc nothrow pure @safe
+        {
+            return value;
+        }
+    }
+    {
+        OpCmp!(-1)[1] range;
+        assert(compare(range[], range[]) < 0);
+    }
+    {
+        OpCmp!1[1] range;
+        assert(compare(range[], range[]) > 0);
+    }
+    {
+        OpCmp!0[1] range;
+        assert(compare(range[], range[]) == 0);
+    }
+}

source/tanya/algorithm/iteration.d

@@ -407,3 +407,172 @@ if (isInputRange!R)
         assert(slice.back == 3);
     }
 }
+
+/**
+ * Iterates a bidirectional range backwards.
+ *
+ * If $(D_PARAM Range) is a random-access range as well, the resulting range
+ * is a random-access range too.
+ *
+ * Params:
+ *  Range = Bidirectional range type.
+ *  range = Bidirectional range.
+ *
+ * Returns: Bidirectional range with the elements order reversed.
+ */
+auto retro(Range)(Range range)
+if (isBidirectionalRange!Range)
+{
+    static struct Retro
+    {
+        Range source;
+
+        @disable this();
+
+        private this(Range source)
+        {
+            this.source = source;
+        }
+
+        Retro save()
+        {
+            return this;
+        }
+
+        @property auto ref front()
+        in (!empty)
+        {
+            return this.source.back;
+        }
+
+        void popFront()
+        in (!empty)
+        {
+            this.source.popBack();
+        }
+
+        @property auto ref back()
+        in (!empty)
+        {
+            return this.source.front;
+        }
+
+        void popBack()
+        in (!empty)
+        {
+            this.source.popFront();
+        }
+
+        @property bool empty()
+        {
+            return this.source.empty;
+        }
+
+        static if (hasLength!Range)
+        {
+            @property size_t length()
+            {
+                return this.source.length;
+            }
+        }
+
+        static if (isRandomAccessRange!Range && hasLength!Range)
+        {
+            auto ref opIndex(size_t i)
+            in (i < length)
+            {
+                return this.source[$ - ++i];
+            }
+        }
+
+        static if (hasAssignableElements!Range)
+        {
+            @property void front(ref ElementType!Range value)
+            in (!empty)
+            {
+                this.source.back = value;
+            }
+
+            @property void front(ElementType!Range value)
+            in (!empty)
+            {
+                this.source.back = move(value);
+            }
+
+            @property void back(ref ElementType!Range value)
+            in (!empty)
+            {
+                this.source.front = value;
+            }
+
+            @property void back(ElementType!Range value)
+            in (!empty)
+            {
+                this.source.front = move(value);
+            }
+
+            static if (isRandomAccessRange!Range && hasLength!Range)
+            {
+                void opIndexAssign(ref ElementType!Range value, size_t i)
+                in (i < length)
+                {
+                    this.source[$ - ++i] = value;
+                }
+
+                void opIndexAssign(ElementType!Range value, size_t i)
+                in (i < length)
+                {
+                    this.source[$ - ++i] = move(value);
+                }
+            }
+        }
+    }
+
+    return Retro(range);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[3] given = [1, 2, 3];
+    const int[3] expected = [3, 2, 1];
+
+    auto actual = retro(given[]);
+
+    assert(actual.length == expected.length);
+    assert(!actual.empty);
+    assert(equal(actual, expected[]));
+}
+
+// Elements are accessible in reverse order
+@nogc nothrow pure @safe unittest
+{
+    const int[3] given = [1, 2, 3];
+    auto actual = retro(given[]);
+
+    assert(actual.back == given[].front);
+    assert(actual[0] == 3);
+    assert(actual[2] == 1);
+
+    actual.popBack();
+    assert(actual.back == 2);
+    assert(actual[1] == 2);
+}
+
+// Elements can be assigned
+@nogc nothrow pure @safe unittest
+{
+    int[4] given = [1, 2, 3, 4];
+    auto actual = retro(given[]);
+
+    actual.front = 5;
+    assert(given[].back == 5);
+
+    actual.back = 8;
+    assert(given[].front == 8);
+
+    actual[2] = 10;
+    assert(given[1] == 10);
+}

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/async/event/iocp.d

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

source/tanya/async/event/selector.d

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

source/tanya/async/loop.d

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

source/tanya/bitmanip.d

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

source/tanya/container/array.d

@@ -15,19 +15,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
@@ -1554,14 +1541,14 @@ struct Array(T)
 {
     struct MutableEqualsStruct
     {
-        int opEquals(typeof(this) that) @nogc nothrow pure @safe
+        bool opEquals(typeof(this) that) @nogc nothrow pure @safe
         {
             return true;
         }
     }
     struct ConstEqualsStruct
     {
-        int opEquals(const typeof(this) that) const @nogc nothrow pure @safe
+        bool opEquals(const typeof(this) that) const @nogc nothrow pure @safe
         {
             return true;
         }
@@ -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/hashtable.d

@@ -386,7 +386,7 @@ struct ByValue(T)
  *  hasher = Hash function for $(D_PARAM Key).
  */
 struct HashTable(Key, Value, alias hasher = hash)
-if (is(typeof(((Key k) => hasher(k))(Key.init)) == size_t))
+if (isHashFunction!(hasher, Key))
 {
     private alias HashArray = .HashArray!(hasher, Key, Value);
     private alias Buckets = HashArray.Buckets;

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/set.d

@@ -154,7 +154,7 @@ struct Range(T)
  *  hasher = Hash function for $(D_PARAM T).
  */
 struct Set(T, alias hasher = hash)
-if (is(typeof(((T x) => hasher(x))(T.init)) == size_t))
+if (isHashFunction!(hasher, T))
 {
     private alias HashArray = .HashArray!(hasher, T);
     private alias Buckets = HashArray.Buckets;
@@ -768,8 +768,8 @@ if (is(typeof(((T x) => hasher(x))(T.init)) == size_t))
     testFunc(set);
 }
 
+// Hasher can take argument by ref
 @nogc nothrow pure @safe unittest
 {
-    // Using hasher that takes argument by ref.
-    Set!(int, (const ref x) => cast(size_t)x) set;
+    static assert(is(Set!(int, (const ref x) => cast(size_t) x)));
 }

source/tanya/container/string.d

@@ -26,9 +26,7 @@
  */
 module tanya.container.string;
 
-import std.algorithm.comparison : cmp;
 import std.algorithm.mutation : bringToFront;
-import std.algorithm.searching;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.hash.lookup;
@@ -1284,14 +1282,14 @@ struct String
     int opCmp(S)(auto ref S that) const @trusted
     if (is(Unqual!S == String))
     {
-        return cmp(this.data[0 .. length], that.data[0 .. that.length]);
+        return compare(this.data[0 .. length], that.data[0 .. that.length]);
     }
 
     /// ditto
     int opCmp(S)(ByCodeUnit!S that) const @trusted
     if (is(Unqual!S == char))
     {
-        return cmp(this.data[0 .. length],
+        return compare(this.data[0 .. length],
                        that.begin[0 .. that.end - that.begin]);
     }
 
@@ -1299,14 +1297,14 @@ struct String
     int opCmp(S)(ByCodePoint!S that) const @trusted
     if (is(Unqual!S == char))
     {
-        return cmp(this.data[0 .. length],
+        return compare(this.data[0 .. length],
                        that.begin[0 .. that.end - that.begin]);
     }
 
     /// ditto
     int opCmp()(const char[] that) const @trusted
     {
-        return cmp(this.data[0 .. length], that);
+        return compare(this.data[0 .. length], that);
     }
 
     ///
@@ -1486,6 +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/functional.d

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

source/tanya/hash/lookup.d

@@ -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");
@@ -636,3 +641,27 @@ static if (size_t.sizeof == 8) @nogc nothrow pure @safe unittest
     assert(hash(r500!"~") == 0xc1af12bdfe16b5b5UL);
     assert(hash(r500!"\x7f") == 0x39e9f18f2f85e221UL);
 }
+
+/**
+ * Determines whether $(D_PARAM hasher) is hash function for $(D_PARAM T), i.e.
+ * it is callable with a value of type $(D_PARAM T) and returns a
+ * $(D_PSYMBOL size_t) value.
+ *
+ * Params:
+ *  hasher = Hash function candidate.
+ *  T      = Type to test the hash function with.
+ *
+ * Returns: $(D_KEYWORD true) if $(D_PARAM hasher) is a hash function for
+ *          $(D_PARAM T), $(D_KEYWORD false) otherwise.
+ */
+template isHashFunction(alias hasher, T)
+{
+    private alias wrapper = (T x) => hasher(x);
+    enum bool isHashFunction = is(typeof(wrapper(T.init)) == size_t);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static assert(isHashFunction!(hash, int));
+}

source/tanya/math/mp.d

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

source/tanya/math/random.d

@@ -15,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/meta/trait.d

@@ -1601,7 +1601,7 @@ if (is(T == class) || is(T == struct) || is(T == union))
 }
 
 ///
-pure nothrow @safe unittest
+@nogc pure nothrow @safe unittest
 {
     static struct S
     {
@@ -2613,14 +2613,23 @@ if (is(T == enum))
         }
         else
         {
-            alias getEnumMembers = AliasSeq!(__traits(getMember, T, Args[0]), getEnumMembers!(Args[1 .. $]));
+            alias getEnumMembers = AliasSeq!(__traits(getMember, T, Args[0]),
+                                             getEnumMembers!(Args[1 .. $]));
         }
     }
-    alias EnumMembers = getEnumMembers!(__traits(allMembers, T));
+    private alias allMembers = AliasSeq!(__traits(allMembers, T));
+    static if (allMembers.length == 1)
+    {
+        alias EnumMembers = AliasSeq!(__traits(getMember, T, allMembers));
+    }
+    else
+    {
+        alias EnumMembers = getEnumMembers!allMembers;
+    }
 }
 
 ///
-pure nothrow @nogc @safe unittest
+@nogc nothrow pure @safe unittest
 {
     enum E : int
     {
@@ -2628,7 +2637,17 @@ pure nothrow @nogc @safe unittest
         two,
         three,
     }
-    static assert([E.one, E.two, E.three] == [ EnumMembers!E ]);
+    static assert([EnumMembers!E] == [E.one, E.two, E.three]);
+}
+
+// Produces a tuple for an enum with only one member
+@nogc nothrow pure @safe unittest
+{
+    enum E : int
+    {
+        one = 0,
+    }
+    static assert(EnumMembers!E == AliasSeq!0);
 }
 
 /**

source/tanya/net/ip.d

@@ -14,6 +14,7 @@
  */
 module tanya.net.ip;
 
+import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.container.string;
 import tanya.conv;
@@ -66,6 +67,37 @@ struct Address4
         assert(Address4(0x00202000U).toUInt() == 0x00202000U);
     }
 
+    /**
+     * Compares two $(D_PARAM Address4) objects.
+     *
+     * Params:
+     *  that = Another address.
+     *
+     * Returns: Positive number if $(D_KEYWORD this) is larger than
+     *          $(D_PARAM that), negative - if it is smaller, or 0 if they
+     *          equal.
+     */
+    int opCmp(ref const Address4 that) const @nogc nothrow pure @safe
+    {
+        const lhs = toUInt();
+        const rhs = that.toUInt();
+        return (rhs < lhs) - (lhs < rhs);
+    }
+
+    /// ditto
+    int opCmp(const Address4 that) const @nogc nothrow pure @safe
+    {
+        return opCmp(that);
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(address4("127.0.0.1") > address4("126.0.0.0"));
+        assert(address4("127.0.0.1") < address4("127.0.0.2"));
+        assert(address4("127.0.0.1") == address4("127.0.0.1"));
+    }
+
     /**
      * Returns object that represents 127.0.0.1.
      *
@@ -423,6 +455,45 @@ struct Address6
         assert(actual.scopeID == 1);
     }
 
+    /**
+     * Compares two $(D_PARAM Address6) objects.
+     *
+     * If $(D_KEYWORD this) and $(D_PARAM that) contain the same address, scope
+     * IDs are compared.
+     *
+     * Params:
+     *  that = Another address.
+     *
+     * Returns: Positive number if $(D_KEYWORD this) is larger than
+     *          $(D_PARAM that), negative - if it is smaller, or 0 if they
+     *          equal.
+     */
+    int opCmp(ref const Address6 that) const @nogc nothrow pure @safe
+    {
+        const diff = compare(this.address[], that.address[]);
+        if (diff == 0)
+        {
+            return (that.scopeID < this.scopeID) - (this.scopeID < that.scopeID);
+        }
+        return diff;
+    }
+
+    /// ditto
+    int opCmp(const Address6 that) const @nogc nothrow pure @safe
+    {
+        return opCmp(that);
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        assert(address6("::14") > address6("::1"));
+        assert(address6("::1") < address6("::14"));
+        assert(address6("::1") == address6("::1"));
+        assert(address6("fe80::1%1") < address6("fe80::1%2"));
+        assert(address6("fe80::1%2") > address6("fe80::1%1"));
+    }
+
     /**
      * Returns object that represents ::.
      *
@@ -645,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.
@@ -675,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
@@ -693,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)();
             }
@@ -711,6 +795,7 @@ if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
                 goto ParseTail;
             }
         }
+    }
     write2Bytes(range, result.address[14 .. $]);
 
     if (range.empty)
@@ -739,6 +824,9 @@ ParseTail: // after ::
     {
         return typeof(return)();
     }
+    { // To make "state" definition local
+        auto state = range.save();
+
         write2Bytes(range, tail[j .. $]);
         if (range.empty)
         {
@@ -748,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)
@@ -770,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)
@@ -836,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.
  *

source/tanya/typecons.d

@@ -19,6 +19,7 @@ module tanya.typecons;
 
 import tanya.algorithm.mutation;
 import tanya.format;
+import tanya.functional;
 import tanya.meta.metafunction;
 import tanya.meta.trait;
 
@@ -35,6 +36,8 @@ import tanya.meta.trait;
  *
  * Params:
  *  Specs = Field types and names.
+ *
+ * See_Also: $(D_PSYMBOL tuple).
  */
 template Tuple(Specs...)
 {
@@ -133,11 +136,50 @@ template Tuple(Specs...)
     static assert(!is(Tuple!(int, "first", double, "second", char, "third")));
 }
 
+/**
+ * Creates a new $(D_PSYMBOL Tuple).
+ *
+ * Params:
+ *  Names = Field names.
+ *
+ * See_Also: $(D_PSYMBOL Tuple).
+ */
+template tuple(Names...)
+{
+    /**
+     * Creates a new $(D_PSYMBOL Tuple).
+     *
+     * Params:
+     *  Args = Field types.
+     *  args = Field values.
+     *
+     * Returns: Newly created $(D_PSYMBOL Tuple).
+     */
+    auto tuple(Args...)(auto ref Args args)
+    if (Args.length >= Names.length && isTypeTuple!Args)
+    {
+        alias Zipped = ZipWith!(AliasSeq, Pack!Args, Pack!Names);
+        alias Nameless = Args[Names.length .. $];
+
+        return Tuple!(Zipped, Nameless)(forward!args);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    auto t = tuple!("one", "two")(20, 5);
+    assert(t.one == 20);
+    assert(t.two == 5);
+}
+
 /**
  * $(D_PSYMBOL Option) is a type that contains an optional value.
  *
  * Params:
  *  T = Type of the encapsulated value.
+ *
+ * See_Also: $(D_PSYMBOL option).
  */
 struct Option(T)
 {
@@ -338,6 +380,24 @@ struct Option(T)
         return this;
     }
 
+    version (D_Ddoc)
+    {
+        /**
+         * If $(D_PARAM T) has a `toHash()` method, $(D_PSYMBOL Option) defines
+         * `toHash()` which returns `T.toHash()` if it is set or 0 otherwise.
+         *
+         * Returns: Hash value.
+         */
+        size_t toHash() const;
+    }
+    else static if (is(typeof(T.init.toHash()) == size_t))
+    {
+        size_t toHash() const
+        {
+            return isNothing ? 0U : this.value.toHash();
+        }
+    }
+
     alias get this;
 }
 
@@ -452,3 +512,50 @@ struct Option(T)
         assert(((ref e) => e)(Option!int().or(i)) == 5);
     }
 }
+
+// Implements toHash() for nothing
+@nogc nothrow pure @safe unittest
+{
+    static struct ToHash
+    {
+        size_t toHash() const @nogc nothrow pure @safe
+        {
+            return 1U;
+        }
+    }
+    {
+        Option!ToHash toHash;
+        assert(toHash.toHash() == 0U);
+    }
+    {
+        auto toHash = Option!ToHash(ToHash());
+        assert(toHash.toHash() == 1U);
+    }
+}
+
+/**
+ * Creates a new $(D_PSYMBOL Option).
+ *
+ * Params:
+ *  T     = Option type.
+ *  value = Initial value.
+ *
+ * See_Also: $(D_PSYMBOL Option).
+ */
+Option!T option(T)(auto ref T value)
+{
+    return Option!T(forward!value);
+}
+
+/// ditto
+Option!T option(T)()
+{
+    return Option!T();
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    assert(option!int().isNothing);
+    assert(option(5) == 5);
+}