net.ip.Address6.toString() recommended notation

Fix #65.

.travis.yml

@@ -7,12 +7,13 @@ os:
 language: d
 
 d:
+- dmd-2.084.1
 - dmd-2.083.1
 - dmd-2.082.1
 
 env:
   global:
-  - LATEST=2.083.1
+  - LATEST=2.084.1
 
   matrix:
   - ARCH=x86_64
@@ -22,7 +23,7 @@ matrix:
   include:
   - name: D-Scanner
     d: dmd-$LATEST
-    env: DSCANNER=0.5.11
+    env: DSCANNER=0.6.0
     os: linux
   - name: DDoc
     d: dmd-$LATEST
@@ -31,7 +32,7 @@ matrix:
   allow_failures:
   - name: D-Scanner
     d: dmd-$LATEST
-    env: DSCANNER=0.5.11
+    env: DSCANNER=0.6.0
     os: linux
 
 addons:

README.md

@@ -175,8 +175,9 @@ parameter is used)
 
 | DMD     | GCC             |
 |:-------:|:---------------:|
-| 2.083.1 | gdc-8 (2.081.2) |
+| 2.084.1 | gdc-8 (2.081.2) |
-| 2.082.1 | gdc-7 (2.081.2) |
+| 2.083.1 | gdc-7 (2.081.2) |
+| 2.082.1 |                 |
 
 ### Release management
 

appveyor.yml

@@ -3,6 +3,12 @@ os: Visual Studio 2015
 
 environment:
   matrix:
+    - DC: dmd
+      DVersion: 2.084.1
+      arch: x64
+    - DC: dmd
+      DVersion: 2.084.1
+      arch: x86
     - DC: dmd
       DVersion: 2.083.1
       arch: x64

source/tanya/algorithm/iteration.d

@@ -22,7 +22,10 @@ module tanya.algorithm.iteration;
 
 import tanya.algorithm.comparison;
 import tanya.algorithm.mutation;
+import tanya.meta.trait;
+import tanya.meta.transform;
 import tanya.range;
+import tanya.typecons;
 version (unittest) import tanya.test.stub;
 
 private struct Take(R, bool exactly)
@@ -646,3 +649,207 @@ if (isBidirectionalRange!Range)
     actual[2] = 10;
     assert(given[1] == 10);
 }
+
+private struct SingletonByValue(E)
+{
+    private Option!E element;
+
+    @disable this();
+
+    private this(U)(ref U element)
+    if (is(U == E))
+    {
+        this.element = move(element);
+    }
+
+    private this(U)(ref U element)
+    if (is(Unqual!U == Option!(Unqual!E)) || is(Unqual!U == Option!(const E)))
+    {
+        if (!element.isNothing)
+        {
+            this.element = element.get;
+        }
+    }
+
+    @property ref inout(E) front() inout
+    in (!empty)
+    {
+        return this.element.get;
+    }
+
+    alias back = front;
+
+    void popFront()
+    in (!empty)
+    {
+        this.element.reset();
+    }
+
+    alias popBack = popFront;
+
+    @property bool empty() const
+    {
+        return this.element.isNothing;
+    }
+
+    @property size_t length() const
+    {
+        return !this.element.isNothing;
+    }
+
+    auto save()
+    {
+        return SingletonByValue!E(this.element);
+    }
+
+    auto save() const
+    {
+        return SingletonByValue!(const E)(this.element);
+    }
+
+    ref inout(E) opIndex(size_t i) inout
+    in (!empty)
+    in (i == 0)
+    {
+        return this.element.get;
+    }
+}
+
+private struct SingletonByRef(E)
+{
+    private E* element;
+
+    @disable this();
+
+    private this(return ref E element) @trusted
+    {
+        this.element = &element;
+    }
+
+    @property ref inout(E) front() inout return
+    in (!empty)
+    {
+        return *this.element;
+    }
+
+    alias back = front;
+
+    void popFront()
+    in (!empty)
+    {
+        this.element = null;
+    }
+
+    alias popBack = popFront;
+
+    @property bool empty() const
+    {
+        return this.element is null;
+    }
+
+    @property size_t length() const
+    {
+        return this.element !is null;
+    }
+
+    auto save() return
+    {
+        return typeof(this)(*this.element);
+    }
+
+    auto save() const return
+    {
+        return SingletonByRef!(const E)(*this.element);
+    }
+
+    ref inout(E) opIndex(size_t i) inout return
+    in (!empty)
+    in (i == 0)
+    {
+        return *this.element;
+    }
+}
+
+/**
+ * Creates a bidirectional and random-access range with the single element
+ * $(D_PARAM element).
+ *
+ * If $(D_PARAM element) is passed by value the resulting range stores it
+ * internally. If $(D_PARAM element) is passed by reference, the resulting
+ * range keeps only a pointer to the element.
+ *
+ * Params:
+ *  E       = Element type.
+ *  element = Element.
+ *
+ * Returns: A range with one element.
+ */
+auto singleton(E)(return E element)
+if (isMutable!E)
+{
+    return SingletonByValue!E(element);
+}
+
+/// ditto
+auto singleton(E)(return ref E element)
+{
+    return SingletonByRef!E(element);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    auto singleChar = singleton('a');
+
+    assert(singleChar.length == 1);
+    assert(singleChar.front == 'a');
+
+    singleChar.popFront();
+    assert(singleChar.empty);
+}
+
+// Singleton range is bidirectional and random-access
+@nogc nothrow pure @safe unittest
+{
+    static assert(isBidirectionalRange!(typeof(singleton('a'))));
+    static assert(isRandomAccessRange!(typeof(singleton('a'))));
+
+    assert({ char a; return isBidirectionalRange!(typeof(singleton(a))); });
+    assert({ char a; return isRandomAccessRange!(typeof(singleton(a))); });
+}
+
+@nogc nothrow pure @safe unittest
+{
+    char a = 'a';
+    auto single = singleton(a);
+
+    assert(single.front == 'a');
+    assert(single.back == 'a');
+    assert(single[0] == 'a');
+    assert(single.length == 1);
+    assert(!single.empty);
+}
+
+// popFront makes SingletonByRef empty
+@nogc nothrow pure @safe unittest
+{
+    char a = 'a';
+    auto single = singleton(a);
+
+    single.popFront();
+    assert(single.empty);
+    assert(single.length == 0);
+    assert(single.empty);
+}
+
+// popBack makes SingletonByRef empty
+@nogc nothrow pure @safe unittest
+{
+    char a = 'b';
+    auto single = singleton(a);
+
+    single.popBack();
+    assert(single.empty);
+    assert(single.length == 0);
+    assert(single.empty);
+}

