import std.typecons : Nullable;

​

struct Foo

{

    int value; // ... more values

}

​

class Node

{

    Nullable!Foo foo;

    Node[uint] children;

​

    void mapFoo(Foo foo, uint[] sequence)

    {

        if (sequence.length == 0)

        {

            assert(this.foo.isNull, "trying to redefine input");

​

            this.foo = foo;

            return;

        }

​

        auto value = sequence.popFrontValue;

        auto node = this.getOrCreateChildNodeForValue(value);

​

        node.mapFoo(foo, sequence);

    }

​

    private Node getOrCreateChildNodeForValue(uint value)

    {

        Node node;

        if ((value in this.children) is null)

        {

            node = new Node();

            this.children[value] = node;

        }

        else

        {

            node = this.children[value];

        }

​

        return node;

    }

}

​

private uint popFrontValue(ref uint[] array) pure

{

    auto value = array[0];

    import std.range.primitives : popFront;

    popFront(array);

    return value;

}

​

void main()

{

    auto root = new Node();

    root.mapFoo(Foo(1), [1]);

    root.mapFoo(Foo(2), [2, 3, 4]);

    root.mapFoo(Foo(3), [2, 3, 5]);

​

    assert(1 == root.children[1].foo.get.value);

    assert(2 == root.children[2].children[3].children[4].foo.get.value);

    assert(3 == root.children[2].children[3].children[5].foo.get.value);

}