Add algorithm.iteration

Create separate travis job for D-Scanner
net.ip: Implement opCmp. Fix #63
2018-09-28 05:40:33 +02:00 · 2018-09-26 06:30:05 +02:00 · 2018-09-24 06:45:44 +02:00 · 2018-09-23 06:59:41 +02:00 · 2018-09-22 07:32:30 +02:00 · 2018-09-21 06:23:59 +02:00
42 changed files with 3825 additions and 348 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,39 +1,47 @@
 sudo: false

 os:
-  - linux
-  - osx
+- linux
+- osx

 language: d

 d:
-  - dmd-2.081.0
-  - dmd-2.080.1
-  - dmd-2.079.1
-  - dmd-2.078.3
+- dmd-2.082.0
+- dmd-2.081.2

 env:
  matrix:
-    - ARCH=x86_64
-    - ARCH=x86
+  - ARCH=x86_64
+  - ARCH=x86
+
+matrix:
+  include:
+  - name: "D-Scanner"
+    d: dmd-2.082.0
+    env: DSCANNER=0.5.10
+    os: linux

 addons:
  apt:
    packages:
-      - gcc-multilib
+    - gcc-multilib

 before_script:
-  - if [ "`$DC --version | head -n 1 | grep 'v2.081.0'`" ]; then
-      export UNITTEST="unittest-cov";
-    fi
+- if [ "`$DC --version | head -n 1 | grep 'v2.082.0'`" ] &&
+     [ -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;
-      dub run dscanner -- --styleCheck ./source/;
-    fi
+- 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:
-  - test "$UNITTEST" && bash <(curl -s https://codecov.io/bash)
+- test "$UNITTEST" && bash <(curl -s https://codecov.io/bash)
--- a/README.md
+++ b/README.md
@ -25,6 +25,7 @@ Tanya consists of the following packages and (top-level) modules:

 * `algorithm`: Collection of generic algorithms.
 * `async`: Event loop (epoll, kqueue and IOCP).
+* `bitmanip`: Bit manipulation.
 * `container`: Queue, Array, Singly and doubly linked lists, Buffers, UTF-8
 string, Set, Hash table.
 * `conv`: This module provides functions for converting between different
@ -172,12 +173,10 @@ parameter is used)

 ### Supported compilers

-| DMD     | GCC       |
-|:-------:|:---------:|
-| 2.081.1 | *master*  |
-| 2.080.1 |           |
-| 2.079.1 |           |
-| 2.078.3 |           |
+| DMD     | GCC    |
+|:-------:|:------:|
+| 2.082.0 | gdc-8  |
+| 2.081.2 | gdc-7  |

 ### Release management

--- a/appveyor.yml
+++ b/appveyor.yml
@ -4,28 +4,16 @@ os: Visual Studio 2015
 environment:
  matrix:
    - DC: dmd
-      DVersion: 2.081.1
+      DVersion: 2.082.0
      arch: x64
    - DC: dmd
-      DVersion: 2.081.1
+      DVersion: 2.082.0
      arch: x86
    - DC: dmd
-      DVersion: 2.080.1
+      DVersion: 2.081.2
      arch: x64
    - DC: dmd
-      DVersion: 2.080.1
-      arch: x86
-    - DC: dmd
-      DVersion: 2.079.1
-      arch: x64
-    - DC: dmd
-      DVersion: 2.079.1
-      arch: x86
-    - DC: dmd
-      DVersion: 2.078.3
-      arch: x64
-    - DC: dmd
-      DVersion: 2.078.3
+      DVersion: 2.081.2
      arch: x86

 skip_tags: true
@ -46,7 +34,7 @@ install:
 before_build:
  - ps: if($env:arch -eq "x86"){
          $env:compilersetupargs = "x86";
-          $env:Darch = "x86";
+          $env:Darch = "x86_mscoff";
        }
        elseif($env:arch -eq "x64"){
          $env:compilersetupargs = "amd64";
--- a/arch/x64/linux/memory/cmp.S
+++ b/arch/x64/linux/memory/cmp.S
@ -8,10 +8,9 @@
 * rdx - r2 length.
 * rcx - r2 data.
 */
-	.globl _D5tanya6memory2op9cmpMemoryFNaNbNixAvxAvZi
-	.type _D5tanya6memory2op9cmpMemoryFNaNbNixAvxAvZi, @function
-
-_D5tanya6memory2op9cmpMemoryFNaNbNixAvxAvZi:
+	.globl _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi
+	.type _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi, @function
+_D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi:
 		// Compare the lengths
 		cmp %rdx, %rdi
 		jl  less
--- a/arch/x64/linux/syscall.S
+++ b/arch/x64/linux/syscall.S
@ -11,10 +11,11 @@ The returned value is placed in %rax.
 */
 	.text

-	.globl syscall1
-	.type syscall1, @function
+// 1 parameter.
+	.globl _D5tanya3sys5linux7syscallQiFNbNillZl
+	.type _D5tanya3sys5linux7syscallQiFNbNillZl, @function

-syscall1:
+_D5tanya3sys5linux7syscallQiFNbNillZl:
 	movq %rsi, %rax // Syscall number.

 	syscall
@ -23,10 +24,10 @@ syscall1:


 // 2 parameters.
-	.globl _D5tanya3sys5linux7syscall7syscallFNbNilllZl
-	.type _D5tanya3sys5linux7syscall7syscallFNbNilllZl, @function
+	.globl _D5tanya3sys5linux7syscallQiFNbNilllZl
+	.type _D5tanya3sys5linux7syscallQiFNbNilllZl, @function

-_D5tanya3sys5linux7syscall7syscallFNbNilllZl:
+_D5tanya3sys5linux7syscallQiFNbNilllZl:
 	movq %rdx, %rax

 	syscall
@ -34,11 +35,23 @@ _D5tanya3sys5linux7syscall7syscallFNbNilllZl:
 	ret


-// 6 parameters.
-	.globl _D5tanya3sys5linux7syscall7syscallFNbNilllllllZl
-	.type _D5tanya3sys5linux7syscall7syscallFNbNilllllllZl, @function
+// 3 parameters.
+	.globl _D5tanya3sys5linux7syscallQiFNbNillllZl
+	.type _D5tanya3sys5linux7syscallQiFNbNillllZl, @function

-_D5tanya3sys5linux7syscall7syscallFNbNilllllllZl:
+_D5tanya3sys5linux7syscallQiFNbNillllZl:
+	movq %rcx, %rax
+
+	syscall
+
+	ret
+
+
+// 6 parameters.
+	.globl _D5tanya3sys5linux7syscallQiFNbNilllllllZl
+	.type _D5tanya3sys5linux7syscallQiFNbNilllllllZl, @function
+
+_D5tanya3sys5linux7syscallQiFNbNilllllllZl:
 	pushq %rbp
 	movq %rsp, %rbp

--- a/dub.json
+++ b/dub.json
@ -34,5 +34,7 @@
 		}
 	],

-	"libs-windows": ["advapi32"]
+	"libs-windows": ["advapi32"],
+	"libs-windows-x86_mscoff": ["iphlpapi"],
+	"libs-windows-x86_64": ["iphlpapi"]
 }
--- a/source/tanya/algorithm/comparison.d
+++ b/source/tanya/algorithm/comparison.d
@ -278,16 +278,19 @@ if (isForwardRange!Range && isOrderingComparable!(ElementType!Range))
 * If the ranges have different lengths, they aren't equal.
 *
 * Params:
- *  R1 = First range type.
- *  R2 = Second range type.
- *  r1 = First range.
- *  r2 = Second range.
+ *  pred = Predicate used to compare individual element pairs.
+ *  R1   = First range type.
+ *  R2   = Second range type.
+ *  r1   = First range.
+ *  r2   = Second range.
 *
 * Returns: $(D_KEYWORD true) if both ranges are equal, $(D_KEYWORD false)
 *          otherwise.
 */
-bool equal(R1, R2)(R1 r1, R2 r2)
-if (allSatisfy!(isInputRange, R1, R2) && is(typeof(r1.front == r2.front)))
+bool equal(alias pred = (auto ref a, auto ref b) => a == b, R1, R2)
+          (R1 r1, R2 r2)
+if (allSatisfy!(isInputRange, R1, R2)
+ && is(typeof(pred(r1.front, r2.front)) == bool))
 {
    static if (isDynamicArray!R1
            && is(R1 == R2)
@ -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);
+    }
+}
--- a/source/tanya/algorithm/iteration.d
+++ b/source/tanya/algorithm/iteration.d
@ -0,0 +1,578 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Range 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).
+ * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
+ * Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/algorithm/iteration.d,
+ *                 tanya/algorithm/iteration.d)
+ */
+module tanya.algorithm.iteration;
+
+import tanya.algorithm.comparison;
+import tanya.algorithm.mutation;
+import tanya.range;
+
+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);
+            }
+        }
+    }
+}
+
+/**
+ * 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)
+{
+    static struct Take
+    {
+        mixin .Take!(R, false);
+
+        static if (hasSlicing!R)
+        {
+            auto opSlice(size_t i, size_t j)
+            in
+            {
+                assert(i <= j);
+                assert(j <= length);
+            }
+            do
+            {
+                return typeof(this)(this.source[i .. j], length);
+            }
+        }
+    }
+    return Take(range, n);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static struct InfiniteRange
+    {
+        private size_t front_ = 1;
+
+        enum bool empty = false;
+
+        @property size_t front() @nogc nothrow pure @safe
+        {
+            return this.front_;
+        }
+
+        @property void front(size_t i) @nogc nothrow pure @safe
+        {
+            this.front_ = i;
+        }
+
+        void popFront() @nogc nothrow pure @safe
+        {
+            ++this.front_;
+        }
+
+        size_t opIndex(size_t i) @nogc nothrow pure @safe
+        {
+            return this.front_ + i;
+        }
+
+        void opIndexAssign(size_t value, size_t i) @nogc nothrow pure @safe
+        {
+            this.front = i + value;
+        }
+
+        InfiniteRange save() @nogc nothrow pure @safe
+        {
+            return this;
+        }
+    }
+
+    auto t = InfiniteRange().take(3);
+    assert(t.length == 3);
+    assert(t.front == 1);
+    assert(t.back == 3);
+
+    t.popFront();
+    assert(t.front == 2);
+    assert(t.back == 3);
+
+    t.popBack();
+    assert(t.front == 2);
+    assert(t.back == 2);
+
+    t.popFront();
+    assert(t.empty);
+}
+
+/**
+ * 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)
+{
+    static if (hasSlicing!R)
+    {
+        return range[0 .. n];
+    }
+    else
+    {
+        static struct TakeExactly
+        {
+            mixin Take!(R, true);
+        }
+        return TakeExactly(range, n);
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static struct InfiniteRange
+    {
+        private size_t front_ = 1;
+
+        enum bool empty = false;
+
+        @property size_t front() @nogc nothrow pure @safe
+        {
+            return this.front_;
+        }
+
+        @property void front(size_t i) @nogc nothrow pure @safe
+        {
+            this.front_ = i;
+        }
+
+        void popFront() @nogc nothrow pure @safe
+        {
+            ++this.front_;
+        }
+
+        size_t opIndex(size_t i) @nogc nothrow pure @safe
+        {
+            return this.front_ + i;
+        }
+
+        void opIndexAssign(size_t value, size_t i) @nogc nothrow pure @safe
+        {
+            this.front = i + value;
+        }
+
+        InfiniteRange save() @nogc nothrow pure @safe
+        {
+            return this;
+        }
+    }
+
+    auto t = InfiniteRange().takeExactly(3);
+    assert(t.length == 3);
+    assert(t.front == 1);
+    assert(t.back == 3);
+
+    t.popFront();
+    assert(t.front == 2);
+    assert(t.back == 3);
+
+    t.popBack();
+    assert(t.front == 2);
+    assert(t.back == 2);
+
+    t.popFront();
+    assert(t.empty);
+}
+
+// Takes minimum length if the range length > n
+@nogc nothrow pure @safe unittest
+{
+    auto range = take(cast(int[]) null, 8);
+    assert(range.length == 0);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    const int[9] range = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    {
+        auto slice = take(range[], 8)[1 .. 3];
+
+        assert(slice.length == 2);
+        assert(slice.front == 2);
+        assert(slice.back == 3);
+    }
+    {
+        auto slice = takeExactly(range[], 8)[1 .. 3];
+
+        assert(slice.length == 2);
+        assert(slice.front == 2);
+        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);
+}
--- a/source/tanya/algorithm/mutation.d
+++ b/source/tanya/algorithm/mutation.d
@ -14,8 +14,10 @@
 */
 module tanya.algorithm.mutation;

-import tanya.memory.op;
+static import tanya.memory.op;
 import tanya.meta.trait;
+import tanya.meta.transform;
+import tanya.range;

 private void deinitialize(bool zero, T)(ref T value)
 {
@ -39,11 +41,12 @@ private void deinitialize(bool zero, T)(ref T value)
        }
        static if (zero)
        {
-            fill!0((cast(void*) &value)[0 .. size]);
+            tanya.memory.op.fill!0((cast(void*) &value)[0 .. size]);
        }
        else
        {
-            copy(typeid(T).initializer()[0 .. size], (&value)[0 .. 1]);
+            tanya.memory.op.copy(typeid(T).initializer()[0 .. size],
+                                 (&value)[0 .. 1]);
        }
    }
 }
@ -81,7 +84,7 @@ do
 {
    static if (is(T == struct) || isStaticArray!T)
    {
-        copy((&source)[0 .. 1], (&target)[0 .. 1]);
+        tanya.memory.op.copy((&source)[0 .. 1], (&target)[0 .. 1]);

        static if (hasElaborateCopyConstructor!T || hasElaborateDestructor!T)
        {
@ -273,3 +276,115 @@ void swap(T)(ref T a, ref T b) @trusted
    assert(a == 5);
    assert(b == 3);
 }
+
+/**
+ * Copies the $(D_PARAM source) range into the $(D_PARAM target) range.
+ *
+ * Params:
+ *  Source = Input range type.
+ *  Target = Output range type.
+ *  source = Source input range.
+ *  target = Target output range.
+ *
+ * Returns: $(D_PARAM target) range, whose front element is the one past the
+ *          last element copied.
+ *
+ * Precondition: $(D_PARAM target) should be large enough to accept all
+ *               $(D_PARAM source) elements.
+ */
+Target copy(Source, Target)(Source source, Target target)
+if (isInputRange!Source && isOutputRange!(Target, Source))
+in
+{
+    static if (hasLength!Source && hasLength!Target)
+    {
+        assert(target.length >= source.length);
+    }
+}
+do
+{
+    alias E = ElementType!Source;
+    static if (isDynamicArray!Source
+            && is(Unqual!E == ElementType!Target)
+            && !hasElaborateCopyConstructor!E
+            && !hasElaborateAssign!E
+            && !hasElaborateDestructor!E)
+    {
+        if (source.ptr < target.ptr
+         && (() @trusted => (target.ptr - source.ptr) < source.length)())
+        {
+            tanya.memory.op.copyBackward(source, target);
+        }
+        else if (source.ptr !is target.ptr)
+        {
+            tanya.memory.op.copy(source, target);
+        }
+        return target[source.length .. $];
+    }
+    else
+    {
+        for (; !source.empty; source.popFront())
+        {
+            put(target, source.front);
+        }
+        return target;
+    }
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    const int[2] source = [1, 2];
+    int[2] target = [3, 4];
+
+    copy(source[], target[]);
+    assert(equal(source[], target[]));
+}
+
+// Returns advanced target
+@nogc nothrow pure @safe unittest
+{
+    int[5] input = [1, 2, 3, 4, 5];
+    assert(copy(input[3 .. 5], input[]).front == 3);
+}
+
+// Copies overlapping arrays
+@nogc nothrow pure @safe unittest
+{
+    import tanya.algorithm.comparison : equal;
+
+    int[6] actual = [1, 2, 3, 4, 5, 6];
+    const int[6] expected = [1, 2, 1, 2, 3, 4];
+
+    copy(actual[0 .. 4], actual[2 .. 6]);
+    assert(equal(actual[], expected[]));
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(typeof(copy((ubyte[]).init, (ushort[]).init))));
+    static assert(!is(typeof(copy((ushort[]).init, (ubyte[]).init))));
+}
+
+@nogc nothrow pure @safe unittest
+{
+    static struct OutPutRange
+    {
+        int value;
+        void put(int value) @nogc nothrow pure @safe
+        in
+        {
+            assert(this.value == 0);
+        }
+        do
+        {
+            this.value = value;
+        }
+    }
+    int[1] source = [5];
+    OutPutRange target;
+
+    assert(copy(source[], target).value == 5);
+}
--- a/source/tanya/algorithm/package.d
+++ b/source/tanya/algorithm/package.d
@ -15,4 +15,5 @@
 module tanya.algorithm;

 public import tanya.algorithm.comparison;
+public import tanya.algorithm.iteration;
 public import tanya.algorithm.mutation;
--- a/source/tanya/async/event/iocp.d
+++ b/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);
--- a/source/tanya/async/event/selector.d
+++ b/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);
        }