source/tanya/algorithm/mutation.d

@@ -309,7 +309,7 @@ void swap(T)(ref T a, ref T b) @trusted
  *               $(D_PARAM source) elements.
  */
 Target copy(Source, Target)(Source source, Target target)
-if (isInputRange!Source && isOutputRange!(Target, Source))
+if (isInputRange!Source && isOutputRange!(Target, ElementType!Source))
 in
 {
     static if (hasLength!Source && hasLength!Target)
@@ -389,12 +389,9 @@ do
     static struct OutPutRange
     {
         int value;
-        void put(int value) @nogc nothrow pure @safe
+
-        in
+        void opCall(int value) @nogc nothrow pure @safe
-        {
+        in (this.value == 0)
-            assert(this.value == 0);
-        }
-        do
         {
             this.value = value;
         }

source/tanya/format.d

@@ -17,11 +17,19 @@
  * To escape `{` or `}`, use `{{` and `}}` respectively. `{{` will be outputted
  * as a single `{`, `}}` - as a single `}`.
  *
- * If a custom data type (like $(D_KEYWORD struct) or $(D_KEYWORD class))
+ * To define the string representation for a custom data type (like
- * defines a `stringify()` function that is callable without arguments and
+ * $(D_KEYWORD class) or $(D_KEYWORD struct)), `toString()`-function can be
- * returns a $(D_PSYMBOL String), this function is used to produce a string
+ * implemented for that type. `toString()` should be $(D_KEYWORD const) and
- * representation for the value. String conversions for the most built-in
+ * accept exactly one argument: an output range for `const(char)[]`. It should
- * data types a also available.
+ * return the same output range, advanced after putting the corresponding value
+ * into it. That is `toString()` signature should look like:
+ *
+ * ---
+ * OR toString(OR)(OR range) const
+ * if (isOutputRange!(OR, const(char)[]));
+ * ---
+ *
+ * String conversions for the most built-in data types a also available.
  *
  * $(D_KEYWORD char), $(D_KEYWORD wchar) and $(D_KEYWORD dchar) ranges are
  * outputted as plain strings (without any delimiters between their elements).
@@ -30,7 +38,7 @@
  *
  * More advanced formatting is currently not implemented.
  *
- * Copyright: Eugene Wissner 2017-2018.
+ * Copyright: Eugene Wissner 2017-2019.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
  * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
@@ -47,8 +55,7 @@ static import tanya.memory.op;
 import tanya.meta.metafunction;
 import tanya.meta.trait;
 import tanya.meta.transform;
-import tanya.range.array;
+import tanya.range;
-import tanya.range.primitive;
 import tanya.typecons : Tuple;
 
 // Returns the last part of buffer with converted number.
@@ -1989,7 +1996,7 @@ private const(char)[] real2String(double value,
     }
 }
 
-private void formatReal(T)(ref T arg, ref String result)
+private void formatReal(T, OR)(ref T arg, OR result)
 if (isFloatingPoint!T)
 {
     char[512] buffer; // Big enough for e+308 or e-307.
@@ -2017,11 +2024,11 @@ if (isFloatingPoint!T)
 
     if (negative)
     {
-        result.insertBack('-');
+        put(result, "-");
     }
     if (decimalPoint == special)
     {
-        result.insertBack(realString);
+        put(result, realString);
         return;
     }
 
@@ -2181,11 +2188,11 @@ if (isFloatingPoint!T)
     // Get the length that we've copied.
     length = cast(uint) (buffer.length - bufferSlice.length);
 
-    result.insertBack(buffer[64 .. length]); // Number.
+    put(result, buffer[64 .. length]); // Number.
-    result.insertBack(tail[1 .. tail[0] + 1]); // Tail.
+    put(result, tail[1 .. tail[0] + 1]); // Tail.
 }
 
-private void formatStruct(T)(ref T arg, ref String result)
+private void formatStruct(T, OR)(ref T arg, OR result)
 if (is(T == struct))
 {
     template pred(alias f)
@@ -2202,24 +2209,24 @@ if (is(T == struct))
     }
     alias fields = Filter!(pred, __traits(allMembers, T));
 
-    result.insertBack(T.stringof);
+    put(result, T.stringof);
-    result.insertBack('(');
+    put(result, "(");
     static if (fields.length > 0)
     {
         printToString!"{}"(result, __traits(getMember, arg, fields[0]));
         foreach (field; fields[1 .. $])
         {
-            result.insertBack(", ");
+            put(result, ", ");
             printToString!"{}"(result, __traits(getMember, arg, field));
         }
     }
-    result.insertBack(')');
+    put(result, ")");
 }
 
-private void formatRange(T)(ref T arg, ref String result)
+private void formatRange(T, OR)(ref T arg, OR result)
 if (isInputRange!T && !isInfinite!T)
 {
-    result.insertBack('[');
+    put(result, "[");
     if (!arg.empty)
     {
         printToString!"{}"(result, arg.front);
@@ -2227,24 +2234,24 @@ if (isInputRange!T && !isInfinite!T)
     }
     foreach (e; arg)
     {
-        result.insertBack(", ");
+        put(result, ", ");
         printToString!"{}"(result, e);
     }
-    result.insertBack(']');
+    put(result, "]");
 }
 
