net.ip.Address6.toString() recommended notation

Fix #65.
algorithm.iteration: Add singleton()
2019-03-01 08:28:36 +01:00 · 2019-02-25 09:27:03 +01:00 · 2019-02-24 13:14:30 +01:00 · 2019-02-19 06:39:39 +01:00 · 2019-02-16 08:37:45 +01:00 · 2019-02-16 08:36:50 +01:00
10 changed files with 941 additions and 153 deletions
--- a/.travis.yml
+++ b/.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:
--- a/README.md
+++ b/README.md
@ -175,8 +175,9 @@ parameter is used)

 | DMD     | GCC             |
 |:-------:|:---------------:|
-| 2.083.1 | gdc-8 (2.081.2) |
-| 2.082.1 | gdc-7 (2.081.2) |
+| 2.084.1 | gdc-8 (2.081.2) |
+| 2.083.1 | gdc-7 (2.081.2) |
+| 2.082.1 |                 |

 ### Release management

--- a/appveyor.yml
+++ b/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
--- a/source/tanya/algorithm/iteration.d
+++ b/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);
+}
--- a/source/tanya/algorithm/mutation.d
+++ b/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
-        {
-            assert(this.value == 0);
-        }
-        do
+
+        void opCall(int value) @nogc nothrow pure @safe
+        in (this.value == 0)
        {
            this.value = value;
        }
--- a/source/tanya/format.d
+++ b/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))
- * defines a `stringify()` function that is callable without arguments and
- * returns a $(D_PSYMBOL String), this function is used to produce a string
- * representation for the value. String conversions for the most built-in
- * data types a also available.
+ * To define the string representation for a custom data type (like
+ * $(D_KEYWORD class) or $(D_KEYWORD struct)), `toString()`-function can be
+ * implemented for that type. `toString()` should be $(D_KEYWORD const) and
+ * accept exactly one argument: an output range for `const(char)[]`. It should
+ * 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.primitive;
+import tanya.range;
 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.
-    result.insertBack(tail[1 .. tail[0] + 1]); // Tail.
+    put(result, buffer[64 .. length]); // Number.
+    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);
-    result.insertBack('(');
+    put(result, T.stringof);
+    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,
-                                                      auto ref Args args)
+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");
-        result.insertBack(buffer[position .. $]);
+        put(result, "0x");
+        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");
--- a/source/tanya/hash/lookup.d
+++ b/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;
-        fnv(key);
-        return fnv.hash;
+        Hasher hasher;
+        hasher(key);
+        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
--- a/source/tanya/net/ip.d
+++ b/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,46 +680,154 @@ 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)[]))
+    {
+        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)
            {
-                output.insertBack(cast(char) (high + '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)
+        {
+            writeGroup(output, i);
+        }
+        if (largestGroupIndex != -1)
+        {
+            while (i < largestGroupIndex)
            {
-                output.insertBack(cast(char) (low - 10 + 'a'));
+                put(output, ":");
+                writeGroup(output, i);
            }
-            if (i % 2 != 0 && i != (this.address.length - 1))
+            put(output, "::");
+            i += largestGroupSize + 2;
+            if (i < (this.address.length - 1))
            {
-                output.insertBack(':');
+                writeGroup(output, i);
            }
        }

+        while (i < this.address.length - 1)
+        {
+            put(output, ":");
+            writeGroup(output, i);
+        }
+
        return output;
    }

    ///
    @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()[],
-               "0001:0002:0003:0004:0005:0006:0007:0008"));
+        String actual;
+
+        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)
        {
--- a/source/tanya/range/adapter.d
+++ b/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[]));
+}
--- a/source/tanya/range/primitive.d
+++ b/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
- * that everything $(D_PARAM range) is an output range for can be put into it,
- * but only if one of the following conditions is met:
+ * $(D_PSYMBOL R) should be an output range for $(D_PARAM E), i.e. at least one
+ * of the following conditions should 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)
- *           for (; !e.empty; e.popFront(), r.popFront())
- *           r.front = e.front $(BR)
- *           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.
- *      )
+ *      $(TD r.front = e)
+ *      $(TD $(D_PARAM R) is an input range with assignable elements of type
+ *           $(D_PARAM E).)
 *  )
 * )
 *
+ * 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));
 }

 /**
Author	SHA1	Message	Date
Eugen Wissner	d7dfa3f6f1	net.ip.Address6.toString() recommended notation Fix #65.	2019-03-01 08:28:36 +01:00
Eugen Wissner	8fd0452cd0	algorithm.iteration: Add singleton() ... iterating over a single value.	2019-02-25 09:27:03 +01:00
Eugen Wissner	df99ea45f2	range.adapter: new arrayInserter	2019-02-24 13:14:30 +01:00
Eugen Wissner	87ba58098e	format.sformat: Support range-based toString()	2019-02-19 06:39:39 +01:00
Eugen Wissner	5a134ce768	net.ip: Implement .toString() with output ranges	2019-02-16 08:37:45 +01:00
Eugen Wissner	0835edce1d	range.adapter: Add container-range adapters. Fix #67	2019-02-16 08:36:50 +01:00
Nathan Sashihara	a786bdbec5	Use word-wise hash instead of FNV-1a for arrays of word-aligned scalars Also special case int-aligned scalars on 64-bit machines. On a 64-bit machine hashing an array of pointers is now ~5.95x faster with LDC2 and ~8.54x faster with DMD, and hashing an array of ints is ~3.34x faster with LDC2 and ~8.12x faster with DMD.	2019-02-12 10:34:18 -05:00
Eugen Wissner	0bef2ef76d	Add sformat() writing to an output range	2019-02-12 07:37:24 +01:00
Eugen Wissner	1d3d750adb	Update dmd to 2.084.1	2019-02-11 22:14:59 +01:00
Eugen Wissner	0c8f1eb4ce	Deprecate InputRange source for OutputRanges An output range for E won't be automatically an output range for [E] anymore. The same, an output range for [E] won't be automatically an output range for E. Automatic E <-> [E] conversion seems to be a nice feature at first glance, but it causes much ambiguity. 1) If I want that my output range accepts only UTF-8 strings but not single characters (because it could be only part of a code point and look like broken UTF-8 without the remaining code units), I can't do it because an OutputRange(R, E) can't distinguish between char and string. 2) Here is an example from 2013: import std.range; import std.stdio; Appender!(const(char)[][]) app; put(app, "aasdf"); put(app, 'b'); writeln(app.data); This outputs: ["aasdf", "\0"]. Whether it is a common case or not, such code just shouldn't compile.	2019-02-06 07:26:28 +01:00
Eugen Wissner	bf197a6554	Deprecate put() as an OutputRange primitive	2019-02-04 10:49:12 +01:00