--- a/source/tanya/async/loop.d
+++ b/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;
--- a/source/tanya/bitmanip.d
+++ b/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));
+}
--- a/source/tanya/container/array.d
+++ b/source/tanya/container/array.d
@ -1554,14 +1554,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;
        }
--- a/source/tanya/container/hashtable.d
+++ b/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;
--- a/source/tanya/container/set.d
+++ b/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(hasher(T.init)) == size_t))
+if (isHashFunction!(hasher, T))
 {
    private alias HashArray = .HashArray!(hasher, T);
    private alias Buckets = HashArray.Buckets;
@ -767,3 +767,9 @@ if (is(typeof(hasher(T.init)) == size_t))
    }
    testFunc(set);
 }
+
+// Hasher can take argument by ref
+@nogc nothrow pure @safe unittest
+{
+    static assert(is(Set!(int, (const ref x) => cast(size_t) x)));
+}
--- a/source/tanya/container/string.d
+++ b/source/tanya/container/string.d
@ -26,9 +26,8 @@
 */
 module tanya.container.string;

-import std.algorithm.comparison : cmp;
-import std.algorithm.mutation : bringToFront, copy;
-import std.algorithm.searching;
+import std.algorithm.mutation : bringToFront;
+import std.algorithm.searching : count;
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
 import tanya.hash.lookup;
@ -1284,29 +1283,29 @@ struct String
    int opCmp(S)(auto ref S that) const @trusted
    if (is(Unqual!S == String))
    {
-        return cmp(this.data[0 .. length], that.data[0 .. that.length]);
+        return compare(this.data[0 .. length], that.data[0 .. that.length]);
    }

    /// ditto
    int opCmp(S)(ByCodeUnit!S that) const @trusted
    if (is(Unqual!S == char))
    {
-        return cmp(this.data[0 .. length],
-                   that.begin[0 .. that.end - that.begin]);
+        return compare(this.data[0 .. length],
+                       that.begin[0 .. that.end - that.begin]);
    }

    /// ditto
    int opCmp(S)(ByCodePoint!S that) const @trusted
    if (is(Unqual!S == char))
    {
-        return cmp(this.data[0 .. length],
-                   that.begin[0 .. that.end - that.begin]);
+        return compare(this.data[0 .. length],
+                       that.begin[0 .. that.end - that.begin]);
    }

    /// ditto
    int opCmp()(const char[] that) const @trusted
    {
-        return cmp(this.data[0 .. length], that);
+        return compare(this.data[0 .. length], that);
    }

    ///
--- a/source/tanya/conv.d
+++ b/source/tanya/conv.d
@ -308,11 +308,11 @@ do
        {
            digit = range.front - 'W';
        }
-        else if (range.front >= 'A')
+        else if (range.front >= 'A' && range.front <= 'Z')
        {
            digit = range.front - '7';
        }
-        else if (range.front >= '0')
+        else if (range.front >= '0' && range.front <= '9')
        {
            digit = range.front - '0';
        }
@ -360,6 +360,15 @@ do
    return n;
 }

+// ':' is not a hex value
+@nogc nothrow pure @safe unittest
+{
+    string colon = ":";
+    auto actual = readIntegral!ubyte(colon, 16);
+    assert(actual == 0);
+    assert(colon.length == 1);
+}
+
 // reads ubyte.max
@nogc nothrow pure @safe unittest
 {
@ -847,35 +856,13 @@ if (is(Unqual!From == bool) && isNumeric!To && !is(Unqual!To == Unqual!From))
    assert(false.to!int == 0);
 }

-/**
- * Converts $(D_PARAM From) to a $(D_PSYMBOL String).
- *
- * Params:
- *  From = Source type.
- *  To   = Target type.
- *  from = Source value.
- *
- * Returns: $(D_PARAM from) converted to $(D_PSYMBOL String).
- */
+deprecated("Use tanya.format.format instead")
 To to(To, From)(auto ref From from)
 if (is(Unqual!To == String))
 {
    return format!"{}"(from);
 }