-private ref String printToString(string fmt, Args...)(return ref String result,
+private void printToString(string fmt, OR, Args...)(ref OR result,
                                                     auto ref Args args)
 {
     alias Arg = Args[0];
 
     static if (is(Unqual!Arg == typeof(null))) // null
     {
-        result.insertBack("null");
+        put(result, "null");
     }
     else static if (is(Unqual!Arg == bool)) // Boolean
     {
-        result.insertBack(args[0] ? "true" : "false");
+        put(result, args[0] ? "true" : "false");
     }
     else static if (is(Arg == enum)) // Enum
     {
@@ -2252,19 +2259,19 @@ private ref String printToString(string fmt, Args...)(return ref String result,
         {
             if (args[0] == __traits(getMember, Arg, m))
             {
-                result.insertBack(m);
+                put(result, m);
             }
         }
     }
     else static if (isSomeChar!Arg || isSomeString!Arg) // String or char
     {
-        result.insertBack(args[0]);
+        put(result, args[0]);
     }
     else static if (isInputRange!Arg
                  && !isInfinite!Arg
                  && isSomeChar!(ElementType!Arg)) // Stringish range
     {
-        result.insertBack(args[0]);
+        put(result, args[0]);
     }
     else static if (isInputRange!Arg && !isInfinite!Arg)
     {
@@ -2272,29 +2279,49 @@ private ref String printToString(string fmt, Args...)(return ref String result,
     }
     else static if (is(Unqual!(typeof(args[0].stringify())) == String))
     {
+        pragma(msg, ".stringify() is deprecated. Use toString() with an output"
+                  ~ " range instead");
         static if (is(Arg == class) || is(Arg == interface))
         {
             if (args[0] is null)
             {
-                result.insertBack("null");
+                put(result, "null");
             }
             else
             {
-                result.insertBack(args[0].stringify()[]);
+                put(result, args[0].stringify()[]);
             }
         }
         else
         {
-            result.insertBack(args[0].stringify()[]);
+            put(result, args[0].stringify()[]);
+        }
+    }
+    else static if (is(typeof(args[0].toString(result)) == OR))
+    {
+        static if (is(Arg == class) || is(Arg == interface))
+        {
+            if (args[0] is null)
+            {
+                put(result, "null");
+            }
+            else
+            {
+                result = args[0].toString(result);
+            }
+        }
+        else
+        {
+            result = args[0].toString(result);
         }
     }
     else static if (is(Arg == class))
     {
-        result.insertBack(args[0] is null ? "null" : args[0].toString());
+        put(result, args[0] is null ? "null" : args[0].toString());
     }
     else static if (is(Arg == interface))
     {
-        result.insertBack(Arg.classinfo.name);
+        put(result, Arg.classinfo.name);
     }
     else static if (is(Arg == struct))
     {
@@ -2302,7 +2329,7 @@ private ref String printToString(string fmt, Args...)(return ref String result,
     }
     else static if (is(Arg == union))
     {
-        result.insertBack(Arg.stringof);
+        put(result, Arg.stringof);
     }
     else static if (isFloatingPoint!Arg) // Float
     {
@@ -2321,21 +2348,19 @@ private ref String printToString(string fmt, Args...)(return ref String result,
         }
         while (address != 0);
 
-        result.insertBack("0x");
+        put(result, "0x");
-        result.insertBack(buffer[position .. $]);
+        put(result, buffer[position .. $]);
     }
     else static if (isIntegral!Arg) // Integer
     {
         char[21] buffer;
-        result.insertBack(integral2String(args[0], buffer));
+        put(result, integral2String(args[0], buffer));
     }
     else
     {
         static assert(false,
                       "Formatting type " ~ Arg.stringof ~ " is not supported");
     }
-
-    return result;
 }
 
 /**
@@ -2351,28 +2376,47 @@ private ref String printToString(string fmt, Args...)(return ref String result,
 String format(string fmt, Args...)(auto ref Args args)
 {
     String formatted;
+    sformat!fmt(backInserter(formatted), args);
+    return formatted;
+}
 
+/**
+ * Produces a string according to the specified format and writes it into an
+ * output range. $(D_PSYMBOL sformat) writes the final string in chunks, so the
+ * output range should be in output range for `const(char)[]`.
+ *
+ * Params:
+ *  fmt    = Format.
+ *  R      = Output range type.
+ *  output = Output range.
+ *  args   = Arguments.
+ *
+ * Returns: $(D_PARAM output).
+ */
+R sformat(string fmt, R, Args...)(R output, auto ref Args args)
+if (isOutputRange!(R, const(char)[]))
+{
     alias Specs = ParseFmt!fmt;
     enum bool FormatSpecFilter(alias spec) = is(typeof(spec) == FormatSpec);
     static assert((Filter!(FormatSpecFilter, ParseFmt!fmt)).length == Args.length,
-                  "Number of the arguments doesn't match the format strign");
+                  "Number of the arguments doesn't match the format string");
 
     foreach (spec; Specs)
     {
         static if (FormatSpecFilter!spec)
         {
-            printToString!"{}"(formatted, args[spec.position]);
+            printToString!"{}"(output, args[spec.position]);
         }
         else static if (isSomeString!(typeof(spec)))
         {
-            formatted.insertBack(spec);
+            put(output, spec);
         }
         else
         {
             static assert(false, "Format string parsed incorrectly");
         }
     }
-    return formatted;
+    return output;
 }
 
 // doesn't print the first argument repeatedly
@@ -2507,14 +2551,15 @@ String format(string fmt, Args...)(auto ref Args args)
     }
     assert(format!"{}"(Nested()) == "Nested(0)");
 
-    static struct WithStringify
+    static struct WithToString
     {
-        String stringify() const @nogc nothrow pure @safe
+        OR toString(OR)(OR range) const
         {
-            return String("stringify method");
+            put(range, "toString method");
+            return range;
         }
     }
-    assert(format!"{}"(WithStringify()) == "stringify method");
+    assert(format!"{}"(WithToString()) == "toString method");
 }
 
 // Aggregate types.
@@ -2536,9 +2581,10 @@ String format(string fmt, Args...)(auto ref Args args)
 
     class B
     {
-        String stringify() @nogc nothrow pure @safe
+        OR toString(OR)(OR range) const
         {
-            return String("Class B");
+            put(range, "Class B");
+            return range;
         }
     }
     assert(format!"{}"(cast(B) null) == "null");

source/tanya/hash/lookup.d

@@ -18,7 +18,7 @@ import tanya.meta.trait;
 import tanya.range.primitive;
 version (unittest) import tanya.test.stub;
 
-private struct FNV
+private struct Hasher
 {
     static if (size_t.sizeof == 4)
     {
@@ -50,11 +50,33 @@ private struct FNV
         }
         else static if (isScalarType!T || isPointer!T)
         {
-            (() @trusted => add((cast(const ubyte*) &key)[0 .. T.sizeof]))();
+            // Treat as an array of words
+            static if (T.sizeof % size_t.sizeof == 0
+                    && T.alignof >= size_t.alignof)
+                alias CastT = size_t;
+            // (64-bit or 128-bit) Treat as an array of ints
+            else static if (T.sizeof % uint.sizeof == 0
+                    && T.alignof >= uint.alignof)
+                alias CastT = uint;
+            // Treat as an array of bytes
+            else
+                alias CastT = ubyte;
+            add((() @trusted => (cast(const CastT*) &key)[0 .. T.sizeof / CastT.sizeof])());
         }
         else static if (isArray!T && isScalarType!(ElementType!T))
         {
-            add(cast(const ubyte[]) key);
+            // Treat as an array of words
+            static if (ElementType!T.sizeof % size_t.sizeof == 0
+                    && ElementType!T.alignof >= size_t.alignof)
+                alias CastT = size_t;
+            // (64-bit or 128-bit) Treat as an array of ints
+            else static if (ElementType!T.sizeof % uint.sizeof == 0
+                    && ElementType!T.alignof >= uint.alignof)
+                alias CastT = uint;
+            // Treat as an array of bytes
+            else
+                alias CastT = ubyte;
+            add(cast(const CastT[]) key);
         }
         else static if (is(T == typeof(null)))
         {
@@ -73,13 +95,166 @@ private struct FNV
         }
     }
 
-    void add(const ubyte[] key) @nogc nothrow pure @safe
+    void add(scope const ubyte[] key) @nogc nothrow pure @safe
     {
+        // FNV-1a
         foreach (c; key)
         {
             this.hash = (this.hash ^ c) * prime;
         }
     }
+
+    void add(scope const size_t[] key) @nogc nothrow pure @safe
+    {
+        static if (size_t.sizeof == 4)
+        {
+            // Partial MurmurHash3_x86_32 (no finalization)
+            enum uint c1 = 0xcc9e2d51;
+            enum uint c2 = 0x1b873593;
+            alias h1 = hash;
+            foreach (x; key)
+            {
+                auto k1 = x * c1;
+                k1 = (k1 << 15) | (k1 >> (32 - 15));
+                k1 *= c2;
+
+                h1 ^= k1;
+                h1 = (h1 << 13) | (h1 >> (32 - 13));
+                h1 = h1 * 5 + 0xe6546b64;
+            }
+        }
+        else static if (size_t.sizeof == 8)
+        {
+            // Partial 64-bit MurmurHash64A (no finalization)
+            alias h = hash;
+            enum ulong m = 0xc6a4a7935bd1e995UL;
+            foreach (x; key)
+            {
+                auto k = x * m;
+                k ^= k >>> 47;
+                k *= m;
+
+                h ^= k;
+                h *= m;
+            }
+        }
+        else static if (size_t.sizeof == 16)
+        {
+            // Partial MurmurHash3_x64_128 (no finalization)
+            // treating each size_t as a pair of ulong.
+            ulong h1 = cast(ulong) hash;
+            ulong h2 = cast(ulong) (hash >> 64);
+
+            enum ulong c1 = 0x87c37b91114253d5UL;
+            enum ulong c2 = 0x4cf5ad432745937fUL;
+
+            foreach (x; key)
+            {
+                auto k1 = cast(ulong) x;
+                auto k2 = cast(ulong) (x >> 64);
+
+                k1 *= c1; k1 = (k1 << 32) | (k1 >> (64 - 31)); k1 *= c2; h1 ^= k1;
+                h1 = (h1 << 27) | (h1 >> (64 - 27)); h1 += h2; h1 = h1*5+0x52dce729;
+                k2 *= c2; k2 = (k2 << 33) | (k2 >> (64 - 33)); k2 *= c1; h2 ^= k2;
+                h2 = (h2 << 31) | (h2 >> (64 - 31)); h2 += h1; h2 = h2*5+0x38495ab5;
+            }
+
+            hash = cast(size_t) h1 + ((cast(size_t) h2) << 64);
+        }
+        else
+        {
+            static assert(0, "Hash length must be either 32, 64, or 128 bits.");
+        }
+    }
+
+    static if (size_t.sizeof != uint.sizeof)
+    void add(scope const uint[] key) @nogc nothrow pure @trusted
+    {
+        static if (size_t.sizeof == 8)
+        {
+            // Partial 32-bit MurmurHash64B (no finalization)
+            enum uint m = 0x5bd1e995;
+            enum r = 24;
+
+            uint h1 = cast(uint) hash;
+            uint h2 = cast(uint) (hash >> 32);
+            const(uint)* data = key.ptr;
+            auto len = key.length;
+
+            for (; len >= 2; data += 2, len -= 2)
+            {
+                uint k1 = data[0];
+                k1 *= m; k1 ^= k1 >> r; k1 *= m;
+                h1 *= m; h1 ^= k1;
+
+                uint k2 = data[1];
+                k2 *= m; k2 ^= k2 >> r; k2 *= m;
+                h2 *= m; h2 ^= k2;
+            }
+            if (len)
+            {
+                uint k1 = data[0];
+                k1 *= m; k1 ^= k1 >> r; k1 *= m;
+                h1 *= m; h1 ^= k1;
+            }
+            hash = cast(ulong) h1 + ((cast(ulong) h2) << 32);
+        }
+        else static if (size_t.sizeof == 16)
+        {
+            // Partial MurmurHash3_x86_128 (no finalization)
+            enum uint c1 = 0x239b961b;
+            enum uint c2 = 0xab0e9789;
+            enum uint c3 = 0x38b34ae5;
+            enum uint c4 = 0xa1e38b93;
+
+            uint h1 = cast(uint) hash;
+            uint h2 = cast(uint) (hash >> 32);
+            uint h3 = cast(uint) (hash >> 64);
+            uint h4 = cast(uint) (hash >> 96);
+            const(uint)* data = key.ptr;
+            auto len = key.length;
+
+            for (; len >= 4; data += 4, len -= 4)
+            {
+                uint k1 = data[0];
+                uint k2 = data[1];
+                uint k3 = data[2];
+                uint k4 = data[3];
+
+                h1 = (h1 << 19) | (h1 >> (32 - 19)); h1 += h2; h1 = h1*5+0x561ccd1b;
+                k2 *= c2; k2 = (k2 << 16) | (k2 >> (32 - 16)); k2 *= c3; h2 ^= k2;
+                h2 = (h2 << 17) | (h2 >> (32 - 17)); h2 += h3; h2 = h2*5+0x0bcaa747;
+                k3 *= c3; k3 = (k3 << 17) | (k3 >> (32 - 17)); k3 *= c4; h3 ^= k3;
+                h3 = (h3 << 15) | (h3 >> (32 - 15)); h3 += h4; h3 = h3*5+0x96cd1c35;
+                k4 *= c4; k4 = (k4 << 18) | (k4 >> (32 - 18)); k4 *= c1; h4 ^= k4;
+                h4 = (h4 << 13) | (h4 >> (32 - 13)); h4 += h1; h4 = h4*5+0x32ac3b17;
+            }
+            uint k1, k2, k3;
+            switch (len) // 0, 1, 2, 3
+            {
+                case 3:
+                    k3 = data[2];
+                    k3 *= c3; k3 = (k3 << 17) | (k3 >> (32 - 17)); k3 *= c4; h3 ^= k3;
+                    goto case;
+                case 2:
+                    k2 = data[1];
+                    k2 *= c2; k2 = (k2 << 16) | (k2 >> (32 - 16)); k2 *= c3; h2 ^= k2;
+                    goto case;
+                case 1:
+                    k1 = data[0];
+                    k1 *= c1; k1 = (k1 << 15) | (k1 >> (32 - 15)); k1 *= c2; h1 ^= k1;
+                    break;
+            }
+            hash = cast(size_t) h1 +
+                   ((cast(size_t) h2) << 32) +
+                   ((cast(size_t) h3) << 64) +
+                   ((cast(size_t) h4) << 96);
+        }
+        else
+        {
+            static assert(0, "Hash length must be either 32, 64, or 128 bits.");
+        }
+    }
 }
 
 /**
@@ -98,7 +273,8 @@ private struct FNV
  * For pointers and for scalar types implicitly convertible to `size_t` this
  * is an identity operation (i.e. the value is cast to `size_t` and returned
  * unaltered). Integer types wider than `size_t` are XOR folded down to
- * `size_t`. Other scalar types use the FNV-1a (Fowler-Noll-Vo) hash function.
+ * `size_t`. Other scalar types use an architecture-dependent hash function
+ * based on their width and alignment.
  * If the type provides a `toHash`-function, only `toHash()` is called and its
  * result is returned.
  *
@@ -134,9 +310,9 @@ size_t hash(T)(auto ref T key)
     }
     else
     {
-        FNV fnv;
+        Hasher hasher;
-        fnv(key);
+        hasher(key);
-        return fnv.hash;
+        return hasher.hash;
     }
 }
 
@@ -199,12 +375,12 @@ version (unittest)
 static if (size_t.sizeof == 4) @nogc nothrow pure @safe unittest
 {
     assert(hash(HashRange()) == 0x6222e842U);
-    assert(hash(ToHashRange()) == 1268118805U);
+    assert(hash(ToHashRange()) == 3371162643U);
 }
 static if (size_t.sizeof == 8) @nogc nothrow pure @safe unittest
 {
     assert(hash(HashRange()) == 0x08985907b541d342UL);
-    assert(hash(ToHashRange()) == 12161962213042174405UL);
+    assert(hash(ToHashRange()) == 2072958611659694473);
 }
 
 static if (size_t.sizeof == 4) @nogc nothrow pure @system unittest

source/tanya/net/ip.d

@@ -15,6 +15,7 @@
 module tanya.net.ip;
 
 import tanya.algorithm.comparison;
+import tanya.algorithm.iteration;
 import tanya.algorithm.mutation;
 import tanya.container.string;
 import tanya.conv;
@@ -237,6 +238,7 @@ struct Address4
      *
      * Returns: This address in dotted-decimal notation.
      */
