Add algorithm.iteration

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.

.travis.yml

@@ -1,39 +1,47 @@
 sudo: false
 
 os:
-  - linux
+- linux
-  - osx
+- osx
 
 language: d
 
 d:
-  - dmd-2.081.0
+- dmd-2.082.0
-  - dmd-2.080.1
+- dmd-2.081.2
-  - dmd-2.079.1
-  - dmd-2.078.3
 
 env:
   matrix:
-    - ARCH=x86_64
+  - ARCH=x86_64
-    - ARCH=x86
+  - 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
+- if [ "`$DC --version | head -n 1 | grep 'v2.082.0'`" ] &&
-      export UNITTEST="unittest-cov";
+     [ -z "$DSCANNER" ]; then
-    fi
+    export UNITTEST="unittest-cov";
+  fi
 
 script:
-  - dub test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC
+- if [ -z "$DSCANNER" ]; then
-  - if [ "$UNITTEST" ] && [ "$ARCH" = "x86_64" ] && [ "$TRAVIS_OS_NAME" = "linux" ];
+    dub test -b ${UNITTEST:-unittest} --arch=$ARCH --compiler=$DC;
-    then
+  else
-      dub fetch dscanner;
+    dub fetch dscanner --version=$DSCANNER;
-      dub run dscanner -- --styleCheck ./source/;
+
-    fi
+    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)

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       |
+| DMD     | GCC    |
-|:-------:|:---------:|
+|:-------:|:------:|
-| 2.081.1 | *master*  |
+| 2.082.0 | gdc-8  |
-| 2.080.1 |           |
+| 2.081.2 | gdc-7  |
-| 2.079.1 |           |
-| 2.078.3 |           |
 
 ### Release management
 

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
+      DVersion: 2.081.2
-      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
       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";

arch/x64/linux/memory/cmp.S

@@ -8,10 +8,9 @@
  * rdx - r2 length.
  * rcx - r2 data.
  */
-	.globl _D5tanya6memory2op9cmpMemoryFNaNbNixAvxAvZi
+	.globl _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi
-	.type _D5tanya6memory2op9cmpMemoryFNaNbNixAvxAvZi, @function
+	.type _D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi, @function
-
+_D5tanya6memory2op9cmpMemoryFNaNbNixAvxQdZi:
-_D5tanya6memory2op9cmpMemoryFNaNbNixAvxAvZi:
 		// Compare the lengths
 		cmp %rdx, %rdi
 		jl  less

arch/x64/linux/syscall.S

@@ -11,10 +11,11 @@ The returned value is placed in %rax.
 */
 	.text
 
-	.globl syscall1
+// 1 parameter.
-	.type syscall1, @function
+	.globl _D5tanya3sys5linux7syscallQiFNbNillZl
+	.type _D5tanya3sys5linux7syscallQiFNbNillZl, @function
 
-syscall1:
+_D5tanya3sys5linux7syscallQiFNbNillZl:
 	movq %rsi, %rax // Syscall number.
 
 	syscall
@@ -23,10 +24,10 @@ syscall1:
 
 
 // 2 parameters.
-	.globl _D5tanya3sys5linux7syscall7syscallFNbNilllZl
+	.globl _D5tanya3sys5linux7syscallQiFNbNilllZl
-	.type _D5tanya3sys5linux7syscall7syscallFNbNilllZl, @function
+	.type _D5tanya3sys5linux7syscallQiFNbNilllZl, @function
 
-_D5tanya3sys5linux7syscall7syscallFNbNilllZl:
+_D5tanya3sys5linux7syscallQiFNbNilllZl:
 	movq %rdx, %rax
 
 	syscall
@@ -34,11 +35,23 @@ _D5tanya3sys5linux7syscall7syscallFNbNilllZl:
 	ret
 
 
-// 6 parameters.
+// 3 parameters.
-	.globl _D5tanya3sys5linux7syscall7syscallFNbNilllllllZl
+	.globl _D5tanya3sys5linux7syscallQiFNbNillllZl
-	.type _D5tanya3sys5linux7syscall7syscallFNbNilllllllZl, @function
+	.type _D5tanya3sys5linux7syscallQiFNbNillllZl, @function
 
-_D5tanya3sys5linux7syscall7syscallFNbNilllllllZl:
+_D5tanya3sys5linux7syscallQiFNbNillllZl:
+	movq %rcx, %rax
+
+	syscall
+
+	ret
+
+
+// 6 parameters.
+	.globl _D5tanya3sys5linux7syscallQiFNbNilllllllZl
+	.type _D5tanya3sys5linux7syscallQiFNbNilllllllZl, @function
+
+_D5tanya3sys5linux7syscallQiFNbNilllllllZl:
 	pushq %rbp
 	movq %rsp, %rbp
 

dub.json

@@ -34,5 +34,7 @@
 		}
 	],
 
-	"libs-windows": ["advapi32"]
+	"libs-windows": ["advapi32"],
+	"libs-windows-x86_mscoff": ["iphlpapi"],
+	"libs-windows-x86_64": ["iphlpapi"]
 }

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.
+ *  pred = Predicate used to compare individual element pairs.
- *  R2 = Second range type.
+ *  R1   = First range type.
- *  r1 = First range.
+ *  R2   = Second range type.
- *  r2 = Second range.
+ *  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)
+bool equal(alias pred = (auto ref a, auto ref b) => a == b, R1, R2)
-if (allSatisfy!(isInputRange, R1, R2) && is(typeof(r1.front == r2.front)))
+          (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);
+    }
+}

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);
+}

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);
+}

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;

source/tanya/async/event/iocp.d

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

source/tanya/async/event/selector.d

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

source/tanya/async/loop.d

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

source/tanya/bitmanip.d

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

source/tanya/container/array.d

@@ -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;
         }

source/tanya/container/hashtable.d

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

source/tanya/container/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)));
+}

source/tanya/container/string.d

@@ -26,9 +26,8 @@
  */
 module tanya.container.string;
 
-import std.algorithm.comparison : cmp;
+import std.algorithm.mutation : bringToFront;
-import std.algorithm.mutation : bringToFront, copy;
+import std.algorithm.searching : count;
-import std.algorithm.searching;
 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],
+        return compare(this.data[0 .. length],
-                   that.begin[0 .. that.end - that.begin]);
+                       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],
+        return compare(this.data[0 .. length],
-                   that.begin[0 .. that.end - that.begin]);
+                       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);
     }
 
     ///

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
 {

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 .. $]));
+        }
     }
 }
 

source/tanya/hash/lookup.d

@@ -636,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));
+}

source/tanya/math/mp.d

@@ -14,17 +14,16 @@
  */
 module tanya.math.mp;
 
-import std.algorithm.comparison : cmp;
+import std.algorithm.mutation : fill;
-import std.algorithm.mutation : copy, fill, reverse;
-import std.range;
 import tanya.algorithm.comparison;
+import tanya.algorithm.iteration;
 import tanya.algorithm.mutation;
 import tanya.container.array;
 import tanya.encoding.ascii;
 import tanya.memory;
-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],
+        copy(value.rep[0 .. value.size], this.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));
+            array[i] = (cast(ubyte) (tmp.rep[0] & 0xff));
-            tmp >>= 8;
         }
-        while (tmp != 0);
-
-        array[].reverse();
 
         return array;
     }

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

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;

source/tanya/meta/trait.d

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

source/tanya/net/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);
+}

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);
+    }
+}

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);
-}

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

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,

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.
+}

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;
+    }
+}

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.
+}

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;

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;

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;

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;

source/tanya/typecons.d

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