-///
-@nogc nothrow pure @safe unittest
-{
-    assert(true.to!String == "true");
-    assert(false.to!String == "false");
-}
-
-@nogc nothrow pure @safe unittest
-{
-    static assert(is(typeof((const String("true")).to!bool)));
-    static assert(is(typeof(false.to!(const String) == "false")));
-}
-
 /**
 * Converts a stringish range to an integral value.
 *
--- a/source/tanya/format.d
+++ b/source/tanya/format.d
@ -3,8 +3,32 @@
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /**
- * This package doesn't yet contain public symbols. Refer to
- * $(D_PSYMBOL tanya.conv) for basic formatting and conversion functionality.
+ * This module provides $(D_PSYMBOL format) function that can convert different
+ * data types to a $(D_PSYMBOL String) according to a specified format.
+ *
+ * Format string is a $(D_PSYMBOL string) which can contain placeholders for
+ * arguments. Placeholder marker is `{}`, i.e. all occurrences of `{}` are
+ * replaced by the arguments passed to $(D_PSYMBOL format). An argument will be
+ * first converted to a string, then inserted into the resulting string instead
+ * of the corresponding placeholder. The number of the placeholders and
+ * arguments must match. The placeholders are replaced with the arguments in
+ * the order arguments are passed to $(D_PSYMBOL format).
+ *
+ * To escape `{` or `}`, use `{{` and `}}` respectively. `{{` will be outputted
+ * as a single `{`, `}}` - as a single `}`.
+ *
+ * If a custom data type (like $(D_KEYWORD struct) or $(D_KEYWORD class))
+ * defines a `stringify()` function that is callable without arguments and
+ * returns a $(D_PSYMBOL String), this function is used to produce a string
+ * representation for the value. String conversions for the most built-in
+ * data types a also available.
+ *
+ * $(D_KEYWORD char), $(D_KEYWORD wchar) and $(D_KEYWORD dchar) ranges are
+ * outputted as plain strings (without any delimiters between their elements).
+ *
+ * All floating point numbers are handled as $(D_KEYWORD double)s.
+ *
+ * More advanced formatting is currently not implemented.
 *
 * Copyright: Eugene Wissner 2017-2018.
 * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
@ -1233,7 +1257,7 @@ private uint128 raise2ToExp(double value) @nogc nothrow pure @safe

 private int indexMismatch(ulong low, ulong high) @nogc nothrow pure @safe
 {
-    enum ulong power10 = 10000000000U;
+    enum ulong power10 = 10000000000UL;
    const ulong a = low / power10;
    const ulong b = high / power10;
    int index;
@ -1346,6 +1370,574 @@ do
    assert(e == 26);
 }

+private char[] errolFixed(double value,
+                          return ref char[512] buffer,
+                          out int exponent) @nogc nothrow pure @safe
+in
+{
+    assert(value >= 16.0 && value <= 9.007199254740992e15);
+}
+do
+{
+    auto decimal = cast(ulong) value;
+    auto n = cast(double) decimal;
+
+    double midpoint = value - n;
+    double leftBoundary = (previous(value) - n + midpoint) / 2.0;
+    double rightBoundary = (next(value) - n + midpoint) / 2.0;
+
+    char[21] intBuffer;
+    auto intSlice = integral2String(decimal, intBuffer);
+    copy(intSlice, buffer);
+    exponent = cast(int) intSlice.length;
+
+    size_t position = exponent;
+    if (midpoint != 0.0)
+    {
+        while (midpoint != 0.0)
+        {
+            leftBoundary *= 10.0;
+            const leftDigit = cast(ubyte) leftBoundary;
+            leftBoundary -= leftDigit;
+
+            midpoint *= 10.0;
+            const middleDigit = cast(ubyte) midpoint;
+            midpoint -= middleDigit;
+
+            rightBoundary *= 10.0;
+            const rightDigit = cast(ubyte) rightBoundary;
+            rightBoundary -= rightDigit;
+
+            buffer[position++] = cast(char) (middleDigit + '0');
+
+            if (rightDigit != leftDigit || position > 50)
+            {
+                break;
+            }
+        }
+
+        if (midpoint > 0.5
+         || ((midpoint == 0.5) && (buffer[position - 1] & 0x1)))
+        {
+            ++buffer[position - 1];
+        }
+    }
+    else
+    {
+        for (; buffer[position - 1] == '0'; --position)
+        {
+            buffer[position - 1] = '\0';
+        }
+    }
+
+    return buffer[0 .. position];
+}
+
+@nogc nothrow pure @safe unittest
+{
+    char[512] num;
+    int exponent;
+    {
+        assert(errolFixed(16.0, num, exponent) == "16");
+        assert(exponent == 2);
+    }
+    {
+        assert(errolFixed(38234.1234, num, exponent) == "382341234");
+        assert(exponent == 5);
+    }
+}
+
+private char[] errol3(double value,
+                      return ref char[512] buffer,
+                      out int exponent) @nogc nothrow pure @safe
+{
+    static struct Pathology
+    {
+        ulong representation;
+        string digits;
+        int exponent;
+    }
+
+    static immutable Pathology[432] pathologies = [
+        { 0x001d243f646eaf51, "40526371999771488", -307 },
+        { 0x002d243f646eaf51, "81052743999542975", -307 },
+        { 0x00ab7aa3d73f6658, "1956574196882425", -304 },
+        { 0x00bb7aa3d73f6658, "391314839376485", -304 },
+        { 0x00cb7aa3d73f6658, "78262967875297", -304 },
+        { 0x00f5d15b26b80e30, "4971131903427841", -303 },
+        { 0x010b7aa3d73f6658, "1252207486004752", -302 },
+        { 0x011b7aa3d73f6658, "2504414972009504", -302 },
+        { 0x012b7aa3d73f6658, "5008829944019008", -302 },
+        { 0x0180a0f3c55062c5, "19398723835545928", -300 },
+        { 0x0180a0f3c55062c6, "1939872383554593", -300 },
+        { 0x0190a0f3c55062c5, "38797447671091856", -300 },
+        { 0x0190a0f3c55062c6, "3879744767109186", -300 },
+        { 0x01f393b456eef178, "29232758945460627", -298 },
+        { 0x03719f08ccdccfe5, "44144884605471774", -291 },
+        { 0x037be9d5a60850b5, "69928982131052126", -291 },
+        { 0x03dc25ba6a45de02, "45129663866844427", -289 },
+        { 0x05798e3445512a6e, "27497183057384368", -281 },
+        { 0x05798e3445512a6f, "2749718305738437", -281 },
+        { 0x05898e3445512a6e, "54994366114768736", -281 },
+        { 0x05898e3445512a6f, "5499436611476874", -281 },
+        { 0x06afdadafcacdf85, "17970091719480621", -275 },
+        { 0x06bfdadafcacdf85, "35940183438961242", -275 },
+        { 0x06ceb7f2c53db97f, "69316187906522606", -275 },
+        { 0x06cfdadafcacdf85, "71880366877922484", -275 },
+        { 0x06e8b03fd6894b66, "22283747288943228", -274 },
+        { 0x06f8b03fd6894b66, "44567494577886457", -274 },
+        { 0x07bfe89cf1bd76ac, "23593494977819109", -270 },
+        { 0x07c1707c02068785, "25789638850173173", -270 },
+        { 0x07cfe89cf1bd76ac, "47186989955638217", -270 },
+        { 0x08567a3c8dc4bc9c, "17018905290641991", -267 },
+        { 0x08667a3c8dc4bc9c, "34037810581283983", -267 },
+        { 0x089c25584881552a, "3409719593752201", -266 },
+        { 0x08ac25584881552a, "6819439187504402", -266 },
+        { 0x08dfa7ebe304ee3d, "6135911659254281", -265 },
+        { 0x08dfa7ebe304ee3e, "61359116592542813", -265 },
+        { 0x096822507db6a8fd, "23951010625355228", -262 },
+        { 0x097822507db6a8fd, "47902021250710456", -262 },
+        { 0x09e41934d77659be, "51061856989121905", -260 },
+        { 0x0b8f3d82e9356287, "53263359599109627", -252 },
+        { 0x0c27b35936d56e27, "4137829457097561", -249 },
+        { 0x0c27b35936d56e28, "41378294570975613", -249 },
+        { 0x0c43165633977bc9, "13329597309520689", -248 },
+        { 0x0c43165633977bca, "1332959730952069", -248 },
+        { 0x0c53165633977bc9, "26659194619041378", -248 },
+        { 0x0c53165633977bca, "2665919461904138", -248 },
+        { 0x0c63165633977bc9, "53318389238082755", -248 },
+        { 0x0c63165633977bca, "5331838923808276", -248 },
+        { 0x0c7e9eddbbb259b4, "1710711888535566", -247 },
+        { 0x0c8e9eddbbb259b4, "3421423777071132", -247 },
+        { 0x0c9e9eddbbb259b4, "6842847554142264", -247 },
+        { 0x0e104273b18918b0, "6096109271490509", -240 },
+        { 0x0e104273b18918b1, "609610927149051", -240 },
+        { 0x0e204273b18918b0, "12192218542981019", -239 },
+        { 0x0e204273b18918b1, "1219221854298102", -239 },
+        { 0x0e304273b18918b0, "24384437085962037", -239 },
+        { 0x0e304273b18918b1, "2438443708596204", -239 },
+        { 0x0f1d16d6d4b89689, "7147520638007367", -235 },
+        { 0x0fd6ba8608faa6a8, "2287474118824999", -231 },
+        { 0x0fd6ba8608faa6a9, "22874741188249992", -231 },
+        { 0x0fe6ba8608faa6a8, "4574948237649998", -231 },
+        { 0x0fe6ba8608faa6a9, "45749482376499984", -231 },
+        { 0x1006b100e18e5c17, "18269851255456139", -230 },
+        { 0x1016b100e18e5c17, "36539702510912277", -230 },
+        { 0x104f48347c60a1be, "40298468695006992", -229 },
+        { 0x105f48347c60a1be, "80596937390013985", -229 },
+        { 0x10a4139a6b17b224, "16552474403007851", -227 },
+        { 0x10b4139a6b17b224, "33104948806015703", -227 },
+        { 0x12cb91d317c8ebe9, "39050270537318193", -217 },
+        { 0x13627383c5456c5e, "26761990828289327", -214 },
+        { 0x138fb24e492936f6, "1838927069906671", -213 },
+        { 0x139fb24e492936f6, "3677854139813342", -213 },
+        { 0x13afb24e492936f6, "7355708279626684", -213 },
+        { 0x13f93bb1e72a2033, "18738512510673039", -211 },
+        { 0x14093bb1e72a2033, "37477025021346077", -211 },
+        { 0x1466cc4fc92a0fa6, "21670630627577332", -209 },
+        { 0x1476cc4fc92a0fa6, "43341261255154663", -209 },
+        { 0x148048cb468bc208, "619160875073638", -209 },
+        { 0x149048cb468bc209, "12383217501472761", -208 },
+        { 0x14a048cb468bc209, "24766435002945523", -208 },
+        { 0x1504c0b3a63c1444, "2019986500244655", -206 },
+        { 0x1514c0b3a63c1444, "403997300048931", -206 },
+        { 0x161ba6008389068a, "35273912934356928", -201 },
+        { 0x162ba6008389068a, "70547825868713855", -201 },
+        { 0x168cfab1a09b49c4, "47323883490786093", -199 },
+        { 0x175090684f5fe997, "22159015457577768", -195 },
+        { 0x175090684f5fe998, "2215901545757777", -195 },
+        { 0x176090684f5fe997, "44318030915155535", -195 },
+        { 0x176090684f5fe998, "4431803091515554", -195 },
+        { 0x17e4116d591ef1fb, "13745435592982211", -192 },
+        { 0x17f4116d591ef1fb, "27490871185964422", -192 },
+        { 0x1804116d591ef1fb, "54981742371928845", -192 },
+        { 0x18a710b7a2ef18b7, "64710073234908765", -189 },
+        { 0x18cde996371c6060, "33567940583589088", -188 },
+        { 0x18d99fccca44882a, "57511323531737074", -188 },
+        { 0x18dde996371c6060, "67135881167178176", -188 },
+        { 0x199a2cf604c30d3f, "2406355597625261", -184 },
+        { 0x19aa2cf604c30d3f, "4812711195250522", -184 },
+        { 0x1b5ebddc6593c857, "75862936714499446", -176 },
+        { 0x1c513770474911bd, "27843818440071113", -171 },
+        { 0x1d1b1ad9101b1bfd, "1795518315109779", -167 },
+        { 0x1d2b1ad9101b1bfd, "3591036630219558", -167 },
+        { 0x1d3b1ad9101b1bfd, "7182073260439116", -167 },
+        { 0x1e3035e7b5183922, "28150140033551147", -162 },
+        { 0x1e4035e7b5183923, "563002800671023", -162 },
+        { 0x1e5035e7b5183923, "1126005601342046", -161 },
+        { 0x1e6035e7b5183923, "2252011202684092", -161 },
+        { 0x1e7035e7b5183923, "4504022405368184", -161 },
+        { 0x1fd5a79c4e71d028, "2523567903248961", -154 },
+        { 0x1fe5a79c4e71d028, "5047135806497922", -154 },
+        { 0x20cc29bc6879dfcd, "10754533488024391", -149 },
+        { 0x20dc29bc6879dfcd, "21509066976048781", -149 },
+        { 0x20e8823a57adbef8, "37436263604934127", -149 },
+        { 0x20ec29bc6879dfcd, "43018133952097563", -149 },
+        { 0x2104dab846e19e25, "1274175730310828", -148 },
+        { 0x2114dab846e19e25, "2548351460621656", -148 },
+        { 0x2124dab846e19e25, "5096702921243312", -148 },
+        { 0x218ce77c2b3328fb, "45209911804158747", -146 },
+        { 0x220ce77c2b3328fb, "11573737421864639", -143 },
+        { 0x220ce77c2b3328fc, "1157373742186464", -143 },
+        { 0x221ce77c2b3328fb, "23147474843729279", -143 },
+        { 0x221ce77c2b3328fc, "2314747484372928", -143 },
+        { 0x222ce77c2b3328fb, "46294949687458557", -143 },
+        { 0x222ce77c2b3328fc, "4629494968745856", -143 },
+        { 0x229197b290631476, "36067106647774144", -141 },
+        { 0x233f346f9ed36b89, "65509428048152994", -138 },
+        { 0x240a28877a09a4e0, "44986453555921307", -134 },
+        { 0x240a28877a09a4e1, "4498645355592131", -134 },
+        { 0x243441ed79830181, "27870735485790148", -133 },
+        { 0x243441ed79830182, "2787073548579015", -133 },
+        { 0x244441ed79830181, "55741470971580295", -133 },
+        { 0x244441ed79830182, "557414709715803", -133 },
+        { 0x245441ed79830181, "11148294194316059", -132 },
+        { 0x245441ed79830182, "1114829419431606", -132 },
+        { 0x246441ed79830181, "22296588388632118", -132 },
+        { 0x246441ed79830182, "2229658838863212", -132 },
+        { 0x247441ed79830181, "44593176777264236", -132 },
+        { 0x247441ed79830182, "4459317677726424", -132 },
+        { 0x248b23b50fc204db, "11948502190822011", -131 },
+        { 0x249b23b50fc204db, "23897004381644022", -131 },
+        { 0x24ab23b50fc204db, "47794008763288043", -131 },
+        { 0x2541e4ee41180c0a, "32269008655522087", -128 },
+        { 0x2633dc6227de9148, "1173600085235347", -123 },
+        { 0x2643dc6227de9148, "2347200170470694", -123 },
+        { 0x2653dc6227de9148, "4694400340941388", -123 },
+        { 0x277aacfcb88c92d6, "16528675364037979", -117 },
+        { 0x277aacfcb88c92d7, "1652867536403798", -117 },
+        { 0x278aacfcb88c92d6, "33057350728075958", -117 },
+        { 0x278aacfcb88c92d7, "3305735072807596", -117 },
+        { 0x279aacfcb88c92d6, "66114701456151916", -117 },
+        { 0x279aacfcb88c92d7, "6611470145615192", -117 },
+        { 0x279b5cd8bbdd8770, "67817280930489786", -117 },
+        { 0x27bbb4c6bd8601bd, "27467428267063488", -116 },
+        { 0x27cbb4c6bd8601bd, "54934856534126976", -116 },
+        { 0x289d52af46e5fa69, "4762882274418243", -112 },
+        { 0x289d52af46e5fa6a, "47628822744182433", -112 },
+        { 0x28b04a616046e074, "10584182832040541", -111 },
+        { 0x28c04a616046e074, "21168365664081082", -111 },
+        { 0x28d04a616046e074, "42336731328162165", -111 },
+        { 0x297c2c31a31998ae, "74973710847373845", -108 },
+        { 0x2a3eeff57768f88c, "33722866731879692", -104 },
+        { 0x2a4eeff57768f88c, "67445733463759384", -104 },
+        { 0x2b8e3a0aeed7be19, "69097540994131414", -98 },
+        { 0x2bdec922478c0421, "22520091703825729", -96 },
+        { 0x2beec922478c0421, "45040183407651457", -96 },
+        { 0x2c2379f099a86227, "45590931008842566", -95 },
+        { 0x2cc7c3fba45c1271, "5696647848853893", -92 },
+        { 0x2cc7c3fba45c1272, "56966478488538934", -92 },
+        { 0x2cf4f14348a4c5db, "40159515855058247", -91 },
+        { 0x2d04f14348a4c5db, "8031903171011649", -91 },
+        { 0x2d44f14348a4c5db, "12851045073618639", -89 },
+        { 0x2d44f14348a4c5dc, "1285104507361864", -89 },
+        { 0x2d54f14348a4c5db, "25702090147237278", -89 },
+        { 0x2d54f14348a4c5dc, "2570209014723728", -89 },
+        { 0x2d5a8c931c19b77a, "3258302752792233", -89 },
+        { 0x2d64f14348a4c5db, "51404180294474556", -89 },
+        { 0x2d64f14348a4c5dc, "5140418029447456", -89 },
+        { 0x2d6a8c931c19b77a, "6516605505584466", -89 },
+        { 0x2efc1249e96b6d8d, "23119896893873391", -81 },
+        { 0x2f0c1249e96b6d8d, "46239793787746783", -81 },
+        { 0x2f0f6b23cfe98807, "51753157237874753", -81 },
+        { 0x2fa387cf9cb4ad4e, "32943123175907307", -78 },
+        { 0x2fe91b9de4d5cf31, "67761208324172855", -77 },
+        { 0x3081eab25ad0fcf7, "49514357246452655", -74 },
+        { 0x308ddc7e975c5045, "8252392874408775", -74 },
+        { 0x308ddc7e975c5046, "82523928744087755", -74 },
+        { 0x309ddc7e975c5045, "1650478574881755", -73 },
+        { 0x30addc7e975c5045, "330095714976351", -73 },
+        { 0x30bddc7e975c5045, "660191429952702", -73 },
+        { 0x3149190e30e46c1d, "28409785190323268", -70 },
+        { 0x3150ed9bd6bfd003, "3832399419240467", -70 },
+        { 0x3159190e30e46c1d, "56819570380646536", -70 },
+        { 0x317d2ec75df6ba2a, "26426943389906988", -69 },
+        { 0x318d2ec75df6ba2a, "52853886779813977", -69 },
+        { 0x321aedaa0fc32ac8, "2497072464210591", -66 },
+        { 0x322aedaa0fc32ac8, "4994144928421182", -66 },
+        { 0x32448050091c3c24, "15208651188557789", -65 },
+        { 0x32548050091c3c24, "30417302377115577", -65 },
+        { 0x328f5a18504dfaac, "37213051060716888", -64 },
+        { 0x329f5a18504dfaac, "74426102121433776", -64 },
+        { 0x3336dca59d035820, "55574205388093594", -61 },
+        { 0x33beef5e1f90ac34, "1925091640472375", -58 },
+        { 0x33ceef5e1f90ac34, "385018328094475", -58 },
+        { 0x33deef5e1f90ac34, "77003665618895", -58 },
+        { 0x33eeef5e1f90ac35, "15400733123779001", -57 },
+        { 0x33feef5e1f90ac35, "30801466247558002", -57 },
+        { 0x340eef5e1f90ac35, "61602932495116004", -57 },
+        { 0x341eef5e1f90ac35, "12320586499023201", -56 },
+        { 0x34228f9edfbd3420, "14784703798827841", -56 },
+        { 0x342eef5e1f90ac35, "24641172998046401", -56 },
+        { 0x34328f9edfbd3420, "29569407597655683", -56 },
+        { 0x343eef5e1f90ac35, "49282345996092803", -56 },
+        { 0x344eef5e1f90ac35, "9856469199218561", -56 },
+        { 0x345eef5e1f90ac35, "19712938398437121", -55 },
+        { 0x346eef5e1f90ac35, "39425876796874242", -55 },
+        { 0x347eef5e1f90ac35, "78851753593748485", -55 },
+        { 0x35008621c4199208, "21564764513659432", -52 },
+        { 0x35108621c4199208, "43129529027318865", -52 },
+        { 0x35e0ac2e7f90b8a3, "35649516398744314", -48 },
+        { 0x35ef1de1f7f14439, "66534156679273626", -48 },
+        { 0x361dde4a4ab13e09, "51091836539008967", -47 },
+        { 0x366b870de5d93270, "15068094409836911", -45 },
+        { 0x367b870de5d93270, "30136188819673822", -45 },
+        { 0x368b870de5d93270, "60272377639347644", -45 },
+        { 0x375b20c2f4f8d49f, "4865841847892019", -41 },
+        { 0x375b20c2f4f8d4a0, "48658418478920193", -41 },
+        { 0x37f25d342b1e33e5, "33729482964455627", -38 },
+        { 0x3854faba79ea92ec, "24661175471861008", -36 },
+        { 0x3854faba79ea92ed, "2466117547186101", -36 },
+        { 0x3864faba79ea92ec, "49322350943722016", -36 },
+        { 0x3864faba79ea92ed, "4932235094372202", -36 },
+        { 0x3a978cfcab31064c, "19024128529074359", -25 },
+        { 0x3a978cfcab31064d, "1902412852907436", -25 },
+        { 0x3aa78cfcab31064c, "38048257058148717", -25 },
+        { 0x3aa78cfcab31064d, "3804825705814872", -25 },
+        { 0x47f52d02c7e14af7, "45035996273704964", 39 },
+        { 0x490cd230a7ff47c3, "80341375308088225", 44 },
+        { 0x4919d9577de925d5, "14411294198511291", 45 },
+        { 0x4929d9577de925d5, "28822588397022582", 45 },
+        { 0x4931159a8bd8a240, "38099461575161174", 45 },
+        { 0x4939d9577de925d5, "57645176794045164", 45 },
+        { 0x49ccadd6dd730c96, "32745697577386472", 48 },
+        { 0x49dcadd6dd730c96, "65491395154772944", 48 },
+        { 0x4a6bb6979ae39c49, "32402369146794532", 51 },
+        { 0x4a7bb6979ae39c49, "64804738293589064", 51 },
+        { 0x4b9a32ac316fb3ab, "16059290466419889", 57 },
+        { 0x4b9a32ac316fb3ac, "1605929046641989", 57 },
+        { 0x4baa32ac316fb3ab, "32118580932839778", 57 },
+        { 0x4baa32ac316fb3ac, "3211858093283978", 57 },
+        { 0x4bba32ac316fb3ab, "64237161865679556", 57 },
+        { 0x4bba32ac316fb3ac, "6423716186567956", 57 },
+        { 0x4c85564fb098c955, "42859354584576066", 61 },
+        { 0x4cef20b1a0d7f626, "4001624164855121", 63 },
+        { 0x4cff20b1a0d7f626, "8003248329710242", 63 },
+        { 0x4e2e2785c3a2a20a, "4064803033949531", 69 },
+        { 0x4e2e2785c3a2a20b, "40648030339495312", 69 },
+        { 0x4e3e2785c3a2a20a, "8129606067899062", 69 },
+        { 0x4e3e2785c3a2a20b, "81296060678990625", 69 },
+        { 0x4e6454b1aef62c8d, "4384946084578497", 70 },
+        { 0x4e80fde34c996086, "1465909318208761", 71 },
+        { 0x4e90fde34c996086, "2931818636417522", 71 },
+        { 0x4ea9a2c2a34ac2f9, "8846583389443709", 71 },
+        { 0x4ea9a2c2a34ac2fa, "884658338944371", 71 },
+        { 0x4eb9a2c2a34ac2f9, "17693166778887419", 72 },
+        { 0x4eb9a2c2a34ac2fa, "1769316677888742", 72 },
+        { 0x4ec9a2c2a34ac2f9, "35386333557774838", 72 },
+        { 0x4ec9a2c2a34ac2fa, "3538633355777484", 72 },
+        { 0x4ed9a2c2a34ac2f9, "70772667115549675", 72 },
+        { 0x4ed9a2c2a34ac2fa, "7077266711554968", 72 },
+        { 0x4f28750ea732fdae, "21606114462319112", 74 },
+        { 0x4f38750ea732fdae, "43212228924638223", 74 },
+        { 0x503ca9bade45b94a, "3318949537676913", 79 },
+        { 0x504ca9bade45b94a, "6637899075353826", 79 },
+        { 0x513843e10734fa57, "18413733104063271", 84 },
+        { 0x514843e10734fa57, "36827466208126543", 84 },
+        { 0x51a3274280201a89, "18604316837693468", 86 },
+        { 0x51b3274280201a89, "37208633675386937", 86 },
+        { 0x51e71760b3c0bc13, "35887030159858487", 87 },
+        { 0x521f6a5025e71a61, "39058878597126768", 88 },
+        { 0x522f6a5025e71a61, "78117757194253536", 88 },
+        { 0x52c6a47d4e7ec633, "57654578150150385", 91 },
+        { 0x55693ba3249a8511, "2825769263311679", 104 },
+        { 0x55793ba3249a8511, "5651538526623358", 104 },
+        { 0x574fe0403124a00e, "38329392744333992", 113 },
+        { 0x575fe0403124a00e, "76658785488667984", 113 },
+        { 0x57763ae2caed4528, "2138446062528161", 114 },
+        { 0x57863ae2caed4528, "4276892125056322", 114 },
+        { 0x57d561def4a9ee32, "1316415380484425", 116 },
+        { 0x57e561def4a9ee32, "263283076096885", 116 },
+        { 0x57f561def4a9ee32, "52656615219377", 116 },
+        { 0x580561def4a9ee31, "10531323043875399", 117 },
+        { 0x581561def4a9ee31, "21062646087750798", 117 },
+        { 0x582561def4a9ee31, "42125292175501597", 117 },
+        { 0x584561def4a9ee31, "16850116870200639", 118 },
+        { 0x585561def4a9ee31, "33700233740401277", 118 },
+        { 0x5935ede8cce30845, "56627018760181905", 122 },
+        { 0x59d0dd8f2788d699, "44596066840334405", 125 },
+        { 0x5b45ed1f039cebfe, "48635409059147446", 132 },
+        { 0x5b55ed1f039cebfe, "9727081811829489", 132 },
+        { 0x5b55ed1f039cebff, "972708181182949", 132 },
+        { 0x5beaf5b5378aa2e5, "61235700073843246", 135 },
+        { 0x5bfaf5b5378aa2e5, "12247140014768649", 136 },
+        { 0x5c0af5b5378aa2e5, "24494280029537298", 136 },
+        { 0x5c1af5b5378aa2e5, "48988560059074597", 136 },
+        { 0x5c4ef3052ef0a361, "4499029632233837", 137 },
+        { 0x5c6cf45d333da323, "16836228873919609", 138 },
+        { 0x5e1780695036a679, "18341526859645389", 146 },
+        { 0x5e2780695036a679, "36683053719290777", 146 },
+        { 0x5e54ec8fd70420c7, "2612787385440923", 147 },
+        { 0x5e64ec8fd70420c7, "5225574770881846", 147 },
+        { 0x5e6b5e2f86026f05, "6834859331393543", 147 },
+        { 0x5f9aeac2d1ea2695, "35243988108650928", 153 },
+        { 0x5faaeac2d1ea2695, "70487976217301855", 153 },
+        { 0x6009813653f62db7, "42745323906998127", 155 },
+        { 0x611260322d04d50b, "40366692112133834", 160 },
+        { 0x624be064a3fb2725, "32106017483029628", 166 },
+        { 0x625be064a3fb2725, "64212034966059256", 166 },
+        { 0x64112a13daa46fe4, "10613173493886741", 175 },
+        { 0x64212a13daa46fe4, "21226346987773482", 175 },
+        { 0x64312a13daa46fe4, "42452693975546964", 175 },
+        { 0x671dcfee6690ffc6, "51886190678901447", 189 },
+        { 0x672dcfee6690ffc6, "10377238135780289", 190 },
+        { 0x673dcfee6690ffc6, "20754476271560579", 190 },
+        { 0x674dcfee6690ffc6, "41508952543121158", 190 },
+        { 0x675dcfee6690ffc6, "83017905086242315", 190 },
+        { 0x677a77581053543b, "29480080280199528", 191 },
+        { 0x678a77581053543b, "58960160560399056", 191 },
+        { 0x6820ee7811241ad3, "38624526316654214", 194 },
+        { 0x682d3683fa3d1ee0, "66641177824100826", 194 },
+        { 0x699873e3758bc6b3, "4679330956996797", 201 },
+        { 0x699cb490951e8515, "5493127645170153", 201 },
+        { 0x6a6cc08102f0da5b, "45072812455233127", 205 },
+        { 0x6b3ef9beaa7aa583, "39779219869333628", 209 },
+        { 0x6b3ef9beaa7aa584, "3977921986933363", 209 },
+        { 0x6b4ef9beaa7aa583, "79558439738667255", 209 },
+        { 0x6b4ef9beaa7aa584, "7955843973866726", 209 },
+        { 0x6b7896beb0c66eb9, "50523702331566894", 210 },
+        { 0x6b7b86d8c3df7cd1, "56560320317673966", 210 },
+        { 0x6bdf20938e7414bb, "40933393326155808", 212 },
+        { 0x6be6c9e14b7c22c4, "59935550661561155", 212 },
+        { 0x6bef20938e7414bb, "81866786652311615", 212 },
+        { 0x6bf6c9e14b7c22c3, "1198711013231223", 213 },
+        { 0x6bf6c9e14b7c22c4, "11987110132312231", 213 },
+        { 0x6c06c9e14b7c22c3, "2397422026462446", 213 },
+        { 0x6c06c9e14b7c22c4, "23974220264624462", 213 },
+        { 0x6c16c9e14b7c22c3, "4794844052924892", 213 },
+        { 0x6c16c9e14b7c22c4, "47948440529248924", 213 },
+        { 0x6ce75d226331d03a, "40270821632825953", 217 },
+        { 0x6cf75d226331d03a, "8054164326565191", 217 },
+        { 0x6d075d226331d03a, "16108328653130381", 218 },
+        { 0x6d175d226331d03a, "32216657306260762", 218 },
+        { 0x6d275d226331d03a, "64433314612521525", 218 },
+        { 0x6d4b9445072f4374, "30423431424080128", 219 },
+        { 0x6d5a3bdac4f00f33, "57878622568856074", 219 },
+        { 0x6d5b9445072f4374, "60846862848160256", 219 },
+        { 0x6e4a2fbffdb7580c, "18931483477278361", 224 },
+        { 0x6e5a2fbffdb7580c, "37862966954556723", 224 },
+        { 0x6e927edd0dbb8c08, "4278822588984689", 225 },
+        { 0x6e927edd0dbb8c09, "42788225889846894", 225 },
+        { 0x6ee1c382c3819a0a, "1315044757954692", 227 },
+        { 0x6ef1c382c3819a0a, "2630089515909384", 227 },
+        { 0x70f60cf8f38b0465, "14022275014833741", 237 },
+        { 0x71060cf8f38b0465, "28044550029667482", 237 },
+        { 0x7114390c68b888ce, "5143975308105889", 237 },
+        { 0x71160cf8f38b0465, "56089100059334965", 237 },
+        { 0x714fb4840532a9e5, "64517311884236306", 238 },
+        { 0x71b1d7cb7eae05d9, "46475406389115295", 240 },
+        { 0x727fca36c06cf106, "3391607972972965", 244 },
+        { 0x728fca36c06cf106, "678321594594593", 244 },
+        { 0x72eba10d818fdafd, "3773057430100257", 246 },
+        { 0x72fba10d818fdafd, "7546114860200514", 246 },
+        { 0x737a37935f3b71c9, "1833078106007497", 249 },
+        { 0x738a37935f3b71c9, "3666156212014994", 249 },
+        { 0x73972852443155ae, "64766168833734675", 249 },
+        { 0x739a37935f3b71c9, "7332312424029988", 249 },
+        { 0x754fe46e378bf132, "1197160149212491", 258 },
+        { 0x754fe46e378bf133, "11971601492124911", 258 },
+        { 0x755fe46e378bf132, "2394320298424982", 258 },
+        { 0x755fe46e378bf133, "23943202984249821", 258 },
+        { 0x756fe46e378bf132, "4788640596849964", 258 },
+        { 0x756fe46e378bf133, "47886405968499643", 258 },
+        { 0x76603d7cb98edc58, "1598075144577112", 263 },
+        { 0x76603d7cb98edc59, "15980751445771122", 263 },
+        { 0x76703d7cb98edc58, "3196150289154224", 263 },
+        { 0x76703d7cb98edc59, "31961502891542243", 263 },
+        { 0x782f7c6a9ad432a1, "83169412421960475", 271 },
+        { 0x78447e17e7814ce7, "21652206566352648", 272 },
+        { 0x78547e17e7814ce7, "43304413132705296", 272 },
+        { 0x7856d2aa2fc5f2b5, "48228872759189434", 272 },
+        { 0x7964066d88c7cab8, "5546524276967009", 277 },
+        { 0x799d696737fe68c7, "65171333649148234", 278 },
+        { 0x7ace779fddf21621, "3539481653469909", 284 },
+        { 0x7ace779fddf21622, "35394816534699092", 284 },
+        { 0x7ade779fddf21621, "7078963306939818", 284 },
+        { 0x7ade779fddf21622, "70789633069398184", 284 },
+        { 0x7bc3b063946e10ae, "14990287287869931", 289 },
+        { 0x7bd3b063946e10ae, "29980574575739863", 289 },
+        { 0x7c0c283ffc61c87d, "34300126555012788", 290 },
+        { 0x7c1c283ffc61c87d, "68600253110025576", 290 },
+        { 0x7c31926c7a7122ba, "17124434349589332", 291 },
+        { 0x7c41926c7a7122ba, "34248868699178663", 291 },
+        { 0x7d0a85c6f7fba05d, "2117392354885733", 295 },
+        { 0x7d1a85c6f7fba05d, "4234784709771466", 295 },
+        { 0x7d52a5daf9226f04, "47639264836707725", 296 },
+        { 0x7d8220e1772428d7, "37049827284413546", 297 },
+        { 0x7d9220e1772428d7, "7409965456882709", 297 },
+        { 0x7da220e1772428d7, "14819930913765419", 298 },
+        { 0x7db220e1772428d7, "29639861827530837", 298 },
+        { 0x7df22815078cb97b, "47497368114750945", 299 },
+        { 0x7dfe5aceedf1c1f1, "79407577493590275", 299 },
+        { 0x7e022815078cb97b, "9499473622950189", 299 },
+        { 0x7e122815078cb97b, "18998947245900378", 300 },
+        { 0x7e222815078cb97b, "37997894491800756", 300 },
+        { 0x7e8a9b45a91f1700, "35636409637317792", 302 },
+        { 0x7e9a9b45a91f1700, "71272819274635585", 302 },
+        { 0x7eb6202598194bee, "23707742595255608", 303 },
+        { 0x7ec490abad057752, "4407140524515149", 303 },
+        { 0x7ec6202598194bee, "47415485190511216", 303 },
+        { 0x7ee3c8eeb77b8d05, "16959746108988652", 304 },
+        { 0x7ef3c8eeb77b8d05, "33919492217977303", 304 },
+        { 0x7ef5bc471d5456c7, "37263572163337027", 304 },
+        { 0x7f03c8eeb77b8d05, "6783898443595461", 304 },
+        { 0x7f13c8eeb77b8d05, "13567796887190921", 305 },
+        { 0x7f23c8eeb77b8d05, "27135593774381842", 305 },
+        { 0x7f33c8eeb77b8d05, "54271187548763685", 305 },
+        { 0x7f5594223f5654bf, "2367662756557091", 306 },
+        { 0x7f6594223f5654bf, "4735325513114182", 306 },
+        { 0x7f9914e03c9260ee, "44032152438472327", 307 },
+        { 0x7fb82baa4ae611dc, "16973149506391291", 308 },
+        { 0x7fc82baa4ae611dc, "33946299012782582", 308 },
+        { 0x7fd82baa4ae611dc, "67892598025565165", 308 },
+        { 0x7fefffffffffffff, "17976931348623157", 309 },
+    ];
+
+    short low;
+    short high = pathologies.length - 1;
+    const FloatBits!double bits = { value };
+
+    while (high >= low)
+    {
+        const short middle = (low + high) / 2;
+        if (pathologies[middle].representation == bits.integral)
+        {
+            exponent = pathologies[middle].exponent;
+            copy(pathologies[middle].digits, buffer);
+            return buffer[0 .. pathologies[middle].digits.length];
+        }
+        else if (pathologies[middle].representation < bits.integral)
+        {
+            low = cast(short) (middle + 1);
+        }
+        else
+        {
+            high = cast(short) (middle - 1);
+        }
+    }
+    return null;
+}
+
+@nogc nothrow pure @safe unittest
+{
+    int exponent;
+    char[512] buffer;
+
+    assert(errol3(double.max, buffer, exponent) == "17976931348623157");
+    assert(exponent == 309);
+
+    assert(errol3(0.67892598025565165e308, buffer, exponent) == "67892598025565165");
+    assert(exponent == 308);
+
+    assert(errol3(0.40526371999771488e-307, buffer, exponent) == "40526371999771488");
+    assert(exponent == -307);
+
+    assert(errol3(0.81052743999542975e-307, buffer, exponent) == "81052743999542975");
+    assert(exponent == -307);
+
+    assert(errol3(0.810307, buffer, exponent) is null);
+}
+
 /*
 * Given a float value, returns the significant bits, and the position of the
 * decimal point in $(D_PARAM exponent). +/-Inf and NaN are specified by
@ -1371,22 +1963,23 @@ private const(char)[] real2String(double value,
        exponent = special;
        return (bits.integral & ((1UL << 52) - 1)) != 0 ? "NaN" : "Inf";
    }
-
-    if (exponent == 0 && (bits.integral << 1) == 0) // Is zero?
+    else if (exponent == 0 && (bits.integral << 1) == 0) // Is zero?
    {
        exponent = 1;
        buffer[0] = '0';
        return buffer[0 .. 1];
    }

-    if (value == double.max)
+    auto digits = errol3(value, buffer, exponent);
+    if (digits !is null)
    {
-        copy("17976931348623157", buffer);
-        exponent = 309;
        return buffer;
    }
-
-    if (value > 9.007199254740992e15 && value < 3.40282366920938e38)
+    else if (value >= 16.0 && value <= 9.007199254740992e15)
+    {
+        return errolFixed(value, buffer, exponent);
+    }
+    else if (value > 9.007199254740992e15 && value < 3.40282366920938e38)
    {
        return errol2(value, buffer, exponent);
    }
@ -1745,7 +2338,17 @@ private ref String printToString(string fmt, Args...)(return ref String result,
    return result;
 }

-package(tanya) String format(string fmt, Args...)(auto ref Args args)
+/**
+ * Produces a string according to the specified format.
+ *
+ * Params:
+ *  fmt  = Format.
+ *  Args = Types of the arguments.
+ *  args = Arguments.
+ *
+ * Returns: Formatted string.
+ */
+String format(string fmt, Args...)(auto ref Args args)
 {
    String formatted;

@ -1758,7 +2361,7 @@ package(tanya) String format(string fmt, Args...)(auto ref Args args)
    {
        static if (FormatSpecFilter!spec)
        {
-            printToString!"{}"(formatted, args);
+            printToString!"{}"(formatted, args[spec.position]);
        }
        else static if (isSomeString!(typeof(spec)))
        {
@ -1772,6 +2375,12 @@ package(tanya) String format(string fmt, Args...)(auto ref Args args)
    return formatted;
 }

+// doesn't print the first argument repeatedly
+@nogc nothrow pure @safe unittest
+{
+    assert(format!"{}{}"(1, 2) == "12");
+}
+
@nogc nothrow pure @safe unittest
 {
    assert(format!"Without arguments"() == "Without arguments");
@ -1845,6 +2454,7 @@ package(tanya) String format(string fmt, Args...)(auto ref Args args)
    assert(format!"{}"(0x1p-16382L) == "0");
    assert(format!"{}"(1e+3) == "1000");
    assert(format!"{}"(38234.1234) == "38234.1");
+    assert(format!"{}"(double.max) == "1.79769e+308");

    // typeof(null).
    assert(format!"{}"(null) == "null");
@ -2004,6 +2614,7 @@ nothrow pure @safe unittest

 private struct FormatSpec
 {
+    const size_t position;
 }

 // Returns the position of `tag` in `fmt`. If `tag` can't be found, returns the
@ -2020,7 +2631,7 @@ private size_t specPosition(string fmt, char tag)()
    return fmt.length;
 }

-private template ParseFmt(string fmt, size_t pos = 0)
+private template ParseFmt(string fmt, size_t arg = 0, size_t pos = 0)
 {
    static if (fmt.length == 0)
    {
@ -2032,7 +2643,7 @@ private template ParseFmt(string fmt, size_t pos = 0)
        {
            enum size_t pos = specPosition!(fmt[2 .. $], '{') + 2;
            alias ParseFmt = AliasSeq!(fmt[1 .. pos],
-                                       ParseFmt!(fmt[pos .. $], pos));
+                                       ParseFmt!(fmt[pos .. $], arg, pos));
        }
        else
        {
@ -2043,8 +2654,8 @@ private template ParseFmt(string fmt, size_t pos = 0)
            }
            else static if (pos == 1)
            {
-                alias ParseFmt = AliasSeq!(FormatSpec(),
-                                           ParseFmt!(fmt[pos + 1 .. $], pos + 1));
+                alias ParseFmt = AliasSeq!(FormatSpec(arg),
+                                           ParseFmt!(fmt[2 .. $], arg + 1, 2));
            }
            else
            {
@ -2056,7 +2667,7 @@ private template ParseFmt(string fmt, size_t pos = 0)
    {
        enum size_t pos = specPosition!(fmt, '{');
        alias ParseFmt = AliasSeq!(fmt[0 .. pos],
-                                   ParseFmt!(fmt[pos .. $], pos));
+                                   ParseFmt!(fmt[pos .. $], arg, pos));
    }
 }

--- a/source/tanya/functional.d
+++ b/source/tanya/functional.d
@ -17,21 +17,6 @@ module tanya.functional;
 import tanya.algorithm.mutation;
 import tanya.meta.metafunction;

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

--- a/source/tanya/hash/lookup.d
+++ b/source/tanya/hash/lookup.d
@ -89,7 +89,10 @@ private struct FNV
 * }
 * ---
 *
- * For scalar types FNV-1a (Fowler-Noll-Vo) hash function is used internally.
+ * For pointers and for scalar types implicitly convertible to `size_t` this
+ * is an identity operation (i.e. the value is cast to `size_t` and returned
+ * unaltered). Integer types wider than `size_t` are XOR folded down to
+ * `size_t`. Other scalar types use the FNV-1a (Fowler-Noll-Vo) hash function.
 * If the type provides a `toHash`-function, only `toHash()` is called and its
 * result is returned.
 *
@ -110,6 +113,19 @@ size_t hash(T)(auto ref T key)
    {
        return key.toHash();
    }
+    else static if ((isIntegral!T || isSomeChar!T || isBoolean!T)
+            && T.sizeof <= size_t.sizeof)
+    {
+        return cast(size_t) key;
+    }
+    else static if (isIntegral!T && T.sizeof > size_t.sizeof)
+    {
+        return cast(size_t) (key ^ (key >>> (size_t.sizeof * 8)));
+    }
+    else static if (isPointer!T || is(T : typeof(null)))
+    {
+        return (() @trusted => cast(size_t) key)();
+    }
    else
    {
        FNV fnv;
@ -177,30 +193,29 @@ version (unittest)
 // Tests that work for any hash size
@nogc nothrow pure @safe unittest
 {
-    assert(hash(null) == FNV.offsetBasis);
+    assert(hash(null) == 0);
    assert(hash(ToHash()) == 0U);
+    assert(hash('a') == 'a');
 }

 static if (size_t.sizeof == 4) @nogc nothrow pure @safe unittest
 {
-    assert(hash('a') == 0xe40c292cU);
    assert(hash(HashRange()) == 0x6222e842U);
    assert(hash(ToHashRange()) == 1268118805U);
 }
 static if (size_t.sizeof == 8) @nogc nothrow pure @safe unittest
 {
-    assert(hash('a') == 0xaf63dc4c8601ec8cUL);
    assert(hash(HashRange()) == 0x08985907b541d342UL);
    assert(hash(ToHashRange()) == 12161962213042174405UL);
 }

 static if (size_t.sizeof == 4) @nogc nothrow pure @system unittest
 {
-    assert(hash(cast(void*) 0x6e6f6863) == 0xac297727U);
+    assert(hash(cast(void*) 0x6e6f6863) == 0x6e6f6863);
 }
 static if (size_t.sizeof == 8) @nogc nothrow pure @system unittest
 {
-    assert(hash(cast(void*) 0x77206f676e6f6863) == 0xd1edd10b507344d0UL);
+    assert(hash(cast(void*) 0x77206f676e6f6863) == 0x77206f676e6f6863);
 }

 /*
@ -621,3 +636,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));
+}
--- a/source/tanya/math/mp.d
+++ b/source/tanya/math/mp.d
@ -14,17 +14,16 @@
 */
 module tanya.math.mp;

-import std.algorithm.comparison : cmp;
-import std.algorithm.mutation : copy, fill, reverse;
-import std.range;
+import std.algorithm.mutation : fill;
 import tanya.algorithm.comparison;
+import tanya.algorithm.iteration;
 import tanya.algorithm.mutation;
 import tanya.container.array;
 import tanya.encoding.ascii;
 import tanya.memory;
-static import tanya.memory.op;
 import tanya.meta.trait;
 import tanya.meta.transform;
+import tanya.range;

 /**
 * Algebraic sign.
@ -211,7 +210,7 @@ struct Integer
    this(this) @nogc nothrow pure @safe
    {
        auto tmp = allocator.resize!digit(null, this.size);
-        tanya.memory.op.copy(this.rep[0 .. this.size], tmp);
+        copy(this.rep[0 .. this.size], tmp);
        this.rep = tmp;
    }

@ -344,8 +343,7 @@ struct Integer
    if (is(Unqual!T == Integer))
    {
        this.rep = allocator.resize(this.rep, value.size);
-        tanya.memory.op.copy(value.rep[0 .. value.size],
-                             this.rep[0 .. value.size]);
+        copy(value.rep[0 .. value.size], this.rep[0 .. value.size]);
        this.size = value.size;
        this.sign = value.sign;

@ -631,7 +629,7 @@ struct Integer
        }
        return this.rep[0 .. this.size]
                   .retro
-                   .cmp(that.rep[0 .. that.size].retro);
+                   .compare(that.rep[0 .. that.size].retro);
    }

    /**
@ -932,7 +930,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);
@ -1508,14 +1506,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;
    }
--- a/source/tanya/memory/op.d
+++ b/source/tanya/memory/op.d
@ -305,7 +305,7 @@ do
 *          first occurrence of $(D_PARAM needle). If $(D_PARAM needle)
 *          couldn't be found, an empty `inout void[]` is returned.
 */
-inout(void[]) find(return inout void[] haystack, const ubyte needle)
+inout(void[]) find(return inout void[] haystack, ubyte needle)
@nogc nothrow pure @trusted
 in
 {
@ -326,19 +326,19 @@ do
        {
            return bytes[0 .. length];
        }
-        bytes++;
-        length--;
+        ++bytes;
+        --length;
    }

    // Check if some of the words has the needle
    auto words = cast(inout(size_t)*) bytes;
    while (length >= size_t.sizeof)
    {
-        if (((*words ^ needleWord) - highBits) & (~*words) & mask)
+        if ((((*words ^ needleWord) - highBits) & (~*words) & mask) != 0)
        {
            break;
        }
-        words++;
+        ++words;
        length -= size_t.sizeof;
    }

@ -350,8 +350,8 @@ do
        {
            return bytes[0 .. length];
        }
-        bytes++;
-        length--;
+        ++bytes;
+        --length;
    }

    return haystack[$ .. $];
@ -362,14 +362,89 @@ do
 {
    const ubyte[9] haystack = ['a', 'b', 'c', 'd', 'e', 'f', 'b', 'g', 'h'];

-    assert(find(haystack, 'a') == haystack[]);
-    assert(find(haystack, 'b') == haystack[1 .. $]);
-    assert(find(haystack, 'c') == haystack[2 .. $]);
-    assert(find(haystack, 'd') == haystack[3 .. $]);
-    assert(find(haystack, 'e') == haystack[4 .. $]);
-    assert(find(haystack, 'f') == haystack[5 .. $]);
-    assert(find(haystack, 'h') == haystack[8 .. $]);
+    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(find(haystack, 'i').length == 0);

    assert(find(null, 'a').length == 0);
 }
+
+/**
+ * Looks for `\0` in the $(D_PARAM haystack) and returns the part of the
+ * $(D_PARAM haystack) ahead of it.
+ *
+ * Returns $(D_KEYWORD null) if $(D_PARAM haystack) doesn't contain a null
+ * character.
+ *
+ * Params:
+ *  haystack = Memory block.
+ *
+ * Returns: The subrange that spans all bytes before the null character or
+ *          $(D_KEYWORD null) if the $(D_PARAM haystack) doesn't contain any.
+ */
+inout(char[]) findNullTerminated(return inout char[] haystack)
+@nogc nothrow pure @trusted
+in
+{
+    assert(haystack.length == 0 || haystack.ptr !is null);
+}
+do
+{
+    auto length = haystack.length;
+    enum size_t highBits = filledBytes!(0x01, 0);
+    enum size_t mask = filledBytes!(0x80, 0);
+
+    // Align
+    auto bytes = cast(inout(ubyte)*) haystack;
+    while (length > 0 && ((cast(size_t) bytes) & 3) != 0)
+    {
+        if (*bytes == '\0')
+        {
+            return haystack[0 .. haystack.length - length];
+        }
+        ++bytes;
+        --length;
+    }
+
+    // Check if some of the words contains 0
+    auto words = cast(inout(size_t)*) bytes;
+    while (length >= size_t.sizeof)
+    {
+        if (((*words - highBits) & (~*words) & mask) != 0)
+        {
+            break;
+        }
+        ++words;
+        length -= size_t.sizeof;
+    }
+
+    // Find the exact 0 position in the word
+    bytes = cast(inout(ubyte)*) words;
+    while (length > 0)
+    {
+        if (*bytes == '\0')
+        {
+            return haystack[0 .. haystack.length - length];
+        }
+        ++bytes;
+        --length;
+    }
+
+    return null;
+}
+
+///
+@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(findNullTerminated(null) is null);
+    assert(findNullTerminated("abcdef") is null);
+}
--- a/source/tanya/memory/package.d
+++ b/source/tanya/memory/package.d
@ -14,7 +14,7 @@
 */
 module tanya.memory;