+    deprecated("Use Address4.toString() instead")
     String stringify() const @nogc nothrow pure @safe
     {
         const octets = (() @trusted => (cast(ubyte*) &this.address)[0 .. 4])();
@@ -251,12 +253,50 @@ struct Address4
         }
     }
 
+    /**
+     * Writes this IPv4 address in dotted-decimal notation.
+     *
+     * Params:
+     *  OR     = Type of the output range.
+     *  output = Output range.
+     *
+     * Returns: $(D_PARAM output).
+     */
+    OR toString(OR)(OR output) const @nogc nothrow pure @safe
+    if (isOutputRange!(OR, const(char)[]))
+    {
+        const octets = (() @trusted => (cast(ubyte*) &this.address)[0 .. 4])();
+        enum string fmt = "{}.{}.{}.{}";
+        version (LittleEndian)
+        {
+            return sformat!fmt(output,
+                               octets[0],
+                               octets[1],
+                               octets[2],
+                               octets[3]);
+        }
+        else
+        {
+            return sformat!fmt(output,
+                               octets[3],
+                               octets[2],
+                               octets[1],
+                               octets[0]);
+        }
+    }
+
     ///
     @nogc nothrow pure @safe unittest
     {
+        import tanya.container.string : String;
+        import tanya.range : backInserter;
+
         const dottedDecimal = "192.168.0.1";
+        String actual;
         const address = address4(dottedDecimal);
-        assert(address.get.stringify() == dottedDecimal);
+
+        address.get.toString(backInserter(actual));
+        assert(actual == dottedDecimal);
     }
 
     /**
@@ -640,34 +680,78 @@ struct Address6
      *
      * Returns: text representation of this address.
      */
+    deprecated("Use Address6.toString() instead")
     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)
+        toString(backInserter(output));
+        return output;
+    }
+
+    /**
+     * Writes text representation of this address to an output range.
+     *
+     * Params:
+     *  OR     = Type of the output range.
+     *  output = Output range.
+     *
+     * Returns: $(D_PARAM output).
+     */
+    OR toString(OR)(OR output) const
+    if (isOutputRange!(OR, const(char)[]))
     {
-                output.insertBack(cast(char) (high + '0'));
+        ptrdiff_t largestGroupIndex = -1;
+        size_t largestGroupSize;
+        size_t zeroesInGroup;
+        size_t groupIndex;
+
+        // Look for the longest group of zeroes
+        for (size_t i; i < this.address.length; i += 2)
+        {
+            if (this.address[i] == 0 && this.address[i + 1] == 0)
+            {
+                if (zeroesInGroup++ == 0)
+                {
+                    groupIndex = i;
+                }
             }
             else
             {
-                output.insertBack(cast(char) (high - 10 + 'a'));
+                zeroesInGroup = 0;
             }
-            if (low < 10)
+            if (zeroesInGroup > largestGroupSize && zeroesInGroup > 1)
             {
-                output.insertBack(cast(char) (low + '0'));
+                largestGroupSize = zeroesInGroup;
+                largestGroupIndex = groupIndex;
             }
-            else
+        }
+
+        // Write the address
+        size_t i;
+        if (largestGroupIndex != 0)
         {
-                output.insertBack(cast(char) (low - 10 + 'a'));
+            writeGroup(output, i);
         }
-            if (i % 2 != 0 && i != (this.address.length - 1))
+        if (largestGroupIndex != -1)
         {
-                output.insertBack(':');
+            while (i < largestGroupIndex)
+            {
+                put(output, ":");
+                writeGroup(output, i);
             }
+            put(output, "::");
+            i += largestGroupSize + 2;
+            if (i < (this.address.length - 1))
+            {
+                writeGroup(output, i);
+            }
+        }
+
+        while (i < this.address.length - 1)
+        {
+            put(output, ":");
+            writeGroup(output, i);
         }
 
         return output;
@@ -676,10 +760,74 @@ struct Address6
     ///
     @nogc nothrow @safe unittest
     {
-        import tanya.algorithm.comparison : equal;
+        import tanya.container.string : String;
+        import tanya.range : backInserter;
 
-        assert(equal(address6("1:2:3:4:5:6:7:8").get.stringify()[],
+        String actual;
-               "0001:0002:0003:0004:0005:0006:0007:0008"));
+
+        address6("1:2:3:4:5:6:7:8").get.toString(backInserter(actual));
+        assert(actual == "1:2:3:4:5:6:7:8");
+    }
+
+    @nogc nothrow @safe unittest
+    {
+        char[18] actual;
+
+        address6("ff00:2:3:4:5:6:7:8").get.toString(arrayInserter(actual));
+        assert(actual[] == "ff00:2:3:4:5:6:7:8");
+    }
+
+    // Skips zero group in the middle
+    @nogc nothrow @safe unittest
+    {
+        char[12] actual;
+
+        address6("1::4:5:6:7:8").get.toString(arrayInserter(actual));
+        assert(actual[] == "1::4:5:6:7:8");
+    }
+
+    // Doesn't replace lonely zeroes
+    @nogc nothrow @safe unittest
+    {
+        char[15] actual;
+
+        address6("0:1:0:2:3:0:4:0").get.toString(arrayInserter(actual));
+        assert(actual[] == "0:1:0:2:3:0:4:0");
+    }
+
+    // Skips zero group at the beginning
+    @nogc nothrow @safe unittest
+    {
+        char[13] actual;
+
+        address6("::3:4:5:6:7:8").get.toString(arrayInserter(actual));
+        assert(actual[] == "::3:4:5:6:7:8");
+    }
+
+    // Skips zero group at the end
+    @nogc nothrow @safe unittest
+    {
+        char[13] actual;
+
+        address6("1:2:3:4:5:6::").get.toString(arrayInserter(actual));
+        assert(actual[] == "1:2:3:4:5:6::");
+    }
+
+    private void writeGroup(OR)(ref OR output, ref size_t i) const
+    {
+        ubyte low = this.address[i] & 0xf;
+        ubyte high = this.address[i] >> 4;
+
+        bool groupStarted = writeHexDigit!OR(output, high);
+        groupStarted = writeHexDigit!OR(output, low, groupStarted);
+
+        ++i;
+        low = this.address[i] & 0xf;
+        high = this.address[i] >> 4;
+
+        writeHexDigit!OR(output, high, groupStarted);
+        put(output, low.toHexDigit.singleton);
+        ++i;
     }
 
     /**
@@ -701,13 +849,32 @@ struct Address6
     }
 }
 
-private void write2Bytes(R)(ref R range, ubyte[] address)
+private void read2Bytes(R)(ref R range, ubyte[] address)
 {
     ushort group = readIntegral!ushort(range, 16);
     address[0] = cast(ubyte) (group >> 8);
     address[1] = group & 0xff;
 }
 
+private char toHexDigit(ubyte digit) @nogc nothrow pure @safe
+in (digit < 16)
+{
+    return cast(char) (digit >= 10 ? (digit - 10 + 'a') : (digit + '0'));
+}
+
+private bool writeHexDigit(OR)(ref OR output,
+                               ubyte digit,
+                               bool groupStarted = false)
+in (digit < 16)
+{
+    if (digit != 0 || groupStarted)
+    {
+        put(output, digit.toHexDigit.singleton);
+        return true;
+    }
+    return groupStarted;
+}
+
 /**
  * Parses a string containing an IPv6 address.
  *
@@ -767,7 +934,7 @@ if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
             {
                 auto state = range.save();
             }
-            write2Bytes(range, result.address[i * 2 .. $]);
+            read2Bytes(range, result.address[i * 2 .. $]);
             if (range.empty)
             {
                 return typeof(return)();
@@ -796,7 +963,7 @@ if (isForwardRange!R && is(Unqual!(ElementType!R) == char) && hasLength!R)
             }
         }
     }
-    write2Bytes(range, result.address[14 .. $]);
+    read2Bytes(range, result.address[14 .. $]);
 
     if (range.empty)
     {
@@ -827,7 +994,7 @@ ParseTail: // after ::
     { // To make "state" definition local
         auto state = range.save();
 
-        write2Bytes(range, tail[j .. $]);
+        read2Bytes(range, tail[j .. $]);
         if (range.empty)
         {
             goto CopyTail;
@@ -856,7 +1023,7 @@ ParseTail: // after ::
             return typeof(return)();
         }
         auto state = range.save();
-        write2Bytes(range, tail[j .. $]);
+        read2Bytes(range, tail[j .. $]);
 
         if (range.empty)
         {

source/tanya/range/adapter.d

@@ -3,9 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Range adapters.
+ * Range adapters transform some data structures into ranges.
  *
- * Copyright: Eugene Wissner 2018.
+ * Copyright: Eugene Wissner 2018-2019.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
  * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
@@ -13,3 +13,218 @@
  *                 tanya/range/adapter.d)
  */
 module tanya.range.adapter;
+
+import tanya.algorithm.mutation;
+import tanya.functional;
+import tanya.meta.trait;
+import tanya.range;
+
+version (unittest)
+{
+    static struct Container
+    {
+        void insertBack(const(char)[])
+        {
+        }
+    }
+}
+
+private mixin template InserterCtor()
+{
+    private Container* container;
+
+    private this(ref Container container) @trusted
+    {
+        this.container = &container;
+    }
+}
+
+/**
+ * If $(D_PARAM container) is a container with `insertBack`-support,
+ * $(D_PSYMBOL backInserter) returns an output range that puts the elements
+ * into the container with `insertBack`.
+ *
+ * The resulting output range supports all types `insertBack` supports.
+ *
+ * The range keeps a reference to the container passed to it, it doesn't use
+ * any other storage. So there is no method to get the written data out of the
+ * range - the container passed to $(D_PSYMBOL backInserter) contains that data
+ * and can be used directly after all operations on the output range are
+ * completed. It also means that the result range is not allowed to outlive its
+ * container.
+ *
+ * Params:
+ *  Container = Container type.
+ *  container = Container used as an output range.
+ *
+ * Returns: `insertBack`-based output range.
+ */
+auto backInserter(Container)(return scope ref Container container)
+if (hasMember!(Container, "insertBack"))
+{
+    static struct Inserter
+    {
+        void opCall(T)(auto ref T data)
+        {
+            this.container.insertBack(forward!data);
+        }
+
+        mixin InserterCtor;
+    }
+    return Inserter(container);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static struct Container
+    {
+        int element;
+
+        void insertBack(int element)
+        {
+            this.element = element;
+        }
+    }
+    Container container;
+    backInserter(container)(5);
+
+    assert(container.element == 5);
+}
+
+@nogc nothrow pure @safe unittest
+{
+    auto func()()
+    {
+        Container container;
+        return backInserter(container);
+    }
+    static assert(!is(typeof(func!())));
+}
+
+@nogc nothrow pure @safe unittest
+{
+    Container container;
+    static assert(isOutputRange!(typeof(backInserter(container)), string));
+}
+
+/**
+ * If $(D_PARAM container) is a container with `insertFront`-support,
+ * $(D_PSYMBOL frontInserter) returns an output range that puts the elements
+ * into the container with `insertFront`.
+ *
+ * The resulting output range supports all types `insertFront` supports.
+ *
+ * The range keeps a reference to the container passed to it, it doesn't use
+ * any other storage. So there is no method to get the written data out of the
+ * range - the container passed to $(D_PSYMBOL frontInserter) contains that data
+ * and can be used directly after all operations on the output range are
+ * completed. It also means that the result range is not allowed to outlive its
+ * container.
+ *
+ * Params:
+ *  Container = Container type.
+ *  container = Container used as an output range.
+ *
+ * Returns: `insertFront`-based output range.
+ */
+auto frontInserter(Container)(return scope ref Container container)
+if (hasMember!(Container, "insertFront"))
+{
+    static struct Inserter
+    {
+        void opCall(T)(auto ref T data)
+        {
+            this.container.insertFront(forward!data);
+        }
+
+        mixin InserterCtor;
+    }
+    return Inserter(container);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    static struct Container
+    {
+        int element;
+
+        void insertFront(int element)
+        {
+            this.element = element;
+        }
+    }
+    Container container;
+    frontInserter(container)(5);
+
+    assert(container.element == 5);
+}
+
+/**
+ * $(D_PSYMBOL arrayInserter) makes an output range out of an array.
+ *
+ * The returned output range accepts single values as well as input ranges that
+ * can be copied into the target array.
+ *
+ * Params:
+ *  Array = Array type.
+ *  array = Array.
+ *
+ * Returns: An output range writing into $(D_PARAM array).
+ */
+auto arrayInserter(Array)(return scope ref Array array)
+if (isArray!Array)
+{
+    static if (is(Array ArrayT : ArrayT[size], size_t size))
+    {
+        alias E = ArrayT;
+    }
+    else
+    {
+        alias E = ElementType!Array;
+    }
+
+    static struct ArrayInserter
+    {
+        private E[] data;
+
+        private this(ref Array data) @trusted
+        {
+            this.data = data[];
+        }
+
+        void opCall(T)(auto ref T data)
+        if (is(T : E))
+        in (!this.data.empty)
+        {
+            put(this.data, data);
+        }
+
+        void opCall(R)(auto ref R data)
+        if (isInputRange!R && isOutputRange!(E[], ElementType!R))
+        {
+            this.data = copy(data, this.data);
+        }
+    }
+    return ArrayInserter(array);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    int[1] array;
+
+    arrayInserter(array)(5);
+    assert(array[0] == 5);
+}
+
+///
+@nogc nothrow pure @safe unittest
+{
+    char[1] array;
+    alias Actual = typeof(arrayInserter(array));
+
+    static assert(isOutputRange!(Actual, char));
+    static assert(isOutputRange!(Actual, char[]));
+}

source/tanya/range/primitive.d

@@ -5,7 +5,7 @@
 /**
  * This module defines primitives for working with ranges.
  *
- * Copyright: Eugene Wissner 2017-2018.
+ * Copyright: Eugene Wissner 2017-2019.
  * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
  *                  Mozilla Public License, v. 2.0).
  * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
@@ -798,15 +798,13 @@ template isRandomAccessRange(R)
 /**
  * Puts $(D_PARAM e) into the $(D_PARAM range).
  *
- * $(D_PSYMBOL R) should be an output range for $(D_PARAM E). It doesn't mean
+ * $(D_PSYMBOL R) should be an output range for $(D_PARAM E), i.e. at least one
- * that everything $(D_PARAM range) is an output range for can be put into it,
+ * of the following conditions should met:
- * but only if one of the following conditions is met:
  *
  * $(OL
- *  $(LI $(D_PARAM R) defines a `put`-method for $(D_PARAM E))
- *  $(LI $(D_PARAM e) can be assigned to $(D_INLINECODE range.front))
  *  $(LI $(D_PARAM e) can be put into $(D_PARAM range) using
  *       $(D_INLINECODE range(e))
+ *  $(LI $(D_PARAM e) can be assigned to $(D_INLINECODE range.front))
  *  )
  * )
  *
@@ -833,18 +831,19 @@ void put(R, E)(ref R range, auto ref E e)
     static if (__traits(hasMember, R, "put")
             && is(typeof((R r, E e) => r.put(e))))
     {
+        pragma(msg, "OutputRange.put()-primitive is deprecated. Define opCall() instead.");
         range.put(e);
     }
+    else static if (is(typeof((R r, E e) => r(e))))
+    {
+        range(e);
+    }
     else static if (isInputRange!R
                  && is(typeof((R r, E e) => r.front = e)))
     {
         range.front = e;
         range.popFront();
     }
-    else static if (is(typeof((R r, E e) => r(e))))
-    {
-        range(e);
-    }
     else
     {
         static assert(false, R.stringof ~ " is not an output range for "
@@ -862,23 +861,6 @@ void put(R, E)(ref R range, auto ref E e)
     assert(actual == [2, 0]);
 }
 
-///
-@nogc nothrow pure @safe unittest
-{
-    static struct Put
-    {
-        int e;
-
-        void put(int e)
-        {
-            this.e = e;
-        }
-    }
-    Put p;
-    put(p, 2);
-    assert(p.e == 2);
-}
-
 ///
 @nogc nothrow pure @safe unittest
 {
@@ -910,36 +892,28 @@ void put(R, E)(ref R range, auto ref E e)
  *      $(TH Scenario)
  *  )
  *  $(TR
- *      $(TD r.put(e))
- *      $(TD $(D_PARAM R) defines `put` for $(D_PARAM E).)
- *  )
- *  $(TR
- *      $(TD r.front = e)
- *      $(TD $(D_PARAM R) is an input range, whose element type is
- *      $(D_PARAM E) and `front` is an lvalue.)
- *  )
- *  $(TR
  *      $(TD r(e))
  *      $(TD $(D_PARAM R) defines `opCall` for $(D_PARAM E).)
  *  )
  *  $(TR
- *      $(TD for (; !e.empty; e.popFront()) r.put(e.front) $(BR)
+ *      $(TD r.front = e)
- *           for (; !e.empty; e.popFront(), r.popFront())
+ *      $(TD $(D_PARAM R) is an input range with assignable elements of type
- *           r.front = e.front $(BR)
+ *           $(D_PARAM E).)
- *           for (; !e.empty; e.popFront()) r(e.front)
- *      )
- *      $(TD $(D_PARAM E) is input range, whose elements can be put into
- *           $(D_PARAM R) according to the rules described above in this table.
- *      )
  *  )
  * )
  *
+ * Output ranges don't have element type (so $(D_PSYMBOL ElementType) returns
+ * $(D_KEYWORD void) when applied to an output range). It is because an output
+ * range can support puting differently typed elements into it.
+ *
  * Params:
  *  R = The type to be tested.
  *  E = Element type should be tested for.
  *
  * 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.
+ *
+ * See_Also: $(D_PSYMBOL put).
  */
 template isOutputRange(R, E)
 {
@@ -949,6 +923,11 @@ template isOutputRange(R, E)
     }
     else static if (isInputRange!E)
     {
+        pragma(msg, "Deprecation. An input range whose element type is "
+                  ~ "supported by the output range isn't considered itself to "
+                  ~ "be a source for such an output range. Don't rely on this "
+                  ~ "behavior and use tanya.algorithm.copy() to write one "
+                  ~ "range into another one.");
         alias ET = ElementType!E;
         enum bool isOutputRange = is(typeof((R r, ET e) => put(r, e)));
     }
@@ -963,7 +942,7 @@ template isOutputRange(R, E)
 {
     static struct R1
     {
-        void put(int) @nogc nothrow pure @safe
+        void opCall(int) @nogc nothrow pure @safe
         {
         }
     }
@@ -972,13 +951,16 @@ template isOutputRange(R, E)
     static struct R2
     {
         int value;
+
         void popFront() @nogc nothrow pure @safe
         {
         }
+
         ref int front() @nogc nothrow pure @safe
         {
             return value;
         }
+
         bool empty() const @nogc nothrow pure @safe
         {
             return true;
@@ -991,28 +973,18 @@ template isOutputRange(R, E)
         void popFront() @nogc nothrow pure @safe
         {
         }
+
         int front() @nogc nothrow pure @safe
         {
             return 0;
         }
+
         bool empty() const @nogc nothrow pure @safe
         {
             return true;
         }
     }
     static assert(!isOutputRange!(R3, int));
-
-    static struct R4
-    {
-        void opCall(int) @nogc nothrow pure @safe
-        {
-        }
-    }
-    static assert(isOutputRange!(R4, int));
-
-    static assert(isOutputRange!(R1, R3));
-    static assert(isOutputRange!(R2, R3));
-    static assert(isOutputRange!(R4, R3));
 }
 
 /**