-import std.algorithm.mutation;
+import std.algorithm.mutation : uninitializedFill;
 import tanya.conv;
 import tanya.exception;
 public import tanya.memory.allocator;
--- a/source/tanya/meta/metafunction.d
+++ b/source/tanya/meta/metafunction.d
@ -116,7 +116,7 @@ if (Args.length > 0 && __traits(isTemplate, pred))
 }

 /**
- * Zips one or more $(D_PSYMBOL Tuple)s with $(D_PARAM f).
+ * Zips one or more $(D_PSYMBOL Pack)s with $(D_PARAM f).
 *
 * Given $(D_PARAM f) and tuples t1, t2, ..., tk, where tk[i] denotes the
 * $(I i)-th element of the tuple $(I k)-th tuple, $(D_PSYMBOL ZipWith)
@ -129,7 +129,7 @@ if (Args.length > 0 && __traits(isTemplate, pred))
 * f(tk[0], tk[1], ... tk[i]),
 * ---
 *
- * $(D_PSYMBOL ZipWith) begins with the first elements from $(D_PARAM Tuples)
+ * $(D_PSYMBOL ZipWith) begins with the first elements from $(D_PARAM Packs)
 * and applies $(D_PARAM f) to them, then it takes the second
 * ones and does the same, and so on.
 *
@ -140,16 +140,17 @@ if (Args.length > 0 && __traits(isTemplate, pred))
 *
 * Params:
 *  f      = Some template that can be applied to the elements of
- *           $(D_PARAM Tuples).
- *  Tuples = $(D_PSYMBOL Tuple) instances.
+ *           $(D_PARAM Packs).
+ *  Packs  = $(D_PSYMBOL Pack) instances.
 *
 * Returns: A sequence, whose $(I i)-th element contains the $(I i)-th element
- *          from each of the $(D_PARAM Tuples).
+ *          from each of the $(D_PARAM Packs).
 */
-template ZipWith(alias f, Tuples...)
-if (Tuples.length > 0
+template ZipWith(alias f, Packs...)
+if (Packs.length > 0
 && __traits(isTemplate, f)
- && allSatisfy!(ApplyLeft!(isInstanceOf, Tuple), Tuples))
+ && (allSatisfy!(ApplyLeft!(isInstanceOf, Pack), Packs)
+ || allSatisfy!(ApplyLeft!(isInstanceOf, Tuple), Packs)))
 {
    private template GetIth(size_t i, Args...)
    {
@ -164,43 +165,37 @@ if (Tuples.length > 0
    }
    private template Iterate(size_t i, Args...)
    {
-        alias Tuple = GetIth!(i, Args);
+        alias Pack = GetIth!(i, Args);

-        static if (Tuple.length < Tuples.length)
+        static if (Pack.length < Packs.length)
        {
            alias Iterate = AliasSeq!();
        }
        else
        {
-            alias Iterate = AliasSeq!(f!Tuple,
-                                      Iterate!(i + 1, Args));
+            alias Iterate = AliasSeq!(f!Pack, Iterate!(i + 1, Args));
        }
    }
-    alias ZipWith = Iterate!(0, Tuples);
+    alias ZipWith = Iterate!(0, Packs);
 }

 ///
@nogc nothrow pure @safe unittest
 {
-    alias Result1 = ZipWith!(AliasSeq,
-                             Tuple!(1, 2),
-                             Tuple!(5, 6),
-                             Tuple!(9, 10));
+    alias Result1 = ZipWith!(AliasSeq, Pack!(1, 2), Pack!(5, 6), Pack!(9, 10));
    static assert(Result1 == AliasSeq!(1, 5, 9, 2, 6, 10));

-    alias Result2 = ZipWith!(AliasSeq,
-                             Tuple!(1, 2, 3),
-                             Tuple!(4, 5));
+    alias Result2 = ZipWith!(AliasSeq, Pack!(1, 2, 3), Pack!(4, 5));
    static assert(Result2 == AliasSeq!(1, 4, 2, 5));

-    alias Result3 = ZipWith!(AliasSeq, Tuple!(), Tuple!(4, 5));
+    alias Result3 = ZipWith!(AliasSeq, Pack!(), Pack!(4, 5));
    static assert(Result3.length == 0);
 }

 /**
 * Holds a typed sequence of template parameters.
 *
- * Different than $(D_PSYMBOL AliasSeq), $(D_PSYMBOL Tuple) doesn't unpack
+ * Different than $(D_PSYMBOL AliasSeq), $(D_PSYMBOL Pack) doesn't unpack
 * its template parameters automatically. Consider:
 *
 * ---
@ -215,7 +210,7 @@ if (Tuples.length > 0
 * Using $(D_PSYMBOL AliasSeq) template `A` gets 4 parameters instead of 2,
 * because $(D_PSYMBOL AliasSeq) is just an alias for its template parameters.
 *
- * With $(D_PSYMBOL Tuple) it is possible to pass distinguishable
+ * With $(D_PSYMBOL Pack) it is possible to pass distinguishable
 * sequences of parameters to a template. So:
 *
 * ---
@ -224,14 +219,26 @@ if (Tuples.length > 0
 *  static assert(Args.length == 2);
 * }
 *
- * alias BInstance = B!(Tuple!(int, uint), Tuple!(float, double));
+ * alias BInstance = B!(Pack!(int, uint), Pack!(float, double));
 * ---
 *
 * Params:
- *  Args = Elements of this $(D_PSYMBOL Tuple).
+ *  Args = Elements of this $(D_PSYMBOL Pack).
 *
 * See_Also: $(D_PSYMBOL AliasSeq).
 */
+struct Pack(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;
+}
+
+deprecated("Use Pack instead")
 struct Tuple(Args...)
 {
    /// Elements in this tuple as $(D_PSYMBOL AliasSeq).
@ -246,9 +253,9 @@ struct Tuple(Args...)
 ///
@nogc nothrow pure @safe unittest
 {
-    alias A = Tuple!short;
-    alias B = Tuple!(3, 8, 9);
-    alias C = Tuple!(A, B);
+    alias A = Pack!short;
+    alias B = Pack!(3, 8, 9);
+    alias C = Pack!(A, B);

    static assert(C.length == 2);

@ -257,7 +264,7 @@ struct Tuple(Args...)
    static assert(B.length == 3);
    static assert(B.Seq == AliasSeq!(3, 8, 9));

-    alias D = Tuple!();
+    alias D = Pack!();
    static assert(D.length == 0);
    static assert(is(D.Seq == AliasSeq!()));
 }
@ -270,7 +277,7 @@ struct Tuple(Args...)
 * for determining if two items are equal.
 *
 * Params:
- *  Args = Elements of this $(D_PSYMBOL Tuple).
+ *  Args = Elements of this $(D_PSYMBOL Set).
 */
 struct Set(Args...)
 {
--- a/source/tanya/meta/trait.d
+++ b/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);
 }

 /**
--- a/source/tanya/net/iface.d
+++ b/source/tanya/net/iface.d
@ -0,0 +1,228 @@
+/* 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/. */
+
+/**
+ * Network interfaces.
+ *
+ * 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/net/iface.d,
+ *                 tanya/net/iface.d)
+ */
+module tanya.net.iface;
+
+import tanya.algorithm.comparison;
+import tanya.algorithm.mutation;
+import tanya.container.string;
+import tanya.meta.trait;
+import tanya.meta.transform;
+import tanya.range;
+
+version (TanyaNative)
+{
+    import mir.linux._asm.unistd;
+    import tanya.sys.linux.syscall;
+    import tanya.sys.posix.ioctl;
+    import tanya.sys.posix.net.if_;
+    import tanya.sys.posix.socket;
+}
+else version (Windows)
+{
+    import tanya.sys.windows.ifdef;
+    import tanya.sys.windows.iphlpapi;
+}
+else version (Posix)
+{
+    import core.sys.posix.net.if_;
+}
+
+/**
+ * Converts the name of a network interface to its index.
+ *
+ * If an interface with the name $(D_PARAM name) cannot be found or another
+ * error occurres, returns 0.
+ *
+ * Params:
+ *  name = Interface name.
+ *
+ * Returns: Returns interface index or 0.
+ */
+uint nameToIndex(R)(R name) @trusted
+if (isInputRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
+{
+    version (TanyaNative)
+    {
+        if (name.length >= IF_NAMESIZE)
+        {
+            return 0;
+        }
+        ifreq ifreq_ = void;
+
+        copy(name, ifreq_.ifr_name[]);
+        ifreq_.ifr_name[name.length] = '\0';
+
+        auto socket = syscall(AF_INET,
+                              SOCK_DGRAM | SOCK_CLOEXEC,
+                              0,
+                              NR_socket);
+        if (socket <= 0)
+        {
+            return 0;
+        }
+        scope (exit)
+        {
+            syscall(socket, NR_close);
+        }
+        if (syscall(socket,
+                    SIOCGIFINDEX,
+                    cast(ptrdiff_t) &ifreq_,
+                    NR_ioctl) == 0)
+        {
+            return ifreq_.ifr_ifindex;
+        }
+        return 0;
+    }
+    else version (Windows)
+    {
+        if (name.length > IF_MAX_STRING_SIZE)
+        {
+            return 0;
+        }
+        char[IF_MAX_STRING_SIZE + 1] buffer;
+        NET_LUID luid;
+
+        copy(name, buffer[]);
+        buffer[name.length] = '\0';
+
+        if (ConvertInterfaceNameToLuidA(buffer.ptr, &luid) != 0)
+        {
+            return 0;
+        }
+        NET_IFINDEX index;
+        if (ConvertInterfaceLuidToIndex(&luid, &index) == 0)
+        {
+            return index;
+        }
+        return 0;
+    }
+    else version (Posix)
+    {
+        if (name.length >= IF_NAMESIZE)
+        {
+            return 0;
+        }
+        char[IF_NAMESIZE] buffer;
+
+        copy(name, buffer[]);
+        buffer[name.length] = '\0';
+
+        return if_nametoindex(buffer.ptr);
+    }
+}
+
+///
+@nogc nothrow @safe unittest
+{
+    version (linux)
+    {
+        assert(nameToIndex("lo") == 1);
+    }
+    else version (Windows)
+    {
+        assert(nameToIndex("loopback_0") == 1);
+    }
+    else
+    {
+        assert(nameToIndex("lo0") == 1);
+    }
+    assert(nameToIndex("ecafretni") == 0);
+}
+
+/**
+ * Converts the index of a network interface to its name.
+ *
+ * If an interface with the $(D_PARAM index) cannot be found or another
+ * error occurres, returns an empty $(D_PSYMBOL String).
+ *
+ * Params:
+ *  index = Interface index.
+ *
+ * Returns: Returns interface name or an empty $(D_PSYMBOL String).
+ */
+String indexToName(uint index) @nogc nothrow @trusted
+{
+    import tanya.memory.op : findNullTerminated;
+
+    version (TanyaNative)
+    {
+        ifreq ifreq_ = void;
+        ifreq_.ifr_ifindex = index;
+
+        auto socket = syscall(AF_INET,
+                              SOCK_DGRAM | SOCK_CLOEXEC,
+                              0,
+                              NR_socket);
+        if (socket <= 0)
+        {
+            return String();
+        }
+        scope (exit)
+        {
+            syscall(socket, NR_close);
+        }
+        if (syscall(socket,
+                    SIOCGIFNAME,
+                    cast(ptrdiff_t) &ifreq_,
+                    NR_ioctl) == 0)
+        {
+            return String(findNullTerminated(ifreq_.ifr_name));
+        }
+        return String();
+    }
+    else version (Windows)
+    {
+        NET_LUID luid;
+        if (ConvertInterfaceIndexToLuid(index, &luid) != 0)
+        {
+            return String();
+        }
+
+        char[IF_MAX_STRING_SIZE + 1] buffer;
+        if (ConvertInterfaceLuidToNameA(&luid,
+                                        buffer.ptr,
+                                        IF_MAX_STRING_SIZE + 1) != 0)
+        {
+            return String();
+        }
+        return String(findNullTerminated(buffer));
+    }
+    else version (Posix)
+    {
+        char[IF_NAMESIZE] buffer;
+        if (if_indextoname(index, buffer.ptr) is null)
+        {
+            return String();
+        }
+        return String(findNullTerminated(buffer));
+    }
+}
+
+@nogc nothrow @safe unittest
+{
+    version (linux)
+    {
+        assert(equal(indexToName(1)[], "lo"));
+    }
+    else version (Windows)
+    {
+        assert(equal(indexToName(1)[], "loopback_0"));
+    }
+    else
+    {
+        assert(equal(indexToName(1)[], "lo0"));
+    }
+    assert(indexToName(uint.max).empty);
+}
--- a/source/tanya/net/inet.d
+++ b/source/tanya/net/inet.d
@ -16,7 +16,7 @@ module tanya.net.inet;

 import tanya.meta.trait;
 import tanya.meta.transform;
-import tanya.range.primitive;
+import tanya.range;

 /**
 * Represents an unsigned integer as an $(D_KEYWORD ubyte) range.
--- a/source/tanya/net/ip.d
+++ b/source/tanya/net/ip.d
@ -0,0 +1,961 @@
+/* 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/. */
+
+/**
+ * Internet Protocol implementation.
+ *
+ * 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/net/ip.d,
+ *                 tanya/net/ip.d)
+ */
+module tanya.net.ip;
+
+import tanya.algorithm.comparison;
+import tanya.algorithm.mutation;
+import tanya.container.string;
+import tanya.conv;
+import tanya.encoding.ascii;
+import tanya.format;
+import tanya.meta.trait;
+import tanya.meta.transform;
+import tanya.net.iface;
+import tanya.net.inet;
+import tanya.range;
+import tanya.typecons;
+
+/**
+ * IPv4 internet address.
+ */
+struct Address4
+{
+    // In network byte order.
+    private uint address;
+
+    version (LittleEndian)
+    {
+        private enum uint loopback_ = 0x0100007fU;
+        enum byte step = 8;
+    }
+    else
+    {
+        private enum uint loopback_ = 0x7f000001U;
+        enum byte step = -8;
+    }
+    private enum uint any_ = 0U;
+    private enum uint broadcast = uint.max;
+
+    /**
+     * Constructs an $(D_PSYMBOL Address4) from an unsigned integer in host
+     * byte order.
+     *
+     * Params:
+     *  address = The address as an unsigned integer in host byte order.
+     */
+    this(uint address) @nogc nothrow pure @safe
+    {
+        copy(NetworkOrder!4(address),
+             (() @trusted => (cast(ubyte*) &this.address)[0 .. 4])());
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        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.
+     *
+     * Returns: Object that represents the Loopback address.
+     */
+    static Address4 loopback() @nogc nothrow pure @safe
+    {
+        typeof(return) address;
+        address.address = Address4.loopback_;
+        return address;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address4.loopback().isLoopback());
+    }
+
+    /**
+     * Returns object that represents 0.0.0.0.
+     *
+     * Returns: Object that represents any address.
+     */
+    static Address4 any() @nogc nothrow pure @safe
+    {
+        typeof(return) address;
+        address.address = Address4.any_;
+        return address;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address4.any().isAny());
+    }
+
+    /**
+     * Loopback address is 127.0.0.1.
+     *
+     * Returns: $(D_KEYWORD true) if this is a loopback address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isLoopback() const @nogc nothrow pure @safe
+    {
+        return this.address == loopback_;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(address4("127.0.0.1").isLoopback());
+    }
+
+    /**
+     * 0.0.0.0 can represent any address. This function checks whether this
+     * address is 0.0.0.0.
+     *
+     * Returns: $(D_KEYWORD true) if this is an unspecified address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isAny() const @nogc nothrow pure @safe
+    {
+        return this.address == any_;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(address4("0.0.0.0").isAny());
+    }
+
+    /**
+     * Broadcast address is 255.255.255.255.
+     *
+     * Returns: $(D_KEYWORD true) if this is a broadcast address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isBroadcast() const @nogc nothrow pure @safe
+    {
+        return this.address == broadcast;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(address4("255.255.255.255").isBroadcast());
+    }
+
+    /**
+     * Determines whether this address' destination is a group of endpoints.
+     *
+     * Returns: $(D_KEYWORD true) if this is a multicast address,
+     *          $(D_KEYWORD false) otherwise.
+     *
+     * See_Also: $(D_PSYMBOL isUnicast).
+     */
+    bool isMulticast() const @nogc nothrow pure @safe
+    {
+        version (LittleEndian)
+        {
+            enum uint mask = 0xe0;
+        }
+        else
+        {
+            enum uint mask = 0xe0000000U;
+        }
+        return (this.address & mask) == mask;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(address4("224.0.0.3").isMulticast());
+    }
+
+    /**
+     * Determines whether this address' destination is a single endpoint.
+     *
+     * Returns: $(D_KEYWORD true) if this is a multicast address,
+     *          $(D_KEYWORD false) otherwise.
+     *
+     * See_Also: $(D_PSYMBOL isMulticast).
+     */
+    bool isUnicast() const @nogc nothrow pure @safe
+    {
+        return !isMulticast();
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(address4("192.168.0.1").isUnicast());
+    }
+
+    /**
+     * Produces a string containing an IPv4 address in dotted-decimal notation.
+     *
+     * Returns: This address in dotted-decimal notation.
+     */
+    String stringify() const @nogc nothrow pure @safe
+    {
+        const octets = (() @trusted => (cast(ubyte*) &this.address)[0 .. 4])();
+        enum string fmt = "{}.{}.{}.{}";
+        version (LittleEndian)
+        {
+            return format!fmt(octets[0], octets[1], octets[2], octets[3]);
+        }
+        else
+        {
+            return format!fmt(octets[3], octets[2], octets[1], octets[0]);
+        }
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        const dottedDecimal = "192.168.0.1";
+        const address = address4(dottedDecimal);
+        assert(address.get.stringify() == dottedDecimal);
+    }
+
+    /**
+     * Produces a byte array containing this address in network byte order.
+     *
+     * Returns: This address as raw bytes in network byte order.
+     */
+    ubyte[4] toBytes() const @nogc nothrow pure @safe
+    {
+        ubyte[4] bytes;
+        copy((() @trusted => (cast(ubyte*) &this.address)[0 .. 4])(), bytes[]);
+        return bytes;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        const actual = address4("192.168.0.1");
+        const ubyte[4] expected = [192, 168, 0, 1];
+        assert(actual.toBytes() == expected);
+    }
+
+    /**
+     * Converts this address to an unsigned integer in host byte order.
+     *
+     * Returns: This address as an unsigned integer in host byte order.
+     */
+    uint toUInt() const @nogc nothrow pure @safe
+    {
+        alias slice = () @trusted => (cast(ubyte*) &this.address)[0 .. 4];
+        return toHostOrder!uint(slice());
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(address4("127.0.0.1").toUInt() == 0x7f000001U);
+    }
+}
+
+/**
+ * Parses a string containing an IPv4 address in dotted-decimal notation.
+ *
+ * Params:
+ *  R     = Input range type.
+ *  range = Stringish range containing the address.
+ *
+ * Returns: $(D_PSYMBOL Option) containing the address if the parsing was
+ *          successful, or nothing otherwise.
+ */
+Option!Address4 address4(R)(R range)
+if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
+{
+    Address4 result;
+    version (LittleEndian)
+    {
+        ubyte shift;
+        enum ubyte cond = 24;
+    }
+    else
+    {
+        ubyte shift = 24;
+        enum ubyte cond = 0;
+    }
+
+    for (; shift != cond; shift += Address4.step, range.popFront())
+    {
+        if (range.empty || range.front == '.')
+        {
+            return typeof(return)();
+        }
+        result.address |= readIntegral!ubyte(range) << shift;
+        if (range.empty || range.front != '.')
+        {
+            return typeof(return)();
+        }
+    }
+
+    if (range.empty || range.front == '.')
+    {
+        return typeof(return)();
+    }
+    result.address |= readIntegral!ubyte(range) << shift;
+    return range.empty ? typeof(return)(result) : typeof(return)();
+}
+
+// Rejects malformed addresses
+@nogc nothrow pure @safe unittest
+{
+    assert(address4("256.0.0.1").isNothing);
+    assert(address4(".0.0.1").isNothing);
+    assert(address4("0..0.1").isNothing);
+    assert(address4("0.0.0.").isNothing);
+    assert(address4("0.0.").isNothing);
+    assert(address4("").isNothing);
+}
+
+/**
+ * Constructs an $(D_PSYMBOL Address4) from raw bytes in network byte order.
+ *
+ * Params:
+ *  R     = Input range type.
+ *  range = $(D_KEYWORD ubyte) range containing the address.
+ *
+ * Returns: $(D_PSYMBOL Option) containing the address if the $(D_PARAM range)
+ *          contains exactly 4 bytes, or nothing otherwise.
+ */
+Option!Address4 address4(R)(R range)
+if (isInputRange!R && is(Unqual!(ElementType!R) == ubyte))
+{
+    Address4 result;
+    version (LittleEndian)
+    {
+        ubyte shift;
+    }
+    else
+    {
+        ubyte shift = 24;
+    }
+
+    for (; shift <= 24; shift += Address4.step, range.popFront())
+    {
+        if (range.empty)
+        {
+            return typeof(return)();
+        }
+        result.address |= range.front << shift;
+    }
+
+    return range.empty ? typeof(return)(result) : typeof(return)();
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    {
+        ubyte[4] actual = [127, 0, 0, 1];
+        assert(address4(actual[]).isLoopback());
+    }
+    {
+        ubyte[3] actual = [127, 0, 0];
+        assert(address4(actual[]).isNothing);
+    }
+    {
+        ubyte[5] actual = [127, 0, 0, 0, 1];
+        assert(address4(actual[]).isNothing);
+    }
+}
+
+@nogc nothrow pure @safe unittest
+{
+    assert(address4(cast(ubyte[]) []).isNothing);
+}
+
+// Assignment and comparison works
+@nogc nothrow pure @safe unittest
+{
+    auto address1 = Address4.loopback();
+    auto address2 = Address4.any();
+    address1 = address2;
+    assert(address1 == address2);
+}
+
+/**
+ * IPv6 internet address.
+ */
+struct Address6
+{
+    // Raw bytes
+    private ubyte[16] address;
+
+    /// Scope ID.
+    uint scopeID;
+
+    /**
+     * Constructs an $(D_PSYMBOL Address6) from an array containing raw bytes
+     * in network byte order and scope ID.
+     *
+     * Params:
+     *  address = The address as an unsigned integer in host byte order.
+     *  scopeID = Scope ID.
+     */
+    this(ubyte[16] address, uint scopeID = 0) @nogc nothrow pure @safe
+    {
+        copy(address[], this.address[]);
+        this.scopeID = scopeID;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        const ubyte[16] expected = [ 0, 1, 0, 2, 0, 3, 0, 4,
+                                     0, 5, 0, 6, 0, 7, 0, 8 ];
+        auto actual = Address6(expected, 1);
+        assert(actual.toBytes() == expected);
+        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("::1%1") < address6("::1%2"));
+        assert(address6("::1%2") > address6("::1%1"));
+    }
+
+    /**
+     * Returns object that represents ::.
+     *
+     * Returns: Object that represents any address.
+     */
+    static Address6 any() @nogc nothrow pure @safe
+    {
+        return Address6();
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address6.any().isAny());
+    }
+
+    /**
+     * Returns object that represents ::1.
+     *
+     * Returns: Object that represents the Loopback address.
+     */
+    static Address6 loopback() @nogc nothrow pure @safe
+    {
+        typeof(return) address;
+        address.address[$ - 1] = 1;
+        return address;
+    }
+
+    ///
+    @nogc nothrow pure @safe unittest
+    {
+        assert(Address6.loopback().isLoopback());
+    }
+
+    /**
+     * :: can represent any address. This function checks whether this
+     * address is ::.
+     *
+     * Returns: $(D_KEYWORD true) if this is an unspecified address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isAny() const @nogc nothrow pure @safe
+    {
+        return this.address == any.address;
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        assert(address6("::").isAny());
+    }
+
+    /**
+     * Loopback address is ::1.
+     *
+     * Returns: $(D_KEYWORD true) if this is a loopback address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isLoopback() const @nogc nothrow pure @safe
+    {
+        return this.address == loopback.address;
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        assert(address6("::1").isLoopback());
+    }
+
+    /**
+     * Determines whether this address' destination is a group of endpoints.
+     *
+     * Returns: $(D_KEYWORD true) if this is a multicast address,
+     *          $(D_KEYWORD false) otherwise.
+     *
+     * See_Also: $(D_PSYMBOL isUnicast).
+     */
+    bool isMulticast() const @nogc nothrow pure @safe
+    {
+        return this.address[0] == 0xff;
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        assert(address6("ff00::").isMulticast());
+    }
+
+    /**
+     * Determines whether this address' destination is a single endpoint.
+     *
+     * Returns: $(D_KEYWORD true) if this is a multicast address,
+     *          $(D_KEYWORD false) otherwise.
+     *
+     * See_Also: $(D_PSYMBOL isMulticast).
+     */
+    bool isUnicast() const @nogc nothrow pure @safe
+    {
+        return !isMulticast();
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        assert(address6("::1").isUnicast());
+    }
+
+    /**
+     * Determines whether this address is a link-local unicast address.
+     *
+     * Returns: $(D_KEYWORD true) if this is a link-local address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isLinkLocal() const @nogc nothrow pure @safe
+    {
+        return this.address[0] == 0xfe && (this.address[1] & 0xc0) == 0x80;
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        assert(address6("fe80::1").isLinkLocal());
+    }
+
+    /**
+     * Determines whether this address is an Unique Local Address (ULA).
+     *
+     * Returns: $(D_KEYWORD true) if this is an Unique Local Address,
+     *          $(D_KEYWORD false) otherwise.
+     */
+    bool isUniqueLocal() const @nogc nothrow pure @safe
+    {
+        return this.address[0] == 0xfc || this.address[0] == 0xfd;
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        assert(address6("fd80:124e:34f3::1").isUniqueLocal());
+    }
+
+    /**
+     * Returns text representation of this address.
+     *
+     * Returns: text representation of this address.
+     */
+    String stringify() const @nogc nothrow pure @safe
+    {
+        String output;
+        foreach (i, b; this.address)
+        {
+            ubyte low = b & 0xf;
+            ubyte high = b >> 4;
+
+            if (high < 10)
+            {
+                output.insertBack(cast(char) (high + '0'));
+            }
+            else
+            {
+                output.insertBack(cast(char) (high - 10 + 'a'));
+            }
+            if (low < 10)
+            {
+                output.insertBack(cast(char) (low + '0'));
+            }
+            else
+            {
+                output.insertBack(cast(char) (low - 10 + 'a'));
+            }
+            if (i % 2 != 0 && i != (this.address.length - 1))
+            {
+                output.insertBack(':');
+            }
+        }
+
+        return output;
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        import tanya.algorithm.comparison : equal;
+
+        assert(equal(address6("1:2:3:4:5:6:7:8").stringify()[],
+               "0001:0002:0003:0004:0005:0006:0007:0008"));
+    }
+
+    /**
+     * Produces a byte array containing this address in network byte order.
+     *
+     * Returns: This address as raw bytes in network byte order.
+     */
+    ubyte[16] toBytes() const @nogc nothrow pure @safe
+    {
+        return this.address;
+    }
+
+    ///
+    @nogc nothrow @safe unittest
+    {
+        auto actual = address6("1:2:3:4:5:6:7:8");
+        ubyte[16] expected = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8];
+        assert(actual.toBytes() == expected);
+    }
+}
+
+private void write2Bytes(R)(ref R range, ubyte[] address)
+{
+    ushort group = readIntegral!ushort(range, 16);
+    address[0] = cast(ubyte) (group >> 8);
+    address[1] = group & 0xff;
+}
+
+/**
+ * Parses a string containing an IPv6 address.
+ *
+ * This function isn't pure since an IPv6 address can contain interface name
+ * or interface ID (separated from the address by `%`). If an interface name
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * Returns: $(D_PSYMBOL Option) containing the address if the parsing was
+ *          successful, or nothing otherwise.
+ */
+Option!Address6 address6(R)(R range)
+if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
+{
+    if (range.empty)
+    {
+        return typeof(return)();
+    }
+    Address6 result;
+    ubyte[12] tail;
+    size_t i;
+    size_t j;
+
+    // An address begins with a number, not ':'. But there is a special case
+    // if the address begins with '::'.
+    if (range.front == ':')
+    {
+        range.popFront();
+        if (range.empty || range.front != ':')
+        {
+            return typeof(return)();
+        }
+        range.popFront();
+        goto ParseTail;
+    }
+
+    // Parse the address before '::'.
+    // This loop parses the whole address if it doesn't contain '::'.
+    for (; i < 13; i += 2)
+    {
+        write2Bytes(range, result.address[i .. $]);
+        if (range.empty || range.front != ':')
+        {
+            return typeof(return)();
+        }
+        range.popFront();
+        if (range.empty)
+        {
+            return typeof(return)();
+        }
+        if (range.front == ':')
+        {
+            range.popFront();
+            goto ParseTail;
+        }
+    }
+    write2Bytes(range, result.address[14 .. $]);
+
+    if (range.empty)
+    {
+        return typeof(return)(result);
+    }
+    else if (range.front == '%')
+    {
+        goto ParseIface;
+    }
+    else
+    {
+        return typeof(return)();
+    }
+
+ParseTail: // after ::
+    // Normally the address can't end with ':', but a special case is if the
+    // address ends with '::'. So the first iteration of the loop below is
+    // unrolled to check whether the address contains something after '::' at
+    // all.
+    if (range.empty)
+    {
+        return typeof(return)(result); // ends with ::
+    }
+    if (range.front == ':')
+    {
+        return typeof(return)();
+    }
+    write2Bytes(range, tail[j .. $]);
+    if (range.empty)
+    {
+        goto CopyTail;
+    }
+    else if (range.front == '%')
+    {
+        goto ParseIface;
+    }
+    else if (range.front != ':')
+    {
+        return typeof(return)();
+    }
+    range.popFront();
+
+    for (i = 2, j = 2; i <= 11; i += 2, j += 2, range.popFront())
+    {
+        if (range.empty || range.front == ':')
+        {
+            return typeof(return)();
+        }
+        write2Bytes(range, tail[j .. $]);
+
+        if (range.empty)
+        {
+            goto CopyTail;
+        }
+        else if (range.front == '%')
+        {
+            goto ParseIface;
+        }
+        else if (range.front != ':')
+        {
+            return typeof(return)();
+        }
+    }
+
+ParseIface: // Scope name or ID
+    range.popFront();
+    if (range.empty)
+    {
+        return typeof(return)();
+    }
+    else if (isDigit(range.front))
+    {
+        const scopeID = readIntegral!uint(range);
+        if (range.empty)
+        {
+            result.scopeID = scopeID;
+        }
+        else
+        {
+            return typeof(return)();
+        }
+    }
+    else
+    {
+        result.scopeID = nameToIndex(range);
+    }
+
+CopyTail:
+    copy(tail[0 .. j + 2], result.address[$ - j - 2 .. $]);
+    return typeof(return)(result);
+}
+
+@nogc nothrow @safe unittest
+{
+    {
+        ubyte[16] expected = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8];
+        auto actual = address6("1:2:3:4:5:6:7:8");
+        assert(actual.address == expected);
+    }
+    {
+        ubyte[16] expected;
+        auto actual = address6("::");
+        assert(actual.address == expected);
+    }
+    {
+        ubyte[16] expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
+        auto actual = address6("::1");
+        assert(actual.address == expected);
+    }
+    {
+        ubyte[16] expected = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        auto actual = address6("1::");
+        assert(actual.address == expected);
+    }
+}
+
+// Rejects malformed addresses
+@nogc nothrow @safe unittest
+{
+    assert(address6("").isNothing);
+    assert(address6(":").isNothing);
+    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);
+}
+
+/**
+ * Constructs an $(D_PSYMBOL Address6) from raw bytes in network byte order and
+ * the scope ID.
+ *
+ * Params:
+ *  R       = Input range type.
+ *  range   = $(D_KEYWORD ubyte) range containing the address.
+ *  scopeID = Scope ID.
+ *
+ * Returns: $(D_PSYMBOL Option) containing the address if the $(D_PARAM range)
+ *          contains exactly 16 bytes, or nothing otherwise.
+ */
+Option!Address6 address6(R)(R range, uint scopeID = 0)
+if (isInputRange!R && is(Unqual!(ElementType!R) == ubyte))
+{
+    Address6 result;
+    int i;
+
+    for (; i < 16 && !range.empty; ++i, range.popFront())
+    {
+        result.address[i] = range.front;
+    }
+    result.scopeID = scopeID;
+
+    return range.empty && i == 16 ? typeof(return)(result) : typeof(return)();
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    {
+        ubyte[16] actual = [ 1, 2, 3, 4, 5, 6, 7, 8,
+                             9, 10, 11, 12, 13, 14, 15, 16 ];
+        assert(!address6(actual[]).isNothing);
+    }
+    {
+        ubyte[15] actual = [ 1, 2, 3, 4, 5, 6, 7, 8,
+                             9, 10, 11, 12, 13, 14, 15 ];
+        assert(address6(actual[]).isNothing);
+    }
+    {
+        ubyte[17] actual = [ 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                             10, 11, 12, 13, 14, 15, 16, 17 ];
+        assert(address6(actual[]).isNothing);
+    }
+    {
+        assert(address6(cast(ubyte[]) []).isNothing);
+    }
+}
--- a/source/tanya/network/socket.d
+++ b/source/tanya/network/socket.d
@ -498,7 +498,7 @@ struct Linger
     *
     * See_Also: $(D_PSYMBOL time).
     */
-    @property enabled(const bool value) pure nothrow @safe @nogc
+    @property void enabled(const bool value) pure nothrow @safe @nogc
    {
        this.l_onoff = value;
    }
--- a/source/tanya/range/adapter.d
+++ b/source/tanya/range/adapter.d
@ -18,6 +18,7 @@
 * 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;
@ -232,63 +233,6 @@ if (isInputRange!R)
    return Take(range, n);
 }

-///
-@nogc nothrow pure @safe unittest
-{
-    static struct InfiniteRange
-    {
-        private size_t front_ = 1;
-
-        enum bool empty = false;
-
-        @property size_t front() @nogc nothrow pure @safe
-        {
-            return this.front_;
-        }
-
-        @property void front(size_t i) @nogc nothrow pure @safe
-        {
-            this.front_ = i;
-        }
-
-        void popFront() @nogc nothrow pure @safe
-        {
-            ++this.front_;
-        }
-
-        size_t opIndex(size_t i) @nogc nothrow pure @safe
-        {
-            return this.front_ + i;
-        }
-
-        void opIndexAssign(size_t value, size_t i) @nogc nothrow pure @safe
-        {
-            this.front = i + value;
-        }
-
-        InfiniteRange save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
-    }
-
-    auto t = InfiniteRange().take(3);
-    assert(t.length == 3);
-    assert(t.front == 1);
-    assert(t.back == 3);
-
-    t.popFront();
-    assert(t.front == 2);
-    assert(t.back == 3);
-
-    t.popBack();
-    assert(t.front == 2);
-    assert(t.back == 2);
-
-    t.popFront();
-    assert(t.empty);
-}
-
 /**
 * Takes exactly $(D_PARAM n) elements from $(D_PARAM range).
 *
@ -316,60 +260,3 @@ if (isInputRange!R)
    }
    return TakeExactly(range, n);
 }
-
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct InfiniteRange
-    {
-        private size_t front_ = 1;
-
-        enum bool empty = false;
-
-        @property size_t front() @nogc nothrow pure @safe
-        {
-            return this.front_;
-        }
-
-        @property void front(size_t i) @nogc nothrow pure @safe
-        {
-            this.front_ = i;
-        }
-
-        void popFront() @nogc nothrow pure @safe
-        {
-            ++this.front_;
-        }
-
-        size_t opIndex(size_t i) @nogc nothrow pure @safe
-        {
-            return this.front_ + i;
-        }
-
-        void opIndexAssign(size_t value, size_t i) @nogc nothrow pure @safe
-        {
-            this.front = i + value;
-        }
-
-        InfiniteRange save() @nogc nothrow pure @safe
-        {
-            return this;
-        }
-    }
-
-    auto t = InfiniteRange().takeExactly(3);
-    assert(t.length == 3);
-    assert(t.front == 1);
-    assert(t.back == 3);
-
-    t.popFront();
-    assert(t.front == 2);
-    assert(t.back == 3);
-
-    t.popBack();
-    assert(t.front == 2);
-    assert(t.back == 2);
-
-    t.popFront();
-    assert(t.empty);
-}
--- a/source/tanya/range/primitive.d
+++ b/source/tanya/range/primitive.d
@ -851,6 +851,8 @@ void put(R, E)(ref R range, auto ref E 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);
@ -907,17 +909,6 @@ void put(R, E)(ref R range, auto ref E e)
    assert(oc.e == 2);
 }

-///
-@nogc nothrow pure @safe unittest
-{
-    int[2] actual;
-    int[2] expected = [2, 3];
-    auto slice = actual[];
-
-    put(slice, expected[]);
-    assert(actual == expected);
-}
-
 /**
 * Determines whether $(D_PARAM R) is an output range for the elemens of type
 * $(D_PARAM E).
@ -963,7 +954,22 @@ void put(R, E)(ref R range, auto ref E e)
 * Returns: $(D_KEYWORD true) if $(D_PARAM R) is an output range for the
 *          elements of the type $(D_PARAM E), $(D_KEYWORD false) otherwise.
 */
-enum bool isOutputRange(R, E) = is(typeof((ref R r, ref E e) => put(r, e)));
+template isOutputRange(R, E)
+{
+    static if (is(typeof((R r, E e) => put(r, e))))
+    {
+        enum bool isOutputRange = true;
+    }
+    else static if (isInputRange!E)
+    {
+        alias ET = ElementType!E;
+        enum bool isOutputRange = is(typeof((R r, ET e) => put(r, e)));
+    }
+    else
+    {
+        enum bool isOutputRange = false;
+    }
+}

 ///
@nogc nothrow pure @safe unittest
--- a/source/tanya/sys/linux/syscall.d
+++ b/source/tanya/sys/linux/syscall.d
@ -14,9 +14,15 @@ module tanya.sys.linux.syscall;

 version (TanyaNative):

+extern ptrdiff_t syscall(ptrdiff_t, ptrdiff_t)
+@nogc nothrow @system;
+
 extern ptrdiff_t syscall(ptrdiff_t, ptrdiff_t, ptrdiff_t)
@nogc nothrow @system;

+extern ptrdiff_t syscall(ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t)
+@nogc nothrow @system;
+
 extern ptrdiff_t syscall(ptrdiff_t,
                         ptrdiff_t,
                         ptrdiff_t,
@ -34,10 +40,18 @@ private template getOverloadMangling(size_t n)
 }

 pragma(mangle, getOverloadMangling!0)
-extern ptrdiff_t syscall_(ptrdiff_t, ptrdiff_t, ptrdiff_t)
+extern ptrdiff_t syscall_(ptrdiff_t, ptrdiff_t)
@nogc nothrow pure @system;

 pragma(mangle, getOverloadMangling!1)
+extern ptrdiff_t syscall_(ptrdiff_t, ptrdiff_t, ptrdiff_t)
+@nogc nothrow pure @system;
+
+pragma(mangle, getOverloadMangling!2)
+extern ptrdiff_t syscall_(ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t)
+@nogc nothrow pure @system;
+
+pragma(mangle, getOverloadMangling!3)
 extern ptrdiff_t syscall_(ptrdiff_t,
                          ptrdiff_t,
                          ptrdiff_t,
--- a/source/tanya/sys/posix/ioctl.d
+++ b/source/tanya/sys/posix/ioctl.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/. */
+
+/*
+ * 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/sys/posix/ioctl.d,
+ *                 tanya/sys/posix/ioctl.d)
+ */
+module tanya.sys.posix.ioctl;
+
+version (TanyaNative):
+
+enum
+{
+    SIOCADDRT = 0x890B, // Add routing table entry.
+    SIOCDELRT = 0x890C, // Delete routing table entry.
+    SIOCRTMSG = 0x890D, // Call to routing system.
+
+    SIOCGIFNAME = 0x8910, // Get iface name.
+    SIOCSIFLINK = 0x8911, // Set iface channel.
+    SIOCGIFCONF = 0x8912, // Get iface list.
+    SIOCGIFFLAGS = 0x8913, // Get flags.
+    SIOCSIFFLAGS = 0x8914, // Set flags.
+    SIOCGIFADDR = 0x8915, // Get PA address.
+    SIOCSIFADDR = 0x8916, // Set PA address.
+    SIOCGIFDSTADDR = 0x8917, // Get remote PA address.
+    SIOCSIFDSTADDR = 0x8918, // Set remote PA address.
+    SIOCGIFBRDADDR = 0x8919, // Get broadcast PA address.
+    SIOCSIFBRDADDR = 0x891a, // Set broadcast PA address.
+    SIOCGIFNETMASK = 0x891b, // Get network PA mask.
+    SIOCSIFNETMASK = 0x891c, // Set network PA mask.
+    SIOCGIFMETRIC = 0x891d, // Get metric.
+    SIOCSIFMETRIC = 0x891e, // Set metric.
+    SIOCGIFMEM = 0x891f, // Get memory address (BSD).
+    SIOCSIFMEM = 0x8920, // Set memory address (BSD).
+    SIOCGIFMTU = 0x8921, // Get MTU size.
+    SIOCSIFMTU = 0x8922, // Set MTU size.
+    SIOCSIFNAME = 0x8923, // Set interface name.
+    SIOCSIFHWADDR = 0x8924, // Set hardware address.
+    SIOCGIFENCAP = 0x8925, // Get/set encapsulations.
+    SIOCSIFENCAP = 0x8926,
+    SIOCGIFHWADDR = 0x8927, // Get hardware address.
+    SIOCGIFSLAVE = 0x8929, // Driver slaving support.
+    SIOCSIFSLAVE = 0x8930,
+    SIOCADDMULTI = 0x8931, // Multicast address lists.
+    SIOCDELMULTI = 0x8932,
+    SIOCGIFINDEX = 0x8933, // Name -> if_index mapping.
+    SIOGIFINDEX = SIOCGIFINDEX, // Misprint compatibility.
+    SIOCSIFPFLAGS = 0x8934, // Set/get extended flags set.
+    SIOCGIFPFLAGS = 0x8935,
+    SIOCDIFADDR = 0x8936, // Delete PA address.
+    SIOCSIFHWBROADCAST = 0x8937, // Set hardware broadcast address.
+    SIOCGIFCOUNT = 0x8938, // Get number of devices.
+
+    SIOCGIFBR = 0x8940, // Bridging support.
+    SIOCSIFBR = 0x8941, // Set bridging options.
+
+    SIOCGIFTXQLEN = 0x8942, // Get the tx queue length.
+    SIOCSIFTXQLEN = 0x8943, // Set the tx queue length.
+
+    SIOCDARP = 0x8953, // Delete ARP table entry.
+    SIOCGARP = 0x8954, // Get ARP table entry.
+    SIOCSARP = 0x8955, // Set ARP table entry.
+
+    SIOCDRARP = 0x8960, // Delete RARP table entry.
+    SIOCGRARP = 0x8961, // Get RARP table entry.
+    SIOCSRARP = 0x8962, // Set RARP table entry.
+
+    SIOCGIFMAP = 0x8970, // Get device parameters.
+    SIOCSIFMAP = 0x8971, // Set device parameters.
+
+    SIOCADDDLCI = 0x8980, // Create new DLCI device.
+    SIOCDELDLCI = 0x8981, // Delete DLCI device.
+}
--- a/source/tanya/sys/posix/net/if_.d
+++ b/source/tanya/sys/posix/net/if_.d
@ -0,0 +1,27 @@
+/* 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/. */
+
+/*
+ * 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/sys/posix/net/if_.d,
+ *                 tanya/sys/posix/net/if_.d)
+ */
+module tanya.sys.posix.net.if_;
+
+version (TanyaNative):
+
+enum size_t IF_NAMESIZE = 16;
+
+struct ifreq
+{
+    char[IF_NAMESIZE] ifr_name;
+
+    union
+    {
+        int ifr_ifindex;
+    }
+}
--- a/source/tanya/sys/posix/socket.d
+++ b/source/tanya/sys/posix/socket.d
@ -0,0 +1,152 @@
+/* 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/. */
+
+/*
+ * 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/sys/posix/socket.d,
+ *                 tanya/sys/posix/socket.d)
+ */
+module tanya.sys.posix.socket;
+
+version (TanyaNative):
+
+/*
+ * Protocol families.
+ */
+enum
+{
+    PF_UNSPEC = 0, // Unspecified.
+    PF_LOCAL = 1, // Local to host (pipes and file-domain).
+    PF_UNIX = PF_LOCAL, // POSIX name for PF_LOCAL.
+    PF_FILE = PF_LOCAL, // Another non-standard name for PF_LOCAL.
+    PF_INET = 2, // IP protocol family.
+    PF_AX25 = 3, // Amateur Radio AX.25.
+    PF_IPX = 4, // Novell Internet Protocol.
+    PF_APPLETALK = 5, // Appletalk DDP.
+    PF_NETROM = 6, // Amateur radio NetROM.
+    PF_BRIDGE = 7, // Multiprotocol bridge.
+    PF_ATMPVC = 8, // ATM PVCs.
+    PF_X25 = 9, // Reserved for X.25 project.
+    PF_INET6 = 10, // IP version 6.
+    PF_ROSE = 11, // Amateur Radio X.25 PLP.
+    PF_DECnet = 12, // Reserved for DECnet project.
+    PF_NETBEUI = 13, // Reserved for 802.2LLC project.
+    PF_SECURITY = 14, // Security callback pseudo AF.
+    PF_KEY = 15, // PF_KEY key management API.
+    PF_NETLINK = 16, // Kernel user interface device.
+    PF_ROUTE = PF_NETLINK, // Alias to emulate 4.4BSD.
+    PF_PACKET = 17, // Packet family.
+    PF_ASH = 18, // Ash.
+    PF_ECONET = 19, // Acorn Econet.
+    PF_ATMSVC = 20, // ATM SVCs.
+    PF_RDS = 21, // RDS sockets.
+    PF_SNA = 22, // Linux SNA Project.
+    PF_IRDA = 23, // IRDA sockets.
+    PF_PPPOX = 24, // PPPoX sockets.
+    PF_WANPIPE = 25, // Wanpipe API sockets.
+    PF_LLC = 26, // Linux LLC.
+    PF_IB = 27, // Native InfiniBand address.
+    PF_MPLS = 28, // MPLS.
+    PF_CAN = 29, // Controller Area Network.
+    PF_TIPC = 30, // TIPC sockets.
+    PF_BLUETOOTH = 31, // Bluetooth sockets.
+    PF_IUCV = 32, // IUCV sockets.
+    PF_RXRPC = 33, // RxRPC sockets.
+    PF_ISDN = 34, // mISDN sockets.
+    PF_PHONET = 35, // Phonet sockets.
+    PF_IEEE802154 = 36, // IEEE 802.15.4 sockets.
+    PF_CAIF = 37, // CAIF sockets.
+    PF_ALG = 38, // Algorithm sockets.
+    PF_NFC = 39, // NFC sockets.
+    PF_VSOCK = 40, // vSockets.
+    PF_MAX = 41, // For now.
+}
+
+/*
+ * Address families.
+ */
+enum
+{
+    AF_UNSPEC = PF_UNSPEC,
+    AF_LOCAL = PF_LOCAL,
+    AF_UNIX = PF_UNIX,
+    AF_FILE = PF_FILE,
+    AF_INET = PF_INET,
+    AF_AX25 = PF_AX25,
+    AF_IPX = PF_IPX,
+    AF_APPLETALK = PF_APPLETALK,
+    AF_NETROM = PF_NETROM,
+    AF_BRIDGE = PF_BRIDGE,
+    AF_ATMPVC = PF_ATMPVC,
+    AF_X25 = PF_X25,
+    AF_INET6 = PF_INET6,
+    AF_ROSE = PF_ROSE,
+    AF_DECnet = PF_DECnet,
+    AF_NETBEUI = PF_NETBEUI,
+    AF_SECURITY = PF_SECURITY,
+    AF_KEY = PF_KEY,
+    AF_NETLINK = PF_NETLINK,
+    AF_ROUTE = PF_ROUTE,
+    AF_PACKET = PF_PACKET,
+    AF_ASH = PF_ASH,
+    AF_ECONET = PF_ECONET,
+    AF_ATMSVC = PF_ATMSVC,
+    AF_RDS = PF_RDS,
+    AF_SNA = PF_SNA,
+    AF_IRDA = PF_IRDA,
+    AF_PPPOX = PF_PPPOX,
+    AF_WANPIPE = PF_WANPIPE,
+    AF_LLC = PF_LLC,
+    AF_IB = PF_IB,
+    AF_MPLS = PF_MPLS,
+    AF_CAN = PF_CAN,
+    AF_TIPC = PF_TIPC,
+    AF_BLUETOOTH = PF_BLUETOOTH,
+    AF_IUCV = PF_IUCV,
+    AF_RXRPC = PF_RXRPC,
+    AF_ISDN = PF_ISDN,
+    AF_PHONET = PF_PHONET,
+    AF_IEEE802154 = PF_IEEE802154,
+    AF_CAIF = PF_CAIF,
+    AF_ALG = PF_ALG,
+    AF_NFC = PF_NFC,
+    AF_VSOCK = PF_VSOCK,
+    AF_MAX = PF_MAX,
+}
+
+/*
+ * Types of sockets.
+ */
+enum
+{
+    // Sequenced, reliable, connection-based byte streams.
+    SOCK_STREAM = 1,
+    // Connectionless, unreliable datagrams of fixed maximum length.
+    SOCK_DGRAM = 2,
+    // Raw protocol interface.
+    SOCK_RAW = 3,
+    // Reliably-delivered messages.
+    SOCK_RDM = 4,
+    // Sequenced, reliable, connection-based, datagrams of fixed maximum
+    // length.
+    SOCK_SEQPACKET = 5,
+    // Datagram Congestion Control Protocol.
+    SOCK_DCCP = 6,
+    // Linux specific way of getting packets at the dev level. For writing rarp
+    // and other similar things on the user level.
+    SOCK_PACKET = 10,
+}
+
+/*
+ * Flags to be ORed into the type parameter of socket and socketpair and used
+ * for the flags parameter of paccept.
+ */
+enum
+{
+    SOCK_CLOEXEC = 0x80000, // Atomically set close-on-exec flag for the new descriptor(s).
+    SOCK_NONBLOCK = 0x800, // Atomically mark descriptor(s) as non-blocking.
+}
--- a/source/tanya/sys/windows/def.d
+++ b/source/tanya/sys/windows/def.d
@ -30,6 +30,7 @@ version (Windows):
 alias BYTE = ubyte;
 alias TBYTE = wchar; // If Unicode, otherwise char.
 alias CHAR = char; // Signed or unsigned char.
+alias WCHAR = wchar;
 alias TCHAR = wchar; // If Unicode, otherwise char.
 alias SHORT = short;
 alias USHORT = ushort;
@ -52,6 +53,10 @@ enum HANDLE INVALID_HANDLE_VALUE = cast(HANDLE) -1;
 enum TRUE = 1;
 enum FALSE = 0;

+alias PSTR = CHAR*;
+alias PWSTR = WCHAR*;
+alias PTSTR = TCHAR*;
+
 align(1) struct GUID
 {
    uint Data1;
--- a/source/tanya/sys/windows/ifdef.d
+++ b/source/tanya/sys/windows/ifdef.d
@ -0,0 +1,30 @@
+/* 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/. */
+
+/**
+ * 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/sys/windows/ifdef.d,
+ *                 tanya/sys/windows/ifdef.d)
+ */
+module tanya.sys.windows.ifdef;
+
+version (Windows):
+
+import tanya.sys.windows.def;
+
+union NET_LUID_LH
+{
+    ulong Value;
+    ulong Info;
+}
+
+alias NET_LUID = NET_LUID_LH;
+alias IF_LUID = NET_LUID_LH;
+
+alias NET_IFINDEX = ULONG;
+
+enum size_t IF_MAX_STRING_SIZE = 256;
--- a/source/tanya/sys/windows/iphlpapi.d
+++ b/source/tanya/sys/windows/iphlpapi.d
@ -0,0 +1,39 @@
+/* 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/. */
+
+/**
+ * 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/sys/windows/iphlpapi.d,
+ *                 tanya/sys/windows/iphlpapi.d)
+ */
+module tanya.sys.windows.iphlpapi;
+
+version (Windows):
+
+import tanya.sys.windows.def;
+import tanya.sys.windows.ifdef;
+
+extern(Windows)
+DWORD ConvertInterfaceNameToLuidA(const(CHAR)* InterfaceName,
+                                  NET_LUID* InterfaceLuid)
+@nogc nothrow @system;
+
+extern(Windows)
+DWORD ConvertInterfaceLuidToIndex(const(NET_LUID)* InterfaceLuid,
+                                  NET_IFINDEX* InterfaceIndex)
+@nogc nothrow @system;
+
+extern(Windows)
+DWORD ConvertInterfaceIndexToLuid(NET_IFINDEX InterfaceIndex,
+                                  NET_LUID* InterfaceLuid)
+@nogc nothrow @system;
+
+extern(Windows)
+DWORD ConvertInterfaceLuidToNameA(const(NET_LUID)* InterfaceLuid,
+                                  PSTR InterfaceName,
+                                  size_t Length)
+@nogc nothrow @system;
--- a/source/tanya/sys/windows/package.d
+++ b/source/tanya/sys/windows/package.d
@ -15,5 +15,7 @@ module tanya.sys.windows;
 version (Windows):

 public import tanya.sys.windows.def;
+public import tanya.sys.windows.ifdef;
+public import tanya.sys.windows.iphlpapi;
 public import tanya.sys.windows.winbase;
 public import tanya.sys.windows.winsock2;
--- a/source/tanya/typecons.d
+++ b/source/tanya/typecons.d
@ -19,7 +19,8 @@ module tanya.typecons;

 import tanya.algorithm.mutation;
 import tanya.format;
-import tanya.meta.metafunction : AliasSeq, AliasTuple = Tuple, Map;
+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...)
 {
@ -49,13 +52,13 @@ template Tuple(Specs...)
            static if (is(typeof(Specs[1]) == string))
            {
                alias parseSpecs
-                    = AliasSeq!(AliasTuple!(Specs[0], Specs[1]),
+                    = AliasSeq!(Pack!(Specs[0], Specs[1]),
                                parseSpecs!(fieldCount + 1, Specs[2 .. $]));
            }
            else
            {
                alias parseSpecs
-                    = AliasSeq!(AliasTuple!(Specs[0]),
+                    = AliasSeq!(Pack!(Specs[0]),
                                parseSpecs!(fieldCount + 1, Specs[1 .. $]));
            }
        }
@ -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);
+}
Author	SHA1	Message	Date
Eugen Wissner	c5eb2f27be	Add algorithm.iteration	2018-09-28 05:40:33 +02:00
Eugen Wissner	349e6dfede	Create separate travis job for D-Scanner	2018-09-26 06:30:05 +02:00
Eugen Wissner	fd133554f3	net.ip: Implement opCmp. Fix #63	2018-09-24 06:45:44 +02:00
Eugen Wissner	9ac56c50f1	typecons: Add option constructor function	2018-09-23 06:59:41 +02:00
Eugen Wissner	03b45ae441	Add typecons.tuple(), Tuple construction function	2018-09-22 07:32:30 +02:00
Eugen Wissner	31d4f30a49	functional.forward: Fix template visibility bug Because of the private template forwardOne, forward couldn't be used in other modules. forwardOne cannot be a local template either since it accepts an alias as its template parameter.	2018-09-21 06:23:59 +02:00
Eugen Wissner	180c4d3956	typecons.Option: Implement toHash forwarder	2018-09-18 22:27:54 +02:00
Eugen Wissner	b0dc7b59e5	Add predicate support for algorithm.comparison.equal	2018-09-17 19:17:39 +02:00
Eugen Wissner	eb796e0ddf	Add bitmanip.BitFlags	2018-09-16 19:07:55 +02:00
Eugen Wissner	e5569e5fea	meta.trait.EnumMembers: Fix one-member enums Produce a tuple for an enum with only one member.	2018-09-15 06:06:17 +02:00
Eugen Wissner	b831a05407	Introduce hash.lookup.isHashFunction trait Fix #66.	2018-09-14 15:16:08 +02:00
Eugen Wissner	b6d1766d58	Implement compare algorithm. Fix #50	2018-09-11 10:05:15 +02:00
Eugen Wissner	7f080831c5	Implement IPv6 parser, fix #49	2018-09-08 07:20:23 +02:00
Eugen Wissner	94c7fd2231	Move range.adapter to algorithms + take() bugfixes A lot of algorithms like lazy sort() can be also classified as adapters since it wraps the original range and allows to access the elements of the range in a particular order. The only reason why take() was in range.adapter is that take() is trivial - it doesn't change the order of elements but can turn an infinite range into finite one. This distinction between trivial and non-trivial algorithms isn't absolutely clear. So let us put all algorithms and any adapters that change the range iteration in some way into "algorithm" package to avoid any confusion later. - range.adapter is renamed into algorithm.iteration - range.adapter is deprecated - Added missing imports for take() and takeExactly() - takeExactly() doesn't wrap ranges that have slicing anymore - Voldemort structs for take() takeExactly() are now static	2018-09-06 12:50:42 +02:00
Eugen Wissner	5ba6d35a1b	Use fixed dscanner version	2018-09-03 09:55:19 +02:00
Eugen Wissner	09f434f631	net.iface: Add indexToName	2018-09-02 10:00:52 +02:00
Eugen Wissner	1f615301e5	memory.op: Add findNullTerminated	2018-09-02 08:27:26 +02:00
Eugen Wissner	131675d0a8	Parse for the main part of an IPv6 address	2018-09-01 11:02:10 +02:00
Eugen Wissner	aa12aa9014	Add module for network interfaces	2018-09-01 10:15:23 +02:00
Eugen Wissner	41878cde50	Fix #60 : Copying overlapping array slices	2018-08-30 07:12:38 +02:00
Eugen Wissner	0fc0aa23f7	Add constants and syscall for if_nametoindex	2018-08-28 20:39:45 +02:00
Eugen Wissner	c205c087a4	Switch to COFF on x86 Windows	2018-08-26 00:10:17 +02:00
Eugen Wissner	8ca88d1f01	net.ip.Address4: Reject malformed addresses	2018-08-22 06:51:20 +02:00
Eugen Wissner	fa4cbb7e59	Update to 2.081.2. Remove old compilers	2018-08-17 05:44:58 +02:00
Eugen Wissner	4653e94fa1	Merge remote-tracking branch 'n8sh/relax-hasher-reqs'	2018-08-12 06:17:12 +02:00
Eugen Wissner	ba5833318b	conv: Fix taking out of range chars for hex values	2018-08-11 14:42:09 +02:00
Eugen Wissner	918d8f5450	Deprecated putting an input into an output range Use copy instead.	2018-08-10 15:34:07 +02:00
Eugen Wissner	2862cc6f50	Update asm mangling to match GDC's D frontend	2018-08-08 10:27:23 +02:00
Eugen Wissner	aa4ccddf47	Add net.ip. Fix #48	2018-08-07 22:27:09 +02:00
Nathan Sashihara	22cffe9d6e	Set: allow hasher to take arg by ref	2018-08-06 14:41:47 -04:00
Eugen Wissner	abd286064b	Add algorithm.mutation.copy	2018-08-05 07:19:30 +02:00
Eugen Wissner	b04928d2c8	net.inet: Import range.array as well	2018-08-03 16:52:34 +02:00
Nathan Sashihara	ceb8e6a113	Use identity hash for integers and pointers This is appropriate because HashArray in tanya.container.entry uses prime numbers instead of powers of 2 for its number of buckets so there is no pitfall if the hashes are all multiples of some power of 2.	2018-08-02 12:37:02 -04:00
Eugen Wissner	900a7172bf	Make format() public Make format() public. Deprecate to!String.	2018-08-01 16:58:23 +02:00
Eugen Wissner	fe0576a2d6	Fix format printing only the first argument	2018-07-29 12:51:38 +02:00
Eugen Wissner	a5b84deca7	format: Add errol3 lookup	2018-07-28 13:52:59 +02:00
Eugen Wissner	24056d53c5	network.socket.Linger.enabled: Add return type network.socket.Linger.enabled: Add missing return type (void).	2018-07-25 05:40:49 +02:00
Eugen Wissner	d62f29abd1	Rename meta.metafunction.Tuple into Pack typecons.Tuples and meta.metafunction.Tuples are often used together, from the same module. So it is reasonable give them different names.	2018-07-24 20:16:21 +02:00
Eugen Wissner	f2eb99bab0	Format fixed-point numbers	2018-07-22 15:28:17 +02:00