Changeset 1753

Timestamp:

07/13/10 01:12:45 (14 years ago)

Author:

rsinfu

Message:

[devel] Moved typecons.Any -> variant.Algebraic with a few improvements.

Files:

• branches/devel/stdio-native-codeset/phobos/std/typecons.d (modified) (1 diff)
• branches/devel/stdio-native-codeset/phobos/std/variant.d (modified) (4 diffs)

branches/devel/stdio-native-codeset/phobos/std/typecons.d

@@ -2196 +2196 @@
-            auto another = this;
-            return another;
-        }
-    }
-    auto a = A(4);
-    auto b = a.copy();
-    if (a.x._refCountedStore._count != 2) {
-        stderr.writeln("*** BUG 4356 still unfixed");
-    }
-}
-
-
-/*-*
- * Provides ad-hoc polymorphism on a specific group of objects that
- * have the same interface (duck-typed).
- */
-package struct Any(Ducks...)
-{
-    /**
-     * Invokes the method $(D op) on the active object.
-     *
-     * The allowed operation $(D op) is the intersection of the allowed
-     * operations on all $(D Ducks).
-     *
-     * Throws:
-     * $(UL
-     *   $(LI $(D Error) if this $(D Any) object is empty)
-     * )
-     */
-    @system auto ref opDispatch(string op, Args...)(auto ref Args args)
-        if (_canDispatch!(op, Args))
-    {
-        if (_which == size_t.max)
-            throw new Error("dispatching " ~ op ~ Args.stringof
-                    ~ " on an empty " ~ typeof(this).stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return mixin("_storageAs!Duck()."
-                        ~ (args.length == 0 ? op : op ~ "(args)"));
-            }));
-        assert(0);
-    }
-
-
-    /**
-     * If $(D T) is one of the $(D Ducks), alters the contained object
-     * with $(D rhs); otherwise assigns $(D rhs) on the active object.
-     */
-    @system void opAssign(T)(T rhs)
-        if (_canAssign!(T))
-    {
-        if (_which == size_t.max)
-            _grab(rhs);
-        else
-            _assign(rhs);
-    }
-
-    @trusted void opAssign(T)(T rhs)
-        if (is(T == typeof(this)))
-    {
-        swap(this, rhs);
-    }
-
-    // @@@BUG4424@@@ workaround
-    private template _workaround4424()
-        { @disable void opAssign(...) { assert(0); } }
-    mixin _workaround4424 _workaround4424_;
-
-
-    //----------------------------------------------------------------//
-
-    // operator overloads
-
-    @system auto ref opUnary(string op)()
-    {
-        if (_which == size_t.max)
-            throw new Error("unary " ~ op ~ " on an empty "
-                    ~ typeof(this).stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return mixin(op ~ "_storageAs!Duck");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opIndexUnary(string op, Indices...)(Indices indices)
-    {
-        if (_which == size_t.max)
-            throw new Error("unary " ~ to!string(Indices.length)
-                    ~ "-indexing " ~ op ~ " on an empty "
-                    ~ typeof(this).stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return mixin(op ~ "_storageAs!Duck[" ~
-                        _commaExpand!("indices", Indices.length) ~ "]");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opSliceUnary(string op, I, J)(I i, J j)
-    {
-        if (_which == size_t.max)
-            throw new Error("unary slicing " ~ op ~ " on an empty "
-                    ~ typeof(this).stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return mixin(op ~ "_storageAs!Duck[i .. j]");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opSliceUnary(string op)()
-    {
-        if (_which == size_t.max)
-            throw new Error("unary slicing " ~ op ~ " on an empty "
-                    ~ typeof(this).stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return mixin(op ~ "_storageAs!Duck[]");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opCast(T)()
-    {
-        if (_which == size_t.max)
-            throw new Error("casting an empty " ~ typeof(this).stringof
-                    ~ " to " ~ T.stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                static if (is(T == Duck))
-                    return         _storageAs!Duck;
-                else
-                    return cast(T) _storageAs!Duck;
-            }));
-        assert(0);
-    }
-
-    @system auto ref opBinary(string op, RHS)(RHS rhs)
-    {
-        if (_which == size_t.max)
-            throw new Error("binary " ~ op ~ " on an empty LHS "
-                    ~ typeof(this).stringof ~ " and RHS " ~ RHS.stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return mixin("_storageAs!Duck() " ~ op ~ " rhs");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opBinaryRight(string op, LHS)(LHS lhs)
-    {
-        if (_which == size_t.max)
-            throw new Error("binary " ~ op ~ " on LHS " ~ LHS.stringof
-                    ~ "and an empty RHS " ~ typeof(this).stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return mixin("lhs " ~ op ~ "_storageAs!Duck");
-            }));
-        assert(0);
-    }
-
-    @system bool opEquals(RHS)(auto ref RHS rhs) const
-    {
-        if (_which == size_t.max)
-            throw new Error("comparing an empty " ~ typeof(this).stringof
-                    ~ " with " ~ RHS.stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return _storageAs_const!Duck() == rhs;
-            }));
-        assert(0);
-    }
-
-    @system bool opEquals(RHS : typeof(this))(ref const RHS rhs) const
-    {
-        if (_which != size_t.max && _which == rhs._which)
-        {
-            mixin (_onActiveDuck!(
-                q{
-                    return _storageAs_const!Duck() ==
-                            rhs._storageAs_const!Duck;
-                }));
-            assert(0);
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-    @system int opCmp(RHS)(auto ref RHS rhs) const
-    {
-        if (_which == size_t.max)
-            throw new Error("comparing an empty " ~ typeof(this).stringof
-                    ~ " with " ~ RHS.stringof);
-
-        mixin (_onActiveDuck!(
-            q{
-                return (_storageAs_const!Duck < rhs) ? -1 :
-                       (_storageAs_const!Duck > rhs) ?  1 : 0;
-            }));
-        assert(0);
-    }
-
-    @system int opCmp(RHS : typeof(this))(ref const RHS rhs) const
-    {
-        if (_which == size_t.max || rhs._which == size_t.max)
-            throw new Error("comparing empty " ~ typeof(this).stringof
-                    ~ " objects");
-
-        mixin (_onActiveDuck!(
-            q{
-                return -rhs.opCmp(_storageAs_const!Duck);
-            }));
-        assert(0);
-    }
-
-    @system auto ref opCall(Args...)(auto ref Args args)
-    {
-        if (_which == size_t.max)
-            throw new Error("calling an empty " ~ typeof(this).stringof
-                    ~ " object");
-
-        mixin (_onActiveDuck!(
-            q{
-                return _storageAs!Duck()(args);
-            }));
-        assert(0);
-    }
-
-    @system auto ref opOpAssign(string op, RHS)(RHS rhs)
-    {
-        mixin (_onActiveDuck!(
-            q{
-                return mixin("_storageAs!Duck() " ~ op ~ "= rhs");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opIndexOpAssign(string op, RHS, Indices...)
-        (RHS rhs, Indices indices)
-    {
-        mixin (_onActiveDuck!(
-            q{
-                return mixin("_storageAs!Duck[" ~
-                        _commaExpand!("indices", Indices.length) ~
-                    "] " ~ op ~ "= rhs");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opSliceOpAssign(string op, RHS, I, J)(RHS rhs, I i, J j)
-    {
-        mixin (_onActiveDuck!(
-            q{
-                return mixin("_storageAs!Duck[i .. j] " ~ op ~ "= rhs");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opSliceOpAssign(string op, RHS)(RHS rhs)
-    {
-        mixin (_onActiveDuck!(
-            q{
-                return mixin("_storageAs!Duck[] " ~ op ~ "= rhs");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opIndex(Indices...)(Indices indices)
-    {
-        mixin (_onActiveDuck!(
-            q{
-                return mixin("_storageAs!Duck[" ~
-                    _commaExpand!("indices", Indices.length) ~ "]");
-            }));
-        assert(0);
-    }
-
-    @system auto ref opSlice(I, J)(I i, J j)
-    {
-        mixin (_onActiveDuck!(
-            q{
-                return _storageAs!Duck[i .. j];
-            }));
-        assert(0);
-    }
-
-    @system auto ref opSlice(_Dummy = void)()
-    {
-        mixin (_onActiveDuck!(
-            q{
-                return _storageAs!Duck[];
-            }));
-        assert(0);
-    }
-
-    /+
-    // @@@ cannot coexist with input range primitives
-    @system int opApply(Args...)(int delegate(ref Args) dg)
-    {
-        mixin (_onActiveDuck!(
-            q{
-                return _storageAs!Duck().opApply(dg);
-            }));
-    }
-    +/
-
-
-    //----------------------------------------------------------------//
-
-    /**
-     * Invokes the copy constructor on the active object if any.
-     */
-    @system this(this)
-    {
-        if (_which != size_t.max)
-            _postblit();
-    }
-
-
-    /**
-     * Invokes the destructor on the active object if any.
-     */
-    @system ~this()
-    {
-        if (_which != size_t.max)
-            _dispose();
-    }
-
-
-    /**
-     * The $(D Any) namespace provides various 'meta' methods
-     * for operating on this $(D Any) object itself, not a
-     * contained object.
-     *
-     * Example:
---------------------
-Any!(A, B) ab;
-
-assert(ab.Any.empty);
-assert(ab.Any.allows!A);
-
-ab = A();
-assert(ab.Any.isActive!A);
-
-A a = ab.Any.instance!A;
---------------------
-     */
-    template _Any()
-    {
-        /**
-         * A tuple of types that are considered homogeneous in this
-         * object, i.e. the $(D Ducks).
-         */
-        alias Ducks Types;
-
-
-        /**
-         * Returns $(D true) if type $(D T) is listed in the type
-         * list $(D Types).
-         */
-        template allows(T) // FIXME the name
-        {
-            enum bool allows = _homogenizes!T;
-        }
-
-
-        /**
-         * Returns $(D true) if this $(D Any) object contains
-         * nothing.
-         */
-        @safe @property bool empty() const nothrow
-        {
-            return _which == size_t.max;
-        }
-
-
-        /**
-         * Returns $(D true) if the type of the active object is $(D T).
-         */
-        @safe bool isActive(T)() const nothrow
-        {
-            return _which != size_t.max && _which == _duckID!T;
-        }
-
-
-        /**
-         * Touch the active object directly (by ref).  The type $(D T)
-         * must be the active one, i.e. $(D isActive!T == true).
-         *
-         * Throws:
-         * $(UL
-         *   $(LI $(D assertion) fails if the $(D Any) object is
-         *        empty or $(D T) is not active)
-         * )
-         */
-        @trusted @property ref T instance(T)() nothrow
-            if (allows!(T))
-        in
-        {
-            assert(_which == _duckID!T);
-        }
-        body
-        {
-            return _storageAs!T;
-        }
-        /+ // @@@BUG3748@@@
-        @trusted @property ref inout(T) instance(T)() inout nothrow
-        +/
-    }
-
-    /// Ditto
-    alias _Any!() Any;
-
-
-    //----------------------------------------------------------------//
-private:
-    // The internal symbols are prefixed with an underscore so that
-    // opDispatch will not be blocked. @@@
-
-    /*
-     * Determines if the operation $(D op) is supported on all the ducks
-     * and the return types are compatible.
-     */
-    template _canDispatch(string op, Args...)
-    {
-        enum bool _canDispatch = __traits(compiles,
-                function(Args args)
-                {
-                    // The operation must be supported by all ducks, and
-                    // the return types must be compatible.
-                    foreach (Duck; Ducks)
-                    {
-                        Duck duck;
-                        static if (Args.length == 0)
-                            return mixin("duck." ~ op);
-                        else
-                            return mixin("duck." ~ op ~ "(args)");
-                    }
-                    assert(0);
-                });
-    }
-
-
-    /*
-     * Determines if a value of $(D T) can be assigned to at least one
-     * of the ducks.
-     */
-    template _canAssign(T, size_t i = 0)
-    {
-        static if (i < Ducks.length)
-            enum bool _canAssign =
-                is(Ducks[i] == T) ||
-                __traits(compiles,
-                    function(ref Ducks[i] duck, T rhs)
-                    {
-                        duck = rhs;
-                    })
-                || _canAssign!(T, i + 1);
-        else
-            enum bool _canAssign = false;
-    }
-
-    unittest
-    {
-        foreach (Duck; Ducks)
-            assert(_canAssign!(Duck));
-        struct Unknown {}
-        assert(!_canAssign!(Unknown));
-    }
-
-
-    /*
-     * Returns $(D true) if the type $(D T) is in the set of types
-     * $(D Ducks).
-     */
-    template _homogenizes(T)
-    {
-        enum bool _homogenizes = (_duckID!T != size_t.max);
-    }
-
-    unittest
-    {
-        foreach (Duck; Ducks)
-            assert(_homogenizes!(Duck));
-        struct Unknown {}
-        assert(!_homogenizes!(Unknown));
-    }
-
-
-    /*
-     * Returns the ID of the duck of type $(D T), or $(D size_t.max) if
-     * $(D T) is not in the set of the types.
-     */
-    template _duckID(T, size_t id = 0)
-    {
-        static if (id < Ducks.length)
-        {
-            static if (is(T == Ducks[id]))
-                enum size_t _duckID = id;
-            else
-                enum size_t _duckID = _duckID!(T, id + 1);
-        }
-        else
-        {
-            enum size_t _duckID = size_t.max;
-        }
-    }
-
-
-    /*
-     * Generates code for operating on the active duck.
-     */
-    template _onActiveDuck(string stmt)
-    {
-        enum string _onActiveDuck =
-                "assert(_which != size_t.max);" ~
-            "L_chooseActive:" ~
-                "final switch (_which) {" ~
-                    "foreach (Duck; Ducks) {" ~
-                        "case _duckID!Duck:" ~
-                            stmt ~
-                            "break L_chooseActive;" ~
-                    "}" ~
-                "}";
-    }
-
-
-    /*
-     * Set $(D rhs) in the storage.
-     */
-    @trusted void _grab(T)(ref T rhs)
-    in
-    {
-        assert(_which == size_t.max);
-    }
-    body
-    {
-        static if (_homogenizes!(T))
-        {
-            // Simple blit.
-            _init(_storageAs!T);
-            swap(_storageAs!T, rhs);
-            _which = _duckID!T;
-        }
-        else
-        {
-            // Use the first-matching opAssign.
-            foreach (Duck; Ducks)
-            {
-                static if (__traits(compiles, _storageAs!Duck() = rhs))
-                {
-                    _init(_storageAs!Duck);
-                    _storageAs!Duck() = rhs;
-                    _which = _duckID!Duck;
-                    break;
-                }
-            }
-        }
-    }
-
-
-    /*
-     * Assigns $(D rhs) to the existing active object.
-     */
-    @trusted void _assign(T)(ref T rhs)
-    in
-    {
-        assert(_which != size_t.max);
-    }
-    body
-    {
-        mixin (_onActiveDuck!(
-            q{
-                static if (__traits(compiles, _storageAs!Duck() = rhs))
-                    return _storageAs!Duck() = rhs;
-            }));
-
-        // Or, alter the content with rhs.
-        _dispose();
-        _grab(rhs);
-    }
-
-
-    /*
-     * Returns a reference to the holded object as an instance of
-     * type $(D T).  This does not validate the type.
-     */
-    @system ref T _storageAs(T)() nothrow
-        if (_homogenizes!(T))
-    {
-        foreach (Duck; Ducks)
-        {
-            static if (_duckID!T == _duckID!Duck)
-                return *cast(Duck*) _storage.ptr;
-        }
-        assert(0);
-    }
-    /+ // @@@BUG3748@@@
-    @system ref inout(T) storageAs(T)() inout nothrow
-    +/
-
-    @system ref const(T) _storageAs_const(T)() const nothrow
-        if (_homogenizes!(T))
-    {
-        foreach (Duck; Ducks)
-        {
-            static if (_duckID!T == _duckID!Duck)
-                return *cast(const Duck*) _storage.ptr;
-        }
-        assert(0);
-    }
-
-
-
-    /*
-     * Runs the copy constructor on the active object.
-     */
-    @trusted void _postblit()
-    in
-    {
-        assert(_which != size_t.max);
-    }
-    body
-    {
-        mixin (_onActiveDuck!(
-            q{
-                static if (__traits(compiles, _storageAs!Duck().__postblit()))
-                    _storageAs!Duck().__postblit();
-                return;
-            }));
-        assert(0);
-    }
-
-
-    /*
-     * Destroys the active object (if it's a struct) and markes this
-     * $(D Any) object empty.
-     */
-    @trusted void _dispose()
-    in
-    {
-        assert(_which != size_t.max);
-    }
-    out
-    {
-        assert(_which == size_t.max);
-    }
-    body
-    {
-        mixin (_onActiveDuck!(
-            q{
-                static if (__traits(compiles, _storageAs!Duck.__dtor()))
-                    _storageAs!Duck.__dtor();
-                _which = size_t.max;
-                return;
-            }));
-        assert(0);
-    }
-
-
-    //----------------------------------------------------------------//
-
-    // @@@ workaround
-    static if (_canDispatch!("front") && _canDispatch!("empty") &&
-            _canDispatch!("popFront"))
-    public @system
-    {
-        @property bool empty()
-        {
-            return opDispatch!("empty")();
-        }
-        @property auto ref front()
-        {
-            return opDispatch!("front")();
-        }
-        void popFront()
-        {
-            opDispatch!("popFront")();
-        }
-    }
-
-
-    //----------------------------------------------------------------//
-private:
-    size_t _which = size_t.max;     // ID of the 'active' Duck
-    union
-    {
-        ubyte[_maxSize!(0, Ducks)]                  _storage;
-        void*[_maxSize!(0, Ducks) / (void*).sizeof] _mark;
-    }
-}
-
-// These templates are prefixed by _ because templates are always public
-// even if they have the private attribute.
-
-private template _maxSize(size_t max, TT...)
-{
-    static if (TT.length > 0)
-    {
-        static if (max < TT[0].sizeof)
-            enum _maxSize = _maxSize!(TT[0].sizeof, TT[1 .. $]);
-        else
-            enum _maxSize = _maxSize!(         max, TT[1 .. $]);
-    }
-    else
-    {
-        enum _maxSize = max;
-    }
-}
-
-private @trusted void _init(T)(ref T obj)
-{
-    static if (is(T == struct))
-    {
-        auto buf  = (cast(void*) &obj   )[0 .. T.sizeof];
-        auto init = (cast(void*) &T.init)[0 .. T.sizeof];
-        buf[] = init[];
-    }
-    else
-    {
-        obj = T.init;
-    }
-}
-
-private template _commaExpand(string array, size_t N)
-    if (N >= 1)
-{
-    static if (N == 1)
-        enum string _commaExpand = array ~ "[0]";
-    else
-        enum string _commaExpand = _commaExpand!(array, N - 1)
-            ~ ", " ~ array ~ "[" ~ N.stringof ~ " - 1]";
-}
-
-
-version (unittest) private
-{
-    bool eq(S)(S a, S b)
-    {
-        foreach (i, _; a.tupleof)
-        {
-            if (a.tupleof[i] != b.tupleof[i])
-                return false;
-        }
-        return true;
-    }
-
-    bool fails(lazy void expr)
-    {
-        try { expr; } catch (Error e) { return true; }
-        return false;
-    }
-}
-
-unittest
-{
-    // copy constructor & destructor
-    struct Counter
-    {
-        int* copies;
-        this(this) { copies && ++*copies; }
-        ~this()    { copies && --*copies; }
-    }
-    Any!(Counter) a;
-    a = Counter(new int);
-    assert(*a.copies == 0);
-    {
-        auto b = a;
-        assert(*a.copies == 1);
-        {
-            auto c = a;
-            assert(*a.copies == 2);
-        }
-        assert(*a.copies == 1);
-    }
-    assert(*a.copies == 0);
-}
-
-unittest
-{
-    // basic use
-    int afoo, bfoo;
-    struct A {
-        int inc() { return ++afoo; }
-        int dec() { return --afoo; }
-    }
-    struct B {
-        int inc() { return --bfoo; }
-        int dec() { return ++bfoo; }
-    }
-    Any!(A, B) ab;
-    ab = A();
-    assert(ab.inc() == 1 && afoo == 1);
-    assert(ab.dec() == 0 && afoo == 0);
-    ab = B();
-    assert(ab.inc() == -1 && bfoo == -1);
-    assert(ab.dec() ==  0 && bfoo ==  0);
-}
-
-unittest
-{
-    // ref argument & ref return
-    struct K {
-        ref int foo(ref int a, ref int b) { ++b; return a; }
-    }
-    Any!(K) k;
-    int v, w;
-    k = K();
-    assert(&(k.foo(v, w)) == &v);
-    assert(w == 1);
-}
-
-unittest
-{
-    // meta interface
-    Any!(int, real) a;
-
-    assert(is(a.Any.Types == TypeTuple!(int, real)));
-    assert(a.Any.allows!int);
-    assert(a.Any.allows!real);
-    assert(!a.Any.allows!string);
-
-    assert(a.Any.empty);
-
-    a = 42;
-    assert(!a.Any.empty);
-    assert( a.Any.isActive!int);
-    assert(!a.Any.isActive!real);
-    assert(!a.Any.isActive!string);
-    int* i = &(a.Any.instance!int());
-    assert(*i == 42);
-
-    a = -21.0L;
-    assert(!a.Any.empty);
-    assert(!a.Any.isActive!int);
-    assert( a.Any.isActive!real);
-    assert(!a.Any.isActive!string);
-    real* r = &(a.Any.instance!real());
-    assert(*r == -21.0L);
-
-    a = a.init;
-    assert(a.Any.empty);
-}
-
-unittest
-{
-    // implicit convertion
-    Any!(real, const(char)[]) a;
-    a = 42;
-    assert(a.Any.isActive!real);
-    a = "abc";
-    assert(a.Any.isActive!(const(char)[]));
-}
-
-unittest
-{
-    // foreach over input range
-    Any!(string, wstring) str;
-
-    str = cast(string) "a";
-    assert(str.length == 1);
-    assert(str.front == 'a');
-    str.popFront;
-    assert(str.empty);
-
-    str = cast(wstring) "bc";
-    assert(str.length == 2);
-    str.popFront;
-    assert(str.front == 'c');
-    assert(!str.empty);
-
-    size_t i;
-    str = "\u3067\u3043\u30fc";
-    foreach (e; str)
-        assert(e == "\u3067\u3043\u30fc"d[i++]);
-}
-
-unittest
-{
-    // null dereference
-    Any!(short[], int[]) x;
-
-    assert(fails(x.length));
-
-    x = new int[4];
-    assert(x.length == 4);
-
-    x = typeof(x).init;
-    assert(fails(x.length));
-}
-
-// operator overloads
-
-unittest
-{
-    // opDispatch
-    struct Tag { string op; int n; }
-    struct OpEcho {
-        Tag opDispatch(string op)(int n) {
-            return Tag(op, n);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    auto r = obj.foo(42);
-    assert(eq( r, Tag("foo", 42) ));
-}
-
-unittest
-{
-    // opAssign
-    struct Tag { string op; int n; }
-    struct OpEcho {
-        int n;
-        void opAssign(int n) {
-            this.n = n;
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    obj = 42;
-    assert(obj.n == 42);
-}
-
-unittest
-{
-    // opUnary
-    struct Tag { string op; }
-    struct OpEcho {
-        Tag opUnary(string op)() {
-            return Tag(op);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (op; TypeTuple!("+", "-", "~", "*", "++", "--"))
-    {
-        auto r = mixin(op ~ "obj");
-        assert(eq( r, Tag(op) ));
-    }
-}
-
-unittest
-{
-    // opIndexUnary
-    struct Tag { string op; int x; real y; }
-    struct OpEcho {
-        Tag opIndexUnary(string op)(int x, real y) {
-            return Tag(op, x, y);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (op; TypeTuple!("+", "-", "~", "*", "++", "--"))
-    {
-        auto r = mixin(op ~ "obj[4, 2.5]");
-        assert(eq( r, Tag(op, 4, 2.5) ));
-    }
-}
-
-unittest
-{
-    // opSliceUnary
-    struct Tag { string op; int x; real y; }
-    struct OpEcho {
-        Tag opSliceUnary(string op, int k = 2)(int x, real y) {
-            return Tag(op, x, y);
-        }
-        Tag opSliceUnary(string op, int k = 0)() {
-            return Tag(op, -1, -1);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (op; TypeTuple!("+", "-", "~", "*", "++", "--"))
-    {
-        auto r = mixin(op ~ "obj[4 .. 5.5]");
-        assert(eq( r, Tag(op, 4, 5.5) ));
-
-        auto s = mixin(op ~ "obj[]");
-        assert(eq( s, Tag(op, -1, -1) ));
-    }
-}
-
-unittest
-{
-    // opCast
-    struct OpEcho {
-        T opCast(T)() { return T.init; }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (T; TypeTuple!(int, string, OpEcho))
-    {
-        auto r = cast(T) obj;
-        assert(is(typeof(r) == T));
-    }
-}
-
-unittest
-{
-    // opBinary, opBinaryRight
-    struct LTag { string op; int v; }
-    struct RTag { string op; int v; }
-    struct OpEcho {
-        LTag opBinary(string op)(int v) {
-            return LTag(op, v);
-        }
-        RTag opBinaryRight(string op)(int v) {
-            return RTag(op, v);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (op; TypeTuple!("+", "-", "*", "/", "%", "^^", "&",
-                "|", "^", "<<", ">>", ">>>", "~"/+, "in" @@@BUG ??@@@+/))
-    {
-        auto r = mixin("obj " ~ op ~ " 42");
-        assert(eq( r, LTag(op, 42) ));
-        auto s = mixin("76 " ~ op ~ " obj");
-        assert(eq( s, RTag(op, 76) ));
-    }
-}
-
-unittest
-{
-    // opEquals (forward)
-    struct Dummy {
-        bool opEquals(int v) const {
-            return v > 0;
-        }
-        bool opEquals(ref const Dummy) const { assert(0); }
-    }
-    Any!(Dummy) obj;
-
-    obj = Dummy();
-    assert(obj ==  1);
-    assert(obj !=  0);
-    assert(obj != -1);
-}
-
-unittest
-{
-    // opEquals (meta)
-    struct Dummy(int k) {
-        bool opEquals(int kk)(ref const Dummy!kk rhs) const {
-            return k == kk;
-        }
-    }
-    Any!(Dummy!0, Dummy!1) a, b;
-
-    a = Dummy!0();
-    b = Dummy!1();
-    assert(a == a);
-    assert(a != b);
-    assert(b == b);
-}
-
-unittest
-{
-    // opCmp (forward)
-    struct Dummy {
-        int opCmp(int v) const {
-            return 0 - v;
-        }
-        int opCmp(ref const Dummy) const { assert(0); }
-    }
-    Any!(Dummy) a;
-
-    a = Dummy();
-    assert(a >= 0);
-    assert(a > -1);
-    assert(a < 1);
-}
-
-unittest
-{
-    // opCmp (meta)
-    struct Dummy(int k) {
-        int opCmp(int kk)(ref const Dummy!kk r) const {
-            return k - kk;
-        }
-    }
-    Any!(Dummy!0, Dummy!1) a, b;
-
-    a = Dummy!0();
-    b = Dummy!1();
-    assert(a >= a);
-    assert(a <= b);
-    assert(a < b);
-    assert(b >= a);
-    assert(b <= b);
-    assert(b > a);
-}
-
-unittest
-{
-    // opCall
-    struct Tag { int x; real y; }
-    struct OpEcho {
-        Tag opCall(int x, real y) {
-            return Tag(x, y);
-        }
-    }
-    Any!(OpEcho) obj;
-
-//  obj = OpEcho(); // @@@BUG@@@
-    obj = OpEcho.init;
-    auto r = obj(4, 8.5);
-    assert(r == Tag(4, 8.5));
-}
-
-unittest
-{
-    // opOpAssign
-    struct Tag { string op; int v; }
-    struct OpEcho {
-        Tag opOpAssign(string op)(int v) {
-            return Tag(op, v);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (op; TypeTuple!("+", "-", "*", "/", "%", "^^", "&",
-                "|", "^", "<<", ">>", ">>>", "~"))
-    {
-        auto r = mixin("obj " ~ op ~ "= 97");
-        assert(eq( r, Tag(op, 97) ));
-    }
-}
-
-unittest
-{
-    // opIndexOpAssign
-    struct Tag { string op; int v; int x; real y; }
-    struct OpEcho {
-        Tag opIndexOpAssign(string op)(int v, int x, real y) {
-            return Tag(op, v, x, y);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (op; TypeTuple!("+", "-", "*", "/", "%", "^^", "&",
-                "|", "^", "<<", ">>", ">>>", "~"))
-    {
-        auto r = mixin("obj[4, 7.5] " ~ op ~ "= 42");
-        assert(eq( r, Tag(op, 42, 4, 7.5) ));
-    }
-}
-
-unittest
-{
-    // opSliceOpAssign
-    struct Tag { string op; int v; int i; real j; }
-    struct OpEcho {
-        Tag opSliceOpAssign(string op, int k = 2)(int v, int i, real j) {
-            return Tag(op, v, i, j);
-        }
-        Tag opSliceOpAssign(string op, int k = 0)(int v) {
-            return Tag(op, v, -1, -1);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (op; TypeTuple!("+", "-", "*", "/", "%", "^^", "&",
-                "|", "^", "<<", ">>", ">>>", "~"))
-    {
-        auto r = mixin("obj[4 .. 7.5] " ~ op ~ "= 42");
-        assert(eq( r, Tag(op, 42, 4, 7.5) ));
-
-        auto s = mixin("obj[] " ~ op ~ "= 42");
-        assert(eq( s, Tag(op, 42, -1, -1) ));
-    }
-}
-
-unittest
-{
-    // opIndex
-    struct Tag { int i; real j; }
-    struct OpEcho {
-        Tag opIndex(int i, real j) {
-            return Tag(i, j);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    auto r = obj[4, 9.5];
-    assert(eq( r, Tag(4, 9.5) ));
-}
-
-unittest
-{
-    // opSlice
-    struct Tag { int i; real j; }
-    struct OpEcho {
-        Tag opSlice(int i, real j) {
-            return Tag(i, j);
-        }
-        Tag opSlice() {
-            return Tag(-1, -1);
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    auto r = obj[4 .. 9.5];
-    assert(eq( r, Tag(4, 9.5) ));
-
-    auto s = obj[];
-    assert(eq( s, Tag(-1, -1) ));
-}
-
-/+
-unittest
-{
-    // opApply
-    struct OpEcho {
-        int opApply(int delegate(ref size_t, ref real) dg)
-        {
-            foreach (i, ref e; [ 1.L, 2.5L, 5.5L ])
-                if (auto r = dg(i, e))
-                    return r;
-            return 0;
-        }
-    }
-    Any!(OpEcho) obj;
-
-    obj = OpEcho();
-    foreach (size_t i, ref real e; obj)
-        assert(e == [ 1.L, 2.5L, 5.5L ][i]);
-}
-+/
-

branches/devel/stdio-native-codeset/phobos/std/variant.d

@@ -57 +57 @@
- * License:   <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
- * Authors:   $(WEB erdani.org, Andrei Alexandrescu)
- *
- *          Copyright Andrei Alexandrescu 2007 - 2009.
- * Distributed under the Boost Software License, Version 1.0.
- *    (See accompanying file LICENSE_1_0.txt or copy at
- *          http://www.boost.org/LICENSE_1_0.txt)
- */
-module std.variant;
-
-
+
+
+
-version(unittest)
-{
-
+range, std.
-}
-
-private template maxSize(T...)
-{
-    static if (T.length == 1)
-    {
-        enum size_t maxSize = T[0].sizeof;
-    }
-    else
-    {
@@ -982 +984 @@
-        auto arr = get!(A[]);
-        foreach (ref e; arr)
-        {
-            if (dg(e)) return 1;
-        }
-        return 0;
-    }
-}
-
-/**
- * Algebraic data type restricted to a closed set of possible
- * types. It's an alias for a $(D_PARAM VariantN) with an
- * appropriately-constructed maximum size. $(D_PARAM Algebraic) is
- * useful when it is desirable to restrict what a discriminated type
- * could hold to the end of defining simpler and more efficient
- * manipulation.
- *
- * Future additions to $(D_PARAM Algebraic) will allow compile-time
- * checking that all possible types are handled by user code,
- * eliminating a large class of errors.
- *
- * Bugs:
- *
- * Currently, $(D_PARAM Algebraic) does not allow recursive data
- * types. They will be allowed in a future iteration of the
- * implementation.
- *
- * Example:
- * ----
- * auto v = Algebraic!(int, double, string)(5);
- * assert(v.peek!(int));
- * v = 3.14;
- * assert(v.peek!(double));
- * // auto x = v.peek!(long); // won't compile, type long not allowed
- * // v = '1'; // won't compile, type char not allowed
- * ----
- */
-
-template Algebraic(T...)
-{
-    alias VariantN!(maxSize!(T), T) Algebraic;
-}
-
-/**
-$(D_PARAM Variant) is an alias for $(D_PARAM VariantN) instantiated
-with the largest of $(D_PARAM creal), $(D_PARAM char[]), and $(D_PARAM
-void delegate()). This ensures that $(D_PARAM Variant) is large enough
-to hold all of D's predefined types, including all numeric types,
-pointers, delegates, and class references.  You may want to use
-$(D_PARAM VariantN) directly with a different maximum size either for
-storing larger types, or for saving memory.
- */
-
-alias VariantN!(maxSize!(creal, char[], void delegate())) Variant;
@@ -1107 +1075 @@
-        this.source = source;
-        this.target = target;
-    }
-}
-
-unittest
-{
-    alias This2Variant!(char, int, This[int]) W1;
-    alias TypeTuple!(int, char[int]) W2;
-    static assert(is(W1 == W2));
-
-    alias Algebraic!(void, string) var_t;
-    var_t foo = "quux";
-}
-
-unittest
-{
-    // @@@BUG@@@
-    // alias Algebraic!(real, This[], This[int], This[This]) A;
-    // A v1, v2, v3;
-    // v2 = 5.0L;
-    // v3 = 42.0L;
-    // //v1 = [ v2 ][];
@@ -1389 +1354 @@
-unittest
-{
-    auto v = Variant([ 1, 2, 3, 4 ][]);
-    auto j = 0;
-    foreach (int i; v)
-    {
-        assert(i == ++j);
-    }
-    assert(j == 4);
-}
+
+
+//----------------------------------------------------------------------------//
+// Algebraic
+
+/+
+ + TODO:
+ +
+ +  - Make Algebraic.opBinary() etc. accept Algebraic rhs.
+ +
+ +  - Make Algebraic.empty sensible of infinite ranges.
+ +
+ +  - opApply
+ +
+ +  ? Prefer Algebraic!(T1,T2,...) to Algebraic!(R1,R2,...) for the return
+ +    type of oveloaded operators of Algebraic!(T1,T2,...) if { R1,R2,...} is
+ +    a subset of { T1,T2,... };  this might reduce program size and
+ +    compilation time.
+ +/
+
+
+// Hook for canonicalizing template instantiation arguments.
+template Algebraic(Types...)
+        if (!isAlgebraicCanonicalized!Types)
+{
+    alias Algebraic!(AlgebraicCanonicalize!Types) Algebraic;
+}
+
+private template AlgebraicCanonicalize(Types...)
+{
+    alias NoDuplicates!Types AlgebraicCanonicalize;
+
+    // validate
+    static assert(AlgebraicCanonicalize.length > 0,
+            "Attempted to instantiate Algebraic with empty argument");
+    static assert(staticIndexOf!(void, AlgebraicCanonicalize) < 0,
+            "void is not allowed for Algebraic");
+    static assert(isTypeTuple!AlgebraicCanonicalize,
+            "Attempted to isntantiate Algebraic with non-type argument(s)");
+}
+
+private template isAlgebraicCanonicalized(Types...)
+{
+    enum bool isAlgebraicCanonicalized =
+        is(Types == AlgebraicCanonicalize!Types);
+}
+
+private template isAlgebraic(A)
+{
+    enum bool isAlgebraic =
+        (UnpackAlgebraicInstantiationArguments!A.length > 0);
+}
+
+private template UnpackAlgebraicInstantiationArguments(A)
+{
+    alias UnpackAlgebraicInstantiationArgumentsImpl!A.Result
+                UnpackAlgebraicInstantiationArguments;
+}
+
+private template UnpackAlgebraicInstantiationArgumentsImpl(A)
+{
+    struct Unpack(UU...)
+    {
+        alias UU Expand;
+    }
+    extern Unpack!UU unpack(UU...)(Algebraic!UU x);
+
+    static if (is(typeof(unpack(A.init)).Expand Types))
+        alias Types        Result;
+    else
+        alias TypeTuple!() Result;
+}
+
+
+/**
+Algebraic data type restricted to a closed set of possible types.
+$(D Algebraic) is useful when it is desirable to restrict what a
+discriminated type could hold to the end of defining simpler and
+more efficient manipulation.
+
+$(D Algebraic) allows compile-time checking that all possible
+types are handled by user code, eliminating a large class of
+errors.
+--------------------
+Algebraic!(int, double) x;
+
+// these lines won't compile since long and string are not allowed
+auto n = x.Algebraic.instance!long;
+x = "abc";
+--------------------
+
+Bugs:
+
+$(UL
+ $(LI Currently, $(D Algebraic) does not allow recursive data types.
+     They will be allowed in a future iteration of the implementation.)
+ $(LI $(D opCall) overloads are hidden due to $(BUGZILLA 4243).
+ $(LI $(D opApply) overloads are hidden because it conflicts with
+     the $(D range) primitives.)
+)
+
+Examples:
+--------------------
+Algebraic!(int, double, string) v = 5;
+assert(v.Algebraic.isActive!int);
+
+v = 3.14;
+assert(v.Algebraic.isActive!double);
+
+v *= 2;
+assert(v > 6);
+--------------------
+
+You can call any method $(D Types) have against $(D Algebraic).
+--------------------
+Algebraic!(string, wstring, dstring) s;
+
+s = "The quick brown fox jumps over the lazy dog.";
+assert(s.front == 'T');
+assert(s.back == '.');
+assert(s.length == 44);
+s.popBack;
+assert(equal(take(retro(s), 3), "god"));
+--------------------
+
+Dispatch a holded object to handlers with $(D Algebraic.dispatch):
+--------------------
+Algebraic!(int, string) x = 42;
+
+x.Algebraic.dispatch(
+        (ref int n)
+        {
+            writeln("saw an int: ", n);
+            ++n;
+        },
+        (string s)
+        {
+            writeln("saw a string: ", s);
+        }
+    );
+assert(x == 43);    // incremented
+--------------------
+ */
+
+struct Algebraic(Types...)
+        if (isAlgebraicCanonicalized!(Types))
+{
+//  private alias This2Variant!(typeof(this), Types) _Types;    // @@@BUG4449@@@
+    private alias Types _Types;
+
+    /**
+     * Constructs an $(D Algebraic) object holding an object $(D init).
+     *
+     * See_Also:
+     *  $(D opAssign)
+     */
+    this(T)(T init)
+    {
+        static assert(_canAssign!(T), "Attempted to construct an "
+                ~ typeof(this).stringof ~ " with a disallowed initial "
+                "object of type " ~ T.stringof);
+        _grab(init);
+    }
+
+
+    /**
+     * Assigns $(D rhs) to the $(D Algebraic) object.
+     *
+     * If $(D T) is one of the $(D Types...), the active object (if any)
+     * is destroyed and $(D rhs) takes place of it;  otherwise assignment
+     * of $(D rhs) occurs on the active object.
+     *
+     * Throws:
+     *  $(UL
+     *   $(LI $(D VariantException) if $(D rhs) is an empty $(D Algebraic)
+     *      object.)
+     *   $(LI $(D VariantException) if $(D rhs) is an $(D Algebraic) object
+     *      holding an object that is not assignable to the left hand side.)
+     *  )
+     */
+    @system void opAssign(T)(T rhs)
+            if (_canAssign!(T) && !_isCompatibleAlgebraic!(T))
+    {
+        static if (_typeCode!T != size_t.max)
+        {
+            if (_which != size_t.max)
+                _dispose();
+            _grab(rhs);
+        }
+        else
+        {
+            if (_which == size_t.max)
+                _grab(rhs);
+            else
+                _assign(rhs);
+        }
+    }
+
+    // simple blit
+    @trusted void opAssign(T)(T rhs)
+            if (is(T == typeof(this)))
+    {
+        swap(this, rhs);
+    }
+
+    // intersection
+    @system void opAssign(T)(T rhs)
+            if (_isCompatibleAlgebraic!(T) && !is(T == typeof(this)))
+    {
+        if (rhs._which == size_t.max)
+            throw new VariantException("Attempted to assign an empty "
+                    ~ T.stringof ~ " to " ~ typeof(this).stringof);
+
+        final switch (rhs._which)
+        {
+            foreach (U; rhs._Types)
+            {
+            case rhs._typeCode!U:
+                static if (_canAssign!U)
+                    return opAssign(rhs._storageAs!U);
+                else
+                    throw new VariantException("Attempted to assign an "
+                        ~ T.stringof ~ " holding " ~ U.stringof ~ " which "
+                        "is incompatible with " ~ typeof(this).stringof);
+            }
+        }
+        assert(0);
+    }
+
+    private template _canAssign(T, size_t i = 0)
+    {
+        static if (i < _Types.length && is(_Types[i] Type))
+            enum bool _canAssign =
+                   is(T : Type)
+                || is(typeof(phony!Type = phony!T))
+                || _isCompatibleAlgebraic!(T)
+                || _canAssign!(T, i + 1);
+        else
+            enum bool _canAssign = false;
+    }
+
+    // Returns true if this and A have nonempty intersection
+    private template _isCompatibleAlgebraic(A)
+    {
+        static if (isAlgebraic!(A) && is(A._Types UU))
+            enum bool _isCompatibleAlgebraic =
+                _Types.length + UU.length > NoDuplicates!(_Types, UU).length;
+        else
+            enum bool _isCompatibleAlgebraic = false;
+    }
+
+    // @@@BUG4424@@@ workaround
+    private template _workaround4424()
+        { @disable void opAssign(...) { assert(0); } }
+    mixin _workaround4424 _workaround4424_;
+
+
+    /**
+     * Invokes the copy constructor on the active object if any.
+     */
+    this(this)
+    {
+        if (_which != size_t.max)
+        {
+            mixin (_onActiveObject!(
+                q{
+                    static if (__traits(compiles,
+                            _storageAs!Active().__postblit() ))
+                        _storageAs!Active().__postblit();
+                }));
+        }
+    }
+
+
+    /**
+     * Invokes the destructor on the active object if any.
+     */
+    ~this()
+    {
+        if (_which != size_t.max)
+            _dispose();
+    }
+
+
+    //------------------------------------------------------------------------//
+
+    /**
+     * $(D Algebraic) namespace for operating on the $(D Algebraic) object
+     * itself, not a holded object.
+     *
+     * Example:
+--------------------
+Algebraic!(A, B) ab;
+assert(ab.Algebraic.empty);
+
+ab = A();
+assert(ab.Algebraic.isActive!A);
+--------------------
+     */
+    private template _Algebraic()
+    {
+        /**
+         * The type tuple used to instantiate the $(D Algebraic) with no
+         * duplicates.
+         *
+         * Example:
+--------------------
+Algebraic!(int, int, real, int) x;
+assert(is( x.Algebraic.Types == TypeTuple!(int, real) ));
+--------------------
+         */
+        alias _Types Types;
+
+
+        /**
+         * Returns $(D true) if type $(D T) is contained in $(D Types...).
+         */
+        template allowed(T)
+        {
+            enum bool allowed = (_typeCode!T != size_t.max);
+        }
+
+
+        /**
+         * Returns $(D true) if an object of type $(D T) can be assigned to
+         * the $(D Algebraic) object.
+         */
+        template canAssign(T)
+        {
+            enum bool canAssign = _canAssign!T;
+        }
+
+
+        /**
+         * Returns $(D true) if the $(D Algebraic) object holds nothing.
+         */
+        @safe @property nothrow bool empty() const
+        {
+            return _which == size_t.max;
+        }
+
+
+        /**
+         * Returns $(D true) if the type of the active object is $(D T).
+         */
+        @safe nothrow bool isActive(T)() const
+        {
+            return _which != size_t.max && _which == _typeCode!T;
+        }
+
+
+        /**
+         * Returns $(D true) if and only if the $(D Algebraic) object holds
+         * an object implicitly convertible to type $(D T).
+         */
+        @safe nothrow bool convertsTo(T)() const
+        {
+            if (_which == size_t.max)
+                return false;
+            mixin (_onActiveObject!(
+                q{
+                    return isImplicitlyConvertible!(Active, T);
+                }));
+            assert(0);
+        }
+
+
+        /**
+         * Returns the active object as a reference of type $(D T).  $(D T)
+         * must be the type of the active object, i.e.,
+         * $(D isActive!T == true).
+         *
+         * Throws:
+         * $(UL
+         *   $(LI $(D VariantException) if the $(D Algebraic) object is
+         *        empty or $(D T) is not active.)
+         * )
+         *
+         * Example:
+--------------------
+// take a pointer to the active object
+Algebraic!(A, B) ab = A();
+
+assert(ab.Algebraic.isActive!A);
+A* p = &(ab.Algebraic.instance!A());
+B* q = &(ab.Algebraic.instance!B());    // throws VariantException
+--------------------
+         */
+        @safe @property ref T instance(T)()
+                if (allowed!(T))
+        {
+            if (!isActive!T)
+                throw new VariantException("Attempting to peek a reference "
+                        ~ "to " ~ T.stringof ~ " in " ~ typeof(this).stringof);
+            return _storageAs!T;
+        }
+        /+ // @@@BUG3748@@@
+        @trusted @property nothrow ref inout(T) instance(T)() inout
+        +/
+
+
+        /**
+         * Returns the active object as a value of type $(D T) allowing
+         * implicit convertion.
+         *
+         * Throws:
+         *  $(UL
+         *   $(LI Compile fails if none of $(D Types...) supports implicit
+         *      convertion to $(D T).)
+         *   $(LI $(D VariantException) if the $(D Algebraic) object is
+         *      empty or the active object is not implicitly convertible
+         *      to $(D T).)
+         *  )
+         */
+        @safe T get(T)()
+                if (canGet!(T))
+        {
+            if (_which == size_t.max)
+                throw new VariantException("Attempted to get a value of "
+                        "type " ~ T.stringof ~ " out of an empty "
+                        ~ typeof(this).stringof);
+
+            mixin (_onActiveObject!(
+                q{
+                    static if (isImplicitlyConvertible!(Active, T))
+                        return _storageAs!Active;
+                    else
+                        throw new VariantException(Active.stringof
+                            ~ "is not implicitly convertible to "
+                            ~ T.stringof);
+                }));
+            assert(0);
+        }
+        /+ // @@@BUG3748@@@
+        @trusted inout(T) get(T)() inout
+        +/
+
+        private template canGet(T, size_t i = 0)
+        {
+            // Convertion must be supported by at least one type.
+            static if (i < _Types.length && is(_Types[i] Active))
+                enum bool canGet = isImplicitlyConvertible!(Active, T)
+                        || canGet!(T, i + 1);
+            else
+                enum bool canGet = false;
+        }
+
+
+        /**
+         * Returns the active object explicitly converted to $(D T) using
+         * $(D std.conv.to!T).
+         *
+         * Throws:
+         *  $(UL
+         *   $(LI Compile fails if none of $(D Types...) supports explicit
+         *      convertion to $(D T).)
+         *   $(LI $(D VariantException) if the $(D Algebraic) object is
+         *      empty.)
+         *   $(LI $(D ConvError) on any convertion error.)
+         *  )
+         */
+        @system T coerce(T)()
+                if (canCoerce!(T))
+        {
+            if (_which == size_t.max)
+                throw new VariantException("Attempted to coerce an empty "
+                        ~ typeof(this).stringof ~ " into " ~ T.stringof);
+
+            mixin (_onActiveObject!(
+                q{
+                    static if (__traits(compiles, to!T(phony!Active)))
+                        return to!T(_storageAs!Active);
+                    else
+                        throw new ConvError("Can't convert a value of type "
+                            ~ Active.stringof ~ " to type " ~ T.stringof);
+                }));
+            assert(0);
+        }
+
+        private template canCoerce(T, size_t i = 0)
+        {
+            // Convertion must be supported by at least one type.
+            static if (i < _Types.length && is(_Types[i] Active))
+                enum bool canCoerce = __traits(compiles, to!T(phony!Active))
+                        || canCoerce!(T, i + 1);
+            else
+                enum bool canCoerce = false;
+        }
+
+
+        /**
+         * Passes a reference to the active object by reference to
+         * appropriate $(D handlers) in turn.
+         *
+         * Returns:
+         *  $(D true) if at least one handler is called.
+         *
+         * Example:
+--------------------
+Algebraic!(A, B, C) x = A.init;
+
+// will print "saw an A" and "it's an A"
+auto matched = x.Algebraic.dispatch(
+        (A obj) { writeln("saw an A"); },
+        (B obj) { writeln("saw a B"); },
+        (ref A obj) { writeln("it's an A"); }
+    );
+assert(matched == true);
+--------------------
+         */
+        bool dispatch(Handlers...)(Handlers handlers)
+        {
+            if (_which == size_t.max)
+                return false;
+
+            uint match = 0;
+            mixin (_onActiveObject!(
+                q{
+                    foreach (handler; handlers)
+                    {
+                        static if (__traits(compiles, handler(_storageAs!Active)))
+                        {
+                            handler(_storageAs!Active);
+                            ++match;
+                        }
+                    }
+                }));
+            return match != 0;
+        }
+    }
+
+    /// Ditto
+    alias _Algebraic!() Algebraic;
+
+
+    //--------------------------------------------------------------------//
+    // standard operator overloads
+
+    /*
+     * Generates code for returning $(D expr) evaluated on the active
+     * object of type $(D Active).  $(D typeof(return)) must be inferable.
+     */
+    private template _returnUsingActiveObject(string expr)
+    {
+        enum string _returnUsingActiveObject = _onActiveObject!(
+             "static if (is(typeof(0, (" ~ expr ~ ")) Ri))"
+            ~"{"
+                ~"static if (is(Ri == void))"
+                ~"{"
+                    ~"return (" ~ expr ~ "), byValue!(typeof(return));"
+                ~"}"
+                ~"else"
+                ~"{"
+                    ~"return byValue!(typeof(return))(" ~ expr ~ ");"
+                ~"}"
+            ~"}");
+    }
+
+    /*
+     * Returns Algebraic!( RTs[0], RTs[1], ... ), or $(D void) if $(D RTs)
+     * is empty or consisting only of $(D void)s.
+     */
+    private template _ReduceOpGenericRT(RTs...)
+    {
+        static if (is(Erase!(void, staticMap!(Unqual, RTs)) NVRTs) &&
+                    NVRTs.length > 0)
+            alias .Algebraic!NVRTs _ReduceOpGenericRT;
+        else
+            alias void             _ReduceOpGenericRT;
+    }
+
+    /*
+     * Maps Types --> { typeof(expr) | Active in Types }, where expr is
+     * an expression in which Active and Args are used.
+     */
+    private template _MapOpGenericRTs(size_t i, string expr, Args...)
+    {
+        static if (i < _Types.length && is(_Types[i] Active))
+        {
+            static if (is(typeof(0, mixin(expr)) R))
+                alias TypeTuple!(R, _MapOpGenericRTs!(i + 1, expr, Args))
+                            _MapOpGenericRTs;
+            else
+                alias _MapOpGenericRTs!(i + 1, expr, Args)
+                            _MapOpGenericRTs;
+        }
+        else
+        {
+            alias TypeTuple!() _MapOpGenericRTs;
+        }
+    }
+
+
+    /**
+     * Evaluates a method or a property $(D op) on the active object.
+     *
+     * The operation $(D op) must be defined by at least one type in the
+     * allowed $(D Types...).
+     *
+     * Params:
+     *  args = The arguments to be passed to the method.
+     *
+     * Returns:
+     *  The value returned by the active object's method $(D op).
+     *
+     *  The type of the result is the $(D CommonType) of all $(D op)s on
+     *  possible $(D Types...).  It's returned by reference if all the
+     *  return types are identical and returned by reference.
+--------------------
+Algebraic!(int, real) n = 0;
+assert(is(typeof(n.max) == real));
+
+Algebraic!(int[], Retro!(int[])) r = [ 1, 2, 3 ];
+auto p = &(r.front());
+assert(*p == 1);
+--------------------
+     *
+     * Throws:
+     *  $(UL
+     *   $(LI $(D VariantException) if the $(D Algebraic) object is
+     *        empty.)
+     *   $(LI $(D VariantException) if the method $(D op) is not
+     *        defined by the active object.)
+     *  )
+     *
+     * BUGS:
+     *  $(UL
+     *   $(LI Forward reference errors may occur due to $(BUGZILLA 3294).
+     *       For example, $(D hasLength) reports $(D false) even if the
+     *       $(D length) property is really available.)
+     *  )
+     */
+    auto ref opDispatch(string op, Args...)(auto ref Args args)
+            if (_canDispatch!(op, Args))
+    {
+        alias CommonType!(_MapOpDispatchRTs!(op, Args)) RT;
+        enum byRef    = _canDispatchByRef!(op, Args);
+
+        enum attempt  = (Args.length ? op ~ Args.stringof : op);
+        enum dispatch = "_storageAs!Active()."
+                ~ (args.length ? op ~ "(args)" : op);
+
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+        //
+        mixin (_onActiveObject!(
+            q{
+                static if (is(typeof(0, mixin(dispatch)) Ri))
+                {
+                    static if (byRef)
+                    {
+                        // Return the result by reference.
+                        return mixin(dispatch);
+                    }
+                    else static if (!is(RT == void) && !is(Ri == void))
+                    {
+                        // Return the result by value of type RT.
+                        return byValue!RT(mixin(dispatch));
+                    }
+                    else
+                    {
+                        // Just dispatch the method and return nothing.
+                        return mixin(dispatch), byValue!RT;
+                    }
+                }
+            }));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpDispatchRTs(string op, Args...)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active."
+                    ~ (Args.length ? op ~ "(phonyList!Args)" : op),
+                Args
+            ) _MapOpDispatchRTs;
+    }
+
+    private template _canDispatch(string op, Args...)
+    {
+        enum bool _canDispatch =
+            _MapOpDispatchRTs!(op, Args).length > 0;
+    }
+
+    private template _canDispatchByRef(string op, Args...)
+    {
+        enum bool _canDispatchByRef =
+            NoDuplicates!(_MapOpDispatchRTs!(op, Args)).length == 1
+            &&
+            __traits(compiles, function(Args args)
+                {
+                    enum dispatch = "obj."
+                        ~ (args.length ? op ~ "(args)" : op);
+                    foreach (Type; _Types)
+                    {
+                        Type obj;
+                        expectLvalue(mixin(dispatch));
+                    }
+                });
+    }
+
+
+    //--------------------------------------------------------------------//
+
+    /*
+     * <op>storageAs!Active
+     */
+    _ReduceOpGenericRT!(_MapOpUnaryRTs!(op))
+        opUnary(string op)()
+    {
+        enum string attempt = "unary " ~ op;
+
+        static assert(_MapOpUnaryRTs!(op).length, _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                op~"_storageAs!Active"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpUnaryRTs(string op)
+    {
+        alias _MapOpGenericRTs!(0, op~"phony!Active") _MapOpUnaryRTs;
+    }
+
+
+    /*
+     * storageAs!Active <op> rhs
+     */
+    _ReduceOpGenericRT!(_MapOpBinaryRTs!(op, RHS))
+        opBinary(string op, RHS)(RHS rhs)
+    {
+        enum string attempt = "binary " ~ op ~ " " ~ RHS.stringof;
+
+        static assert(_MapOpBinaryRTs!(op, RHS).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active() "~op~" rhs"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpBinaryRTs(string op, RHS)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active "~op~" phony!(Args[0])",
+                RHS
+            ) _MapOpBinaryRTs;
+    }
+
+
+    /*
+     * lhs <op> storageAs!Active
+     */
+    _ReduceOpGenericRT!(_MapOpBinaryRightRTs!(op, LHS))
+        opBinaryRight(string op, LHS)(LHS lhs)
+            if (!_isCompatibleAlgebraic!(LHS))
+    {
+        enum string attempt = "binary " ~ LHS.stringof ~ " " ~ op;
+
+        static assert(_MapOpBinaryRightRTs!(op, LHS).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "lhs "~op~" _storageAs!Active"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpBinaryRightRTs(string op, LHS)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!(Args[0]) " ~ op ~ " phony!Active",
+                LHS
+            ) _MapOpBinaryRightRTs;
+    }
+
+
+    /*
+     * storageAs!Active[ indices[0], ... ]
+     */
+    _ReduceOpGenericRT!(_MapOpIndexRTs!(Indices))
+        opIndex(Indices...)(Indices indices)
+    {
+        enum size_t K       = Indices.length;
+        enum string attempt = to!string(K) ~ "-indexing";
+
+        static assert(_MapOpIndexRTs!(Indices).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+//              "_storageAs!Active()[indices]" // @@@BUG4444@@@
+                "_storageAs!Active()[" ~ expandArray("indices", K) ~ "]"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpIndexRTs(Indices...)
+    {
+        alias _MapOpGenericRTs!(0,
+//              "phony!Active[phonyList!Args]", // @@@BUG4444@@@
+                "phony!Active[" ~ expandArray("phonyList!Args", Indices.length) ~ "]",
+                Indices
+            ) _MapOpIndexRTs;
+    }
+
+
+    /*
+     * storageAs!Active[i .. j]
+     */
+    _ReduceOpGenericRT!(_MapOpSliceRTs!(I, J))
+        opSlice(I, J)(I i, J j)
+    {
+        enum string attempt = "slicing";
+
+        static assert(_MapOpSliceRTs!(I, J).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active()[i .. j]"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpSliceRTs(I, J)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active[phony!(Args[0]) .. phony!(Args[1])]",
+                I, J
+            ) _MapOpSliceRTs;
+    }
+
+
+    /*
+     * storageAs!Active[]
+     */
+    _ReduceOpGenericRT!(_MapOpSliceRTs!())
+        opSlice()()
+    {
+        enum string attempt = "whole-slicing";
+
+        static assert(_MapOpSliceRTs!().length, _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active()[]"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpSliceRTs()
+    {
+        alias _MapOpGenericRTs!(0, "phony!Active[]") _MapOpSliceRTs;
+    }
+
+
+    /*
+     * <op>storageAs!Active[ indices[0], ... ]
+     */
+    _ReduceOpGenericRT!(_MapOpIndexUnaryRTs!(op, Indices))
+        opIndexUnary(string op, Indices...)(Indices indices)
+    {
+        enum size_t K       = Indices.length;
+        enum string attempt = to!string(K) ~ "-indexing unary " ~ op;
+
+        static assert(_MapOpIndexUnaryRTs!(op, Indices).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+//              op~"_storageAs!Active()[indices]"   // @@@BUG4444@@@
+                op~"_storageAs!Active()[" ~ expandArray("indices", K) ~ "]"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpIndexUnaryRTs(string op, Indices...)
+    {
+        alias _MapOpGenericRTs!(0,
+//              op~"phony!Active[phonyList!Args]",  // @@@BUG4444@@@
+                op~"phony!Active["
+                    ~ expandArray("phonyList!Args", Indices.length) ~ "]",
+                Indices
+            ) _MapOpIndexUnaryRTs;
+    }
+
+
+    /*
+     * <op>storageAs!Active[i .. j]
+     */
+    _ReduceOpGenericRT!(_MapOpSliceUnaryRTs!(op, I, J))
+        opSliceUnary(string op, I, J)(I i, J j)
+    {
+        enum string attempt = "unary slicing " ~ op;
+
+        static assert(_MapOpSliceUnaryRTs!(op, I, J).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                op~"_storageAs!Active()[i .. j]"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpSliceUnaryRTs(string op, I, J)
+    {
+        alias _MapOpGenericRTs!(0,
+                op~"phony!Active[phony!(Args[0]) .. phony!(Args[1])]",
+                I, J
+            ) _MapOpSliceUnaryRTs;
+    }
+
+
+    /*
+     * <op>storageAs!Active[]
+     */
+    _ReduceOpGenericRT!(_MapOpSliceUnaryRTs!(op))
+        opSliceUnary(string op)()
+    {
+        enum string attempt = "unary whole-slicing " ~ op;
+
+        static assert(_MapOpSliceUnaryRTs!(op).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                op~"_storageAs!Active()[]"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpSliceUnaryRTs(string op)
+    {
+        alias _MapOpGenericRTs!(0, op ~ "phony!Active[]") _MapOpSliceUnaryRTs;
+    }
+
+
+    /*
+     * storageAs!Active[ indices[0], ... ] = rhs
+     */
+    _ReduceOpGenericRT!(_MapOpIndexAssignRTs!(RHS, Indices))
+        opIndexAssign(RHS, Indices...)(RHS rhs, Indices indices)
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum size_t K       = Indices.length;
+        enum string attempt = to!string(K) ~ "-indexing assignment of "
+                                ~ RHS.stringof;
+
+        static assert(_MapOpIndexAssignRTs!(RHS, Indices).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+//              "_storageAs!Active()[indices] = rhs"    // @@@BUG4444@@@
+                "_storageAs!Active()[" ~ expandArray("indices", K) ~ "] = rhs"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpIndexAssignRTs(RHS, Indices...)
+    {
+        alias _MapOpGenericRTs!(0,
+//              "phony!Active[ phonyList!(Args[1 .. $]) ] = phony!(Args[0])", // @@@BUG4444@@@
+                "phony!Active[" ~ expandArray(
+                    "phonyList!(Args[1 .. $])", Indices.length)
+                        ~ "] = phony!(Args[0])",
+                RHS, Indices
+            ) _MapOpIndexAssignRTs;
+    }
+
+
+    /*
+     * storageAs!Active[i .. j] = rhs
+     */
+    _ReduceOpGenericRT!(_MapOpSliceAssignRTs!(RHS, I, J))
+        opSliceAssign(RHS, I, J)(RHS rhs, I i, J j)
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum string attempt = "slicing assignment of " ~ RHS.stringof;
+
+        static assert(_MapOpSliceAssignRTs!(RHS, I, J).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active()[i .. j] = rhs"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpSliceAssignRTs(RHS, I, J)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active[phony!(Args[1]) .. phony!(Args[2])]"
+                    ~ " = phony!(Args[0])",
+                RHS, I, J
+            ) _MapOpSliceAssignRTs;
+    }
+
+
+    /*
+     * storageAs!Active[] = rhs
+     */
+    _ReduceOpGenericRT!(_MapOpSliceAssignRTs!(RHS))
+        opSliceAssign(RHS)(RHS rhs)
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum string attempt = "whole-slicing assignment of " ~ RHS.stringof;
+
+        static assert(_MapOpSliceAssignRTs!(RHS).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active()[] = rhs"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpSliceAssignRTs(RHS)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active[] = phony!(Args[0])",
+                RHS
+            ) _MapOpSliceAssignRTs;
+    }
+
+
+    /*
+     * storageAs!Active <op>= rhs
+     */
+    _ReduceOpGenericRT!(_MapOpOpAssignRTs!(op, RHS))
+        opOpAssign(string op, RHS)(RHS rhs)
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum string attempt = "binary assignment "~op~"= " ~ RHS.stringof;
+
+        static assert(_MapOpOpAssignRTs!(op, RHS).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active() "~op~"= rhs"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpOpAssignRTs(string op, RHS)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active "~op~"= phony!(Args[0])",
+                RHS
+            ) _MapOpOpAssignRTs;
+    }
+
+
+    /*
+     * storageAs!Active[ indices[0], ... ] <op>= rhs
+     */
+    _ReduceOpGenericRT!(_MapOpIndexOpAssignRTs!(op, RHS, Indices))
+        opIndexOpAssign(string op, RHS, Indices...)(RHS rhs, Indices indices)
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum string attempt = "binary indexing assignment "
+                                ~op~"= " ~ RHS.stringof;
+
+        static assert(_MapOpIndexOpAssignRTs!(op, RHS, Indices).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+//              "_storageAs!Active()[indices] "~op~"= rhs"  // @@@BUG4444@@@
+                "_storageAs!Active()["
+                        ~ expandArray("indices", Indices.length)
+                    ~ "] "~op~"= rhs"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpIndexOpAssignRTs(string op, RHS, Indices...)
+    {
+        alias _MapOpGenericRTs!(0,
+//              "phony!Active[phonyList!(Args[1 .. $])] "
+//                  ~op~"= phony!(Args[0])",    // @@@BUG4444@@@
+                "phony!Active[" ~ expandArray(
+                    "phonyList!(Args[1 .. $])", Indices.length) ~ "] "
+                    ~op~"= phony!(Args[0])",
+                RHS, Indices
+            ) _MapOpIndexOpAssignRTs;
+    }
+
+
+    /*
+     * storageAs!Active[i .. j] <op>= rhs
+     */
+    _ReduceOpGenericRT!(_MapOpSliceOpAssignRTs!(op, RHS, I, J))
+         opSliceOpAssign(string op, RHS, I, J)(RHS rhs, I i, J j)
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum string attempt = "binary slicing assignment "
+                                ~op~"= " ~ RHS.stringof;
+
+        static assert(_MapOpSliceOpAssignRTs!(op, RHS, I, J).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active()[i .. j] "~op~"= rhs"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpSliceOpAssignRTs(string op, RHS, I, J)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active[phony!(Args[1]) .. phony!(Args[2])] "
+                    ~op~"= phony!(Args[0])",
+                RHS, I, J
+            ) _MapOpSliceOpAssignRTs;
+    }
+
+
+    /*
+     * storageAs!Active[] <op>= rhs
+     */
+    _ReduceOpGenericRT!(_MapOpSliceOpAssignRTs!(op, RHS))
+        opSliceOpAssign(string op, RHS)(RHS rhs)
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum string attempt = "binary whole-slicing assignment "
+                                ~op~"= " ~ RHS.stringof;
+
+        static assert(_MapOpSliceOpAssignRTs!(op, RHS).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active()[] "~op~"= rhs"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpSliceOpAssignRTs(string op, RHS)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active[] "~op~"= phony!(Args[0])",
+                RHS
+            ) _MapOpSliceOpAssignRTs;
+    }
+
+
+    //--------------------------------------------------------------------//
+
+    /*
+     * cast(T) storageAs!Active
+     */
+    T opCast(T)()
+    {
+        enum attempt = "casting to " ~ T.stringof;
+
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+        mixin (_onActiveObject!(
+            q{
+                static if (is(Active : T))
+                    return         _storageAs!Active;
+//              else static if (__traits(compiles, cast(T) _storageAs!Active))  // @@@ e2ir
+                else static if (is(typeof(Active.opCast!T) R == return) && is(R == T))
+                    return cast(T) _storageAs!Active;
+            }));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+
+    /*
+     * storageAs!Active == rhs
+     */
+    bool opEquals(RHS)(auto ref RHS rhs) const
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum attempt = "equality comparison with " ~ RHS.stringof;
+
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+        mixin (_onActiveObject!(
+            q{
+                static if (__traits(compiles,
+                        _storageAs_const!Active() == rhs))
+                    return _storageAs_const!Active() == rhs;
+            }));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    // Algebraic vs. Algebraic
+    bool opEquals(RHS)(ref const RHS rhs) const
+            if (is(RHS == typeof(this)))
+    {
+        if (_which != size_t.max && _which == rhs._which)
+        {
+            mixin (_onActiveObject!(
+                q{
+                    return _storageAs_const!Active() ==
+                            rhs._storageAs_const!Active;
+                }));
+            assert(0);
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+
+    /*
+     * storageAs!Active <>= rhs
+     */
+    int opCmp(RHS)(auto ref RHS rhs) const
+            if (!_isCompatibleAlgebraic!(RHS))
+    {
+        enum attempt = "ordering comparison with " ~ RHS.stringof;
+
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+        mixin (_onActiveObject!(
+            q{
+                static if (__traits(compiles, _storageAs_const!Active < rhs))
+                {
+                    return (_storageAs_const!Active < rhs) ? -1 :
+                           (_storageAs_const!Active > rhs) ?  1 : 0;
+                }
+            }));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    // Algebraic vs. Algebraic
+    int opCmp(RHS)(ref const RHS rhs) const
+            if (is(RHS == typeof(this)))
+    {
+        enum attempt = "ordering comparison";
+
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+        mixin (_onActiveObject!(
+            q{
+                return -rhs.opCmp(_storageAs_const!Active);
+            }));
+        assert(0);
+    }
+
+/+
+// @@@BUG4253@@@
+    _ReduceOpGenericRT!(_MapOpCallRTs!(Args))
+        opCall(Args...)(auto ref Args args)
+    {
+        enum string attempt = "calling operator";
+
+        static assert(_MapOpCallRTs!(Args).length,
+                _invalidOpMsg(attempt));
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+
+        mixin (_returnUsingActiveObject!(
+                "_storageAs!Active(args)"
+            ));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
+
+    private template _MapOpCallRTs(Args...)
+    {
+        alias _MapOpGenericRTs!(0,
+                "phony!Active(phonyList!Args)",
+                Args
+            ) _MapOpCallRTs;
+    }
++/
+
+/+
+// @@@ cannot coexist with input range primitives
+    int opApply(Args...)(int delegate(ref Args) dg)
+    {
+        enum attempt = "foreach";
+
+        if (_which == size_t.max)
+            throw new VariantException(_emptyMsg(attempt));
+        mixin (_onActiveObject!(
+            q{
+                static if (__traits(compiles,
+                        _storageAs!Active().opApply(dg)))
+                    return _storageAs!Active().opApply(dg);
+            }));
+        throw new VariantException(_undefinedOpMsg(attempt));
+    }
++/
+
+
+    //--------------------------------------------------------------------//
+    // special functions
+
+    @system string toString()
+    {
+        if (_which == size_t.max)
+            return typeof(this).stringof ~ "(empty)";
+
+        mixin (_onActiveObject!(
+            q{
+                static if (__traits(compiles,
+                        to!string(_storageAs!Active) ))
+                    return to!string(_storageAs!Active);
+                else
+                    return Active.stringof;
+            }));
+        assert(0);
+    }
+//  @system string toString(
+//      void delegate(const(char)[]) sink = null,
+//      string fmt = null)
+
+    @system hash_t toHash() const
+    {
+        if (_which == size_t.max)
+            return 0;
+
+        mixin (_onActiveObject!(
+            q{
+                return typeid(Active).getHash(_storage.ptr);
+            }));
+        assert(0);
+    }
+
+
+    // input range primitives
+    static if (_canDispatch!"front" &&
+               _canDispatch!"empty" &&
+               _canDispatch!"popFront")
+    {
+        @property bool empty()
+        {
+            return opDispatch!"empty"();
+        }
+        @property auto ref front()
+        {
+            return opDispatch!"front"();
+        }
+        void popFront()
+        {
+            opDispatch!"popFront"();
+        }
+    }
+
+    // forward range primitive
+    static if (_canDispatch!"save")
+    {
+        @property typeof(this) save()
+        {
+            enum string attempt = "range primitive save()";
+            if (_which == size_t.max)
+                throw new VariantException(_emptyMsg(attempt));
+            mixin (_returnUsingActiveObject!(
+                    "_storageAs!Active.save"
+                ));
+            throw new VariantException(_undefinedOpMsg(attempt));
+        }
+    }
+
+    // bidirectional range primitives
+    static if (_canDispatch!"back" &&
+               _canDispatch!"popBack")
+    {
+        @property auto ref back()
+        {
+            return opDispatch!"back"();
+        }
+        void popBack()
+        {
+            opDispatch!"popBack"();
+        }
+    }
+
+
+    //------------------------------------------------------------//
+    // internals
+private:
+
+    /*
+     * Returns the internal code number of the type $(D T), or
+     * $(D size_t.max) if $(D T) is not in $(D Types...).
+     */
+    template _typeCode(T, size_t id = 0)
+    {
+        static if (id < _Types.length)
+        {
+            static if (is(T == _Types[id]))
+                enum size_t _typeCode = id;
+            else
+                enum size_t _typeCode = _typeCode!(T, id + 1);
+        }
+        else
+        {
+            enum size_t _typeCode = size_t.max;
+        }
+    }
+
+
+    /*
+     * Returns a reference to the storage as an object of type $(D T).
+     */
+    @trusted nothrow ref T _storageAs(T)()
+            if (_typeCode!T != size_t.max)
+    {
+        return *cast(T*) _storage.ptr;
+    }
+    @trusted nothrow ref const(T) _storageAs_const(T)() const
+            if (_typeCode!T != size_t.max)
+    {
+        return *cast(const T*) _storage.ptr;
+    }
+    /+ // @@@BUG3748@@@
+    @trusted nothrow ref inout(T) storageAs(T)() inout
+    +/
+
+
+    /*
+     * Generates code for doing $(D stmt) on the active object.
+     */
+    template _onActiveObject(string stmt)
+    {
+        enum string _onActiveObject =
+                 "assert(_which != size_t.max);"
+            ~"L_chooseActive:"
+                ~"final switch (_which)"
+                ~"{"
+                    ~"foreach (Active; _Types)"
+                    ~"{"
+                    ~"case _typeCode!Active:"
+                        ~stmt
+                        ~"break L_chooseActive;"
+                    ~"}"
+                ~"}";
+    }
+
+
+    /*
+     * Error message for an attempting against any operation on an
+     * empty Algebraic object.
+     */
+    static @safe pure nothrow string _emptyMsg(string attempt)
+    {
+        return "Attempted to evaluate " ~ attempt ~ " on an empty "
+            ~ typeof(this).stringof;
+    }
+
+    /*
+     * Error message for an attempting to evaluate any operation that
+     * is not defined by any of $(D Types...).
+     */
+    static @safe pure nothrow string _invalidOpMsg(string op)
+    {
+        return "No type in " ~ typeof(this).stringof ~ " defines " ~ op;
+    }
+
+    /*
+     * Error message for an attempting to evaluate any operation that
+     * is not defined by the active object.
+     */
+    @safe nothrow string _undefinedOpMsg(string op) const
+    in
+    {
+        assert(_which != size_t.max);
+    }
+    body
+    {
+        string typeName;
+
+        mixin (_onActiveObject!(
+            q{
+                typeName = Active.stringof;
+            }));
+        return "An active object of type " ~ typeName ~ " does not "
+            ~ "define " ~ op;
+    }
+
+
+    /*
+     * Store $(D rhs) in the internal storage.
+     */
+    @system void _grab(T)(ref T rhs)
+    in
+    {
+        assert(_which == size_t.max);
+    }
+    out
+    {
+        assert(_which != size_t.max);
+    }
+    body
+    {
+        static if (_typeCode!T != size_t.max)
+        {
+            // Simple blit.
+            initialize(_storageAs!T);
+            swap(_storageAs!T, rhs);
+            _which = _typeCode!T;
+        }
+        else
+        {
+            // Use opAssign matched first.
+            foreach (Active; _Types)
+            {
+                static if (__traits(compiles, _storageAs!Active() = rhs))
+                {
+                    initialize(_storageAs!Active);
+                    _storageAs!Active() = rhs;  // may be @system
+                    _which = _typeCode!Active;
+                    break;
+                }
+            }
+        }
+    }
+
+
+    /*
+     * Assigns $(D rhs) to the non-empty active storage.
+     */
+    @system void _assign(T)(ref T rhs)
+    in
+    {
+        assert(_which != size_t.max);
+    }
+    body
+    {
+        mixin (_onActiveObject!(
+            q{
+                static if (__traits(compiles, _storageAs!Active() = rhs))
+                    return _storageAs!Active() = rhs;   // may be @system
+            }));
+
+        // Or, replace the content with rhs.
+        _dispose();
+        _grab(rhs);
+    }
+
+
+    /*
+     * Destroys the active object (if it's a struct) and marks this
+     * $(D Algebraic) object empty.
+     */
+    @trusted void _dispose()
+    in
+    {
+        assert(_which != size_t.max);
+    }
+    out
+    {
+        assert(_which == size_t.max);
+    }
+    body
+    {
+        mixin (_onActiveObject!(
+            q{
+                static if (__traits(compiles, _storageAs!Active.__dtor()))
+                    _storageAs!Active.__dtor();
+                _which = size_t.max;
+                return;
+            }));
+        assert(0);
+    }
+
+
+    //------------------------------------------------------------------------//
+private:
+    void*[(maxSize!_Types + (void*).sizeof - 1) / (void*).sizeof]
+            _storage;
+    size_t  _which = size_t.max;    // typeCode of the active object
+}
+
+
+version (unittest) private
+{
+    bool eq(S)(S a, S b)
+    {
+        foreach (i, _; a.tupleof)
+        {
+            if (a.tupleof[i] != b.tupleof[i])
+                return false;
+        }
+        return true;
+    }
+
+    bool fails(lazy void expr)
+    {
+        try { expr; } catch (VariantException e) { return true; }
+        return false;
+    }
+}
+
+//-------------- doc examples
+
+unittest
+{
+    // doc example 0
+    Algebraic!(int, double) x;
+
+    // these lines won't compile since long and string are not allowed
+//  auto n = x.Algebraic.instance!long;
+//  x = "abc";
+    assert(!__traits(compiles, x.Algebraic.instance!long));
+    assert(!__traits(compiles, x = "abc"));
+}
+
+unittest
+{
+    // doc example 1
+    Algebraic!(int, double, string) v = 5;
+    assert(v.Algebraic.isActive!int);
+
+    v = 3.14;
+    assert(v.Algebraic.isActive!double);
+
+    v *= 2;
+    assert(v > 6);
+}
+
+unittest
+{
+    // doc example 2
+    Algebraic!(string, wstring, dstring) s;
+
+    s = "The quick brown fox jumps over the lazy dog.";
+    assert(s.front == 'T');
+    assert(s.back == '.');
+    assert(s.length == 44);
+    s.popBack;
+    assert(equal(take(retro(s), 3), "god"));
+}
+
+unittest
+{
+    // doc exmaple 3
+    Algebraic!(int, double, string) x = 42;
+
+    x.Algebraic.dispatch(
+            (ref int n)
+            {
+                //writeln("saw an int: ", n);
+                assert(n == 42);
+                ++n;
+            },
+            (string s)
+            {
+                //writeln("saw a string: ", s);
+                assert(0);
+            }
+        );
+    assert(x == 43);    // incremented
+}
+
+unittest
+{
+    // doc example 4
+    Algebraic!(int, int, real, int) x;
+    assert(is( x.Algebraic.Types == TypeTuple!(int, real) ));
+}
+
+unittest
+{
+    // doc example 5 - take a pointer to the active object
+    struct A {}
+    struct B {}
+    Algebraic!(A, B) ab;
+    /+
+    Algebraic!(A, B) ab = A();
+
+    assert(ab.Algebraic.isActive!A);
+    A* p = &(ab.Algebraic.instance!A());
+//  B* q = &(ab.Algebraic.instance!B());    // throws VariantException
+    B* q;
+    assert(fails( q = &(ab.Algebraic.instance!B()) ));
+    +/
+}
+
+//--------------
+
+unittest
+{
+    // funny types
+    assert(!__traits(compiles, Algebraic!()));
+    assert(!__traits(compiles, Algebraic!(void)));
+    assert(!__traits(compiles, Algebraic!(int, void, dchar)));
+    assert(!__traits(compiles, Algebraic!(int, 42, short)));
+    assert(is( Algebraic!(int, real, int) == Algebraic!(int, real) ));
+}
+
+unittest
+{
+    // copy constructor & destructor
+    struct Counter
+    {
+        int* copies;
+        this(this) { copies && ++*copies; }
+        ~this()    { copies && --*copies; }
+    }
+    Algebraic!(Counter) a;
+    a = Counter(new int);
+    assert(*a.copies == 0);
+    {
+        auto b = a;
+        assert(*a.copies == 1);
+        {
+            auto c = a;
+            assert(*a.copies == 2);
+        }
+        assert(*a.copies == 1);
+    }
+    assert(*a.copies == 0);
+}
+
+unittest
+{
+    // basic use
+    int afoo, bfoo;
+    struct A {
+        int inc() { return ++afoo; }
+        int dec() { return --afoo; }
+    }
+    struct B {
+        int inc() { return --bfoo; }
+        int dec() { return ++bfoo; }
+    }
+    Algebraic!(A, B) ab;
+    ab = A();
+    assert(ab.inc() == 1 && afoo == 1);
+    assert(ab.dec() == 0 && afoo == 0);
+    ab = B();
+    assert(ab.inc() == -1 && bfoo == -1);
+    assert(ab.dec() ==  0 && bfoo ==  0);
+}
+
+unittest
+{
+    // constructor
+    auto x = Algebraic!(int, real)(4.5);
+    assert(x == 4.5);
+}
+
+unittest
+{
+    // meta interface
+    Algebraic!(int, real) a;
+
+    assert(is(a.Algebraic.Types == TypeTuple!(int, real)));
+    assert(a.Algebraic.allowed!int);
+    assert(a.Algebraic.allowed!real);
+    assert(!a.Algebraic.allowed!string);
+
+    assert(a.Algebraic.canAssign!int);
+    assert(a.Algebraic.canAssign!real);
+    assert(a.Algebraic.canAssign!byte);
+    assert(a.Algebraic.canAssign!short);
+    assert(a.Algebraic.canAssign!ushort);
+    assert(a.Algebraic.canAssign!double);
+    assert(a.Algebraic.canAssign!(const int));
+    assert(a.Algebraic.canAssign!(immutable int));
+    assert(!a.Algebraic.canAssign!string);
+    assert(!a.Algebraic.canAssign!void);
+    assert(!a.Algebraic.canAssign!(int*));
+    assert(!a.Algebraic.canAssign!(int[]));
+
+    assert(!__traits(compiles, a.Algebraic.get!(int[])));
+    assert(!__traits(compiles, a.Algebraic.coerce!(int[])));
+    assert(!__traits(compiles, a.Algebraic.instance!(int[])));
+
+    assert(a.Algebraic.empty);
+
+    a = 42;
+    assert(!a.Algebraic.empty);
+    assert( a.Algebraic.isActive!int);
+    assert(!a.Algebraic.isActive!real);
+    assert(!a.Algebraic.isActive!string);
+    assert(fails( a.Algebraic.instance!real ));
+    int* i = &(a.Algebraic.instance!int());
+    assert(*i == 42);
+    assert(a.Algebraic.convertsTo!(long));
+    assert(a.Algebraic.convertsTo!(const uint));
+    assert(a.Algebraic.get!real == 42);
+    assert(a.Algebraic.coerce!string == "42");
+
+    a = -21.0L;
+    assert(!a.Algebraic.empty);
+    assert(!a.Algebraic.isActive!int);
+    assert( a.Algebraic.isActive!real);
+    assert(!a.Algebraic.isActive!string);
+    assert(fails( a.Algebraic.instance!int ));
+    real* r = &(a.Algebraic.instance!real());
+    assert(*r == -21.0L);
+    assert(a.Algebraic.get!(const real) == -21.0L);
+    assert(a.Algebraic.coerce!string == "-21");
+    assert(fails( a.Algebraic.get!int ));
+
+    a = 100;
+    assert(a.Algebraic.dispatch(
+            (int a) { assert(a == 100); },
+            (ref real b) { assert(0); },
+            (ref int a) { assert(a == 100); ++a; }
+        ));
+    assert(a == 101);
+
+    a = a.init;
+    assert(a.Algebraic.empty);
+    assert(fails( a.Algebraic.instance!int ));
+    assert(fails( a.Algebraic.instance!real ));
+    assert(fails( a.Algebraic.get!real ));
+    assert(fails( a.Algebraic.coerce!string ));
+}
+
+unittest
+{
+    // implicit convertion
+    Algebraic!(real, const(char)[]) a;
+
+    a = 42;
+    assert(a.Algebraic.isActive!real);
+    a = "abc";
+    assert(a.Algebraic.isActive!(const(char)[]));
+}
+
+unittest
+{
+    // foreach over input range
+    Algebraic!(string, wstring) str;
+
+    assert(isInputRange!(typeof(str)));
+    assert(isForwardRange!(typeof(str)));
+    assert(isBidirectionalRange!(typeof(str)));
+//  assert(isRandomAccessRange!(typeof(str)));  // @@@ forward reference
+//  assert(hasLength!(typeof(str)));            // @@@ forward reference
+
+    str = cast(string) "a";
+    assert(str.length == 1);
+    assert(str.front == 'a');
+    str.popFront;
+    assert(str.empty);
+
+    str = cast(wstring) "bc";
+    assert(str.length == 2);
+    str.popFront;
+    assert(str.front == 'c');
+    assert(!str.empty);
+
+    size_t i;
+    str = "\u3067\u3043\u30fc";
+    foreach (e; str)
+        assert(e == "\u3067\u3043\u30fc"d[i++]);
+    foreach_reverse (e; str)
+        assert(e == "\u3067\u3043\u30fc"d[--i]);
+}
+
+//-------------- operator overloads
+
+unittest
+{
+    // opDispatch
+    struct Tag { string op; int n; }
+    struct OpEcho {
+        Tag opDispatch(string op)(int n) {
+            return Tag(op, n);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    auto r = obj.foo(42);
+    assert(eq( r, Tag("foo", 42) ));
+}
+
+unittest
+{
+    // opDispatch (common type)
+    struct K {
+        @property  int value() { return 441; }
+    }
+    struct L {
+        @property real value() { return 4.5; }
+    }
+    Algebraic!(K, L) obj;
+
+    obj = K(); assert(obj.value == 441);
+    obj = L(); assert(obj.value == 4.5);
+
+    assert(!__traits(compiles, &(obj.value()) ));
+//  assert(is( typeof(obj.value()) == real ));  // @@@ forward reference
+    auto r = obj.value;
+    assert(is( typeof(r) == real ));
+}
+
+unittest
+{
+    // opDispatch (ref argument & ref return)
+    struct K {
+        ref int foo(ref int a, ref int b) { ++b; return a; }
+    }
+    struct L {
+        ref int foo(   long a, ref int b) {      return b; }
+    }
+    Algebraic!(K, L) q;
+    int v, w;
+
+    q = K();
+    assert(&(q.foo(v, w)) == &v);
+    assert(w == 1);
+
+    q = L();
+    assert(&(q.foo(v, w)) == &w);
+}
+
+unittest
+{
+    // opDispatch (empty / undefined)
+    Algebraic!(int, real) obj;
+
+    assert(fails( obj.max ));
+    obj = 42;
+    assert(fails( obj.nan ));
+}
+
+unittest
+{
+    // opAssign
+    struct Tag { string op; int n; }
+    struct OpEcho {
+        int n;
+        void opAssign(int n) {
+            this.n = n;
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    obj = 42;
+    assert(obj.n == 42);
+}
+
+unittest
+{
+    // opAssign (intersection)
+    Algebraic!(   int, real) a;
+    Algebraic!(string, real) b;
+
+    a = 4;
+    assert(a.Algebraic.isActive!int);
+    b = a;
+    assert(b.Algebraic.isActive!real);
+    a = b;
+    assert(a.Algebraic.isActive!real);
+    b = "0";
+    assert(b.Algebraic.isActive!string);
+
+    // incompatible: string
+    assert(fails( a = b ));
+}
+
+unittest
+{
+    // opUnary
+    struct Tag { string op; }
+    struct OpEcho {
+        Tag opUnary(string op)() {
+            return Tag(op);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (op; TypeTuple!("+", "-", "~", "*", "++", "--"))
+    {
+        auto r = mixin(op ~ "obj");
+        assert(r.Algebraic.isActive!Tag);
+        assert(eq( r.Algebraic.instance!Tag, Tag(op) ));
+    }
+}
+
+unittest
+{
+    // opUnary (empty, undefined)
+    Algebraic!(int, string) p;
+
+    assert(fails( ~p ));
+    p = "D";
+    assert(fails( +p ));
+}
+
+unittest
+{
+    // opIndexUnary
+    struct Tag { string op; int x; real y; }
+    struct OpEcho {
+        Tag opIndexUnary(string op)(int x, real y) {
+            return Tag(op, x, y);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (op; TypeTuple!("+", "-", "~", "*", "++", "--"))
+    {
+        auto r = mixin(op ~ "obj[4, 2.5]");
+        assert(r.Algebraic.isActive!Tag);
+        assert(eq( r.Algebraic.instance!Tag, Tag(op, 4, 2.5) ));
+    }
+}
+
+unittest
+{
+    // opIndexUnary (empty, undefined)
+    Algebraic!(int[], int) obj;
+
+    assert(fails( ++obj[0] ));
+    obj = 42;
+    assert(fails( --obj[4] ));
+}
+
+unittest
+{
+    // opSliceUnary
+    struct Tag { string op; int x; real y; }
+    struct OpEcho {
+        Tag opSliceUnary(string op, int k = 2)(int x, real y) {
+            return Tag(op, x, y);
+        }
+        Tag opSliceUnary(string op, int k = 0)() {
+            return Tag(op, -1, -1);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (op; TypeTuple!("+", "-", "~", "*", "++", "--"))
+    {
+        auto r = mixin(op ~ "obj[4 .. 5.5]");
+        assert(r.Algebraic.isActive!Tag);
+        assert(eq( r.Algebraic.instance!Tag, Tag(op, 4, 5.5) ));
+
+        auto s = mixin(op ~ "obj[]");
+        assert(r.Algebraic.isActive!Tag);
+        assert(eq( s.Algebraic.instance!Tag, Tag(op, -1, -1) ));
+    }
+}
+
+unittest
+{
+    // opSliceUnary (empty, undefined)
+    Algebraic!(int[], int) obj;
+
+    assert(fails( ++obj[0 .. 1] ));
+    assert(fails( --obj[] ));
+    obj = 42;
+    assert(fails( ++obj[0 .. 1] ));
+    assert(fails( --obj[] ));
+}
+
+unittest
+{
+    // opCast
+    struct OpEcho {
+        T opCast(T)() { return T.init; }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (T; TypeTuple!(int, string, OpEcho, Object, real))
+    {
+        T r = cast(T) obj;
+    }
+}
+
+unittest
+{
+    // opCast (empty, undefined)
+    Algebraic!(int, string) obj;
+
+    assert(fails( cast(int) obj ));
+    assert(fails( cast(string) obj ));
+    obj = 42;
+    assert(fails( cast(string) obj ));
+    obj = "abc";
+    assert(fails( cast(int) obj ));
+}
+
+unittest
+{
+    // opBinary, opBinaryRight
+    struct LTag { string op; int v; }
+    struct RTag { string op; int v; }
+    struct OpEcho {
+        LTag opBinary(string op)(int v) {
+            return LTag(op, v);
+        }
+        RTag opBinaryRight(string op)(int v) {
+            return RTag(op, v);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (op; TypeTuple!("+", "-", "*", "/", "%", "^^", "&",
+                "|", "^", "<<", ">>", ">>>", "~", "in"))
+    {
+        auto r = mixin("obj " ~ op ~ " 42");
+        assert(r.Algebraic.isActive!LTag);
+        assert(eq( r.Algebraic.instance!LTag, LTag(op, 42) ));
+
+        auto s = mixin("76 " ~ op ~ " obj");
+        assert(s.Algebraic.isActive!RTag);
+        assert(eq( s.Algebraic.instance!RTag, RTag(op, 76) ));
+    }
+}
+
+unittest
+{
+    // opBinary, opBinaryRight (empty, undefined)
+    Algebraic!(int, real) obj;
+
+    assert(fails( obj + 4 ));
+    assert(fails( 4 + obj ));
+    obj = 4.5;
+    assert(fails( obj >> 4 ));
+    assert(fails( 4 >> obj ));
+}
+
+unittest
+{
+    // opEquals (forward)
+    struct Dummy {
+        bool opEquals(int v) const {
+            return v > 0;
+        }
+        bool opEquals(ref const Dummy) const { assert(0); }
+    }
+    Algebraic!(Dummy) obj;
+
+    obj = Dummy();
+    assert(obj ==  1);
+    assert(obj !=  0);
+    assert(obj != -1);
+}
+
+unittest
+{
+    // opEquals (meta)
+    struct Dummy(int k) {
+        bool opEquals(int kk)(ref const Dummy!kk rhs) const {
+            return k == kk;
+        }
+    }
+    Algebraic!(Dummy!0, Dummy!1) a, b;
+
+    a = Dummy!0();
+    b = Dummy!1();
+    assert(a == a);
+    assert(a != b);
+    assert(b == b);
+}
+
+unittest
+{
+    // opCmp (forward)
+    struct Dummy {
+        int opCmp(int v) const {
+            return 0 - v;
+        }
+        int opCmp(ref const Dummy) const { assert(0); }
+    }
+    Algebraic!(Dummy) a;
+
+    a = Dummy();
+    assert(a >= 0);
+    assert(a > -1);
+    assert(a < 1);
+}
+
+unittest
+{
+    // opCmp (meta)
+    struct Dummy(int k) {
+        int opCmp(int kk)(ref const Dummy!kk r) const {
+            return k - kk;
+        }
+    }
+    Algebraic!(Dummy!0, Dummy!1) a, b;
+
+    a = Dummy!0();
+    b = Dummy!1();
+    assert(a >= a);
+    assert(a <= b);
+    assert(a < b);
+    assert(b >= a);
+    assert(b <= b);
+    assert(b > a);
+}
+
+unittest
+{
+    // opCmp (empty, undefined)
+    Algebraic!(int, string) obj;
+
+    assert(fails( /+obj < 0+/ obj.opCmp(0) ));
+    obj = "abc";
+    assert(fails( /+obj > 0+/ obj.opCmp(1) ));
+}
+
+/+
+// @@@BUG4253@@@
+unittest
+{
+    // opCall
+    struct Tag { int x; real y; }
+    struct OpEcho {
+        Tag opCall(int x, real y) {
+            return Tag(x, y);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+//  obj = OpEcho(); // @@@BUG@@@
+    obj = OpEcho.init;
+    auto r = obj(4, 8.5);
+    assert(r.Algebraic.isActive!Tag);
+    assert(r.Algebraic.instance!Tag == Tag(4, 8.5));
+}
++/
+
+unittest
+{
+    // opIndexAssign
+    struct Tag { string v; int i; real j; }
+    struct OpEcho {
+        Tag opIndexAssign(string v, int i, real j) {
+            return Tag(v, i, j);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    auto r = (obj[1, 2.5] = "abc");
+    assert(r.Algebraic.isActive!Tag);
+    assert(eq( r.Algebraic.instance!Tag, Tag("abc", 1, 2.5) ));
+}
+
+unittest
+{
+    // opIndexAssign (empty, undefined)
+    Algebraic!(int, int[]) obj;
+
+    assert(fails( obj[0] = 4 ));
+    obj = 42;
+    assert(fails( obj[4] = 0 ));
+}
+
+unittest
+{
+    // opSliceAssign
+    struct Tag { string v; int i; real j; }
+    struct OpEcho {
+        Tag opSliceAssign(string v, int i, real j) {
+            return Tag(v, i, j);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    auto r = (obj[1 .. 2.5] = "abc");
+    assert(r.Algebraic.isActive!Tag);
+    assert(eq( r.Algebraic.instance!Tag, Tag("abc", 1, 2.5) ));
+}
+
+unittest
+{
+    // opSliceAssign (empty, undefined)
+    Algebraic!(int, int[]) obj;
+
+    assert(fails( obj[0 .. 1] = 2 ));
+    obj = 42;
+    assert(fails( obj[1 .. 2] = 3 ));
+}
+
+unittest
+{
+    // opOpAssign
+    struct Tag { string op; int v; }
+    struct OpEcho {
+        Tag opOpAssign(string op)(int v) {
+            return Tag(op, v);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (op; TypeTuple!("+", "-", "*", "/", "%", "^^", "&",
+                "|", "^", "<<", ">>", ">>>", "~"))
+    {
+        auto r = mixin("obj " ~ op ~ "= 97");
+        assert(r.Algebraic.isActive!Tag);
+        assert(eq( r.Algebraic.instance!Tag, Tag(op, 97) ));
+    }
+}
+
+unittest
+{
+    // opOpAssign (empty, undefined)
+    Algebraic!(int, string) obj;
+
+//  assert(fails( obj *= 4 ));  // exception uncaught. why?
+    obj = "abc";
+    assert(fails( obj /= 4 ));
+}
+
+unittest
+{
+    // opIndexOpAssign
+    struct Tag { string op; int v; int x; real y; }
+    struct OpEcho {
+        Tag opIndexOpAssign(string op)(int v, int x, real y) {
+            return Tag(op, v, x, y);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (op; TypeTuple!("+", "-", "*", "/", "%", "^^", "&",
+                "|", "^", "<<", ">>", ">>>", "~"))
+    {
+        auto r = mixin("obj[4, 7.5] " ~ op ~ "= 42");
+        assert(r.Algebraic.isActive!Tag);
+        assert(eq( r.Algebraic.instance!Tag, Tag(op, 42, 4, 7.5) ));
+    }
+}
+
+unittest
+{
+    // opIndexOpAssign (empty, undefined)
+    Algebraic!(int, int[]) obj;
+
+    assert(fails( obj[0] += 4 ));
+    obj = 42;
+    assert(fails( obj[1] *= 4 ));
+}
+
+unittest
+{
+    // opSliceOpAssign
+    struct Tag { string op; int v; int i; real j; }
+    struct OpEcho {
+        Tag opSliceOpAssign(string op, int k = 2)(int v, int i, real j) {
+            return Tag(op, v, i, j);
+        }
+        Tag opSliceOpAssign(string op, int k = 0)(int v) {
+            return Tag(op, v, -1, -1);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (op; TypeTuple!("+", "-", "*", "/", "%", "^^", "&",
+                "|", "^", "<<", ">>", ">>>", "~"))
+    {
+        auto r = mixin("obj[4 .. 7.5] " ~ op ~ "= 42");
+        assert(r.Algebraic.isActive!Tag);
+        assert(eq( r.Algebraic.instance!Tag, Tag(op, 42, 4, 7.5) ));
+
+        auto s = mixin("obj[] " ~ op ~ "= 42");
+        assert(s.Algebraic.isActive!Tag);
+        assert(eq( s.Algebraic.instance!Tag, Tag(op, 42, -1, -1) ));
+    }
+}
+
+unittest
+{
+    // opSliceOpAssign (empty, undefined)
+    Algebraic!(int, int[]) obj;
+
+    assert(fails( obj[0 .. 1] += 1 ));
+    assert(fails( obj[]       -= 2 ));
+    obj = 42;
+    assert(fails( obj[2 .. 3] *= 3 ));
+    assert(fails( obj[]       /= 4 ));
+}
+
+unittest
+{
+    // opIndex
+    struct Tag { int i; real j; }
+    struct OpEcho {
+        Tag opIndex(int i, real j) {
+            return Tag(i, j);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    auto r = obj[4, 9.5];
+    assert(r.Algebraic.isActive!Tag);
+    assert(eq( r.Algebraic.instance!Tag, Tag(4, 9.5) ));
+}
+
+unittest
+{
+    // opIndex (empty, undefined)
+    Algebraic!(int, int[]) obj;
+
+    assert(fails( obj[0] ));
+    obj = 42;
+    assert(fails( obj[2] ));
+}
+
+unittest
+{
+    // opSlice
+    struct Tag { int i; real j; }
+    struct OpEcho {
+        Tag opSlice(int i, real j) {
+            return Tag(i, j);
+        }
+        Tag opSlice() {
+            return Tag(-1, -1);
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    auto r = obj[4 .. 9.5];
+    assert(r.Algebraic.isActive!Tag);
+    assert(eq( r.Algebraic.instance!Tag, Tag(4, 9.5) ));
+
+    auto s = obj[];
+    assert(s.Algebraic.isActive!Tag);
+    assert(eq( s.Algebraic.instance!Tag, Tag(-1, -1) ));
+}
+
+unittest
+{
+    // opSlice (empty, undefined)
+    Algebraic!(int, int[]) obj;
+
+    assert(fails( obj[0 .. 1] ));
+    assert(fails( obj[] ));
+    obj = 42;
+    assert(fails( obj[2 .. 3] ));
+    assert(fails( obj[] ));
+}
+
+/+
+unittest
+{
+    // opApply
+    struct OpEcho {
+        int opApply(int delegate(ref size_t, ref real) dg)
+        {
+            foreach (i, ref e; [ 1.L, 2.5L, 5.5L ])
+                if (auto r = dg(i, e))
+                    return r;
+            return 0;
+        }
+    }
+    Algebraic!(OpEcho) obj;
+
+    obj = OpEcho();
+    foreach (size_t i, ref real e; obj)
+        assert(e == [ 1.L, 2.5L, 5.5L ][i]);
+}
++/
+
+//-------------- special functions
+
+unittest
+{
+    // toString
+    Algebraic!(int, string, Object) obj;
+    obj.toString();
+
+    obj = 42;
+    assert(obj.toString() == "42");
+
+    obj = "The quick brown...";
+    assert(obj.toString() == "The quick brown...");
+
+    obj = new class { string toString() { return "mew"; } };
+    assert(obj.toString() == "mew");
+
+    assert(to!string(obj) == "mew");
+}
+
+unittest
+{
+    // toHash
+    Algebraic!(string, Object) obj;
+    obj.toHash();
+
+    obj = "I'm in a box.";
+    obj.toHash();
+
+    obj = new class { hash_t toHash() { return 42; } };
+    assert(obj.toHash() == 42);
+}
+
+//-------------- misc
+
+unittest
+{
+    // class object
+    class A {
+        int foo(int a, int b) { return a + b; }
+    }
+    struct B {
+        int foo(int a, int b) { return a * b; }
+    }
+    Algebraic!(A, B) ab;
+
+    ab = new A;
+    {
+        auto c = ab;
+        assert(c.foo(2, 3) == 5);
+    }
+    assert(ab.foo(4, 5) == 9);
+
+    ab = B();
+    assert(ab.foo(6, 7) == 42);
+}
+
+unittest
+{
+    // associative array
+    Algebraic!(int[string], real[string]) map;
+
+    map = (int[string]).init;
+    map["abc"] = 42;
+    assert(("abc" in map) != null);
+    assert(map["abc"] == 42);
+    map.rehash;
+    assert(map.length == 1);
+
+    map = (real[string]).init;
+    map["xyz"] = 3.5;
+    assert(("xyz" in map) != null);
+    assert(map["xyz"] == 3.5);
+    map.rehash;
+    assert(map.length == 1);
+}
+
+/+
+// @@@BUG4449@@@ ICE
+unittest
+{
+    // recursive data type
+    alias Algebraic!(dchar, This[]) Tree;
+
+    static uint depth(ref Tree tree)
+    {
+        uint r;
+
+        // pattern match against the tree node
+        tree.Algebraic.dispatch(
+                (dchar leaf)
+                {
+                    r = 1;
+                },
+                (Tree[] subtrees)
+                {
+                    uint mx = 0;
+                    foreach (sub; subtrees)
+                        mx = max(mx, depth(sub));
+                    r = 1 + mx;
+                }
+            ) || assert(0);
+        return r;
+    }
+
+    /*
+     *  1:      <root>
+     *         /      \
+     *  2:   <ab>    <cde>
+     *       /  \    /   \
+     *  3:  a    b  c    <de>
+     *                   /  \
+     *  4:              d    e
+     */
+    Tree tree =
+        [ Tree([ Tree('a'),
+                 Tree('b') ]),
+          Tree([ Tree('c'),
+                 Tree([ Tree('d'),
+                        Tree('e') ]) ]) ];
+    assert(depth(tree) == 4);
+}
++/
+
+
+//----------------------------------------------------------------------------//
+
+/*
+ * A dummy lvalue of type T.
+ */
+private template phony(T)
+{
+    static extern T phony;
+}
+
+unittest
+{
+    real foo(ref string s) { return 0; }
+    assert(is(typeof(++phony!int) == int));
+    assert(is(typeof(foo(phony!string)) == real));
+}
+
+
+/*
+ * A tuple of dummy lvalues of types TT.
+ */
+private template phonyList(TT...)
+{
+    static if (TT.length > 0)
+        alias TypeTuple!(phony!(TT[0]), phonyList!(TT[1 .. $]))
+                            phonyList;
+    else
+        alias TypeTuple!()  phonyList;
+}
+
+unittest
+{
+    int foo(Args...)(ref Args args) { return 0; }
+    assert(is(typeof(foo(phonyList!(int, dchar))) == int));
+}
+
+
+/*
+ * Returns x by a value of type R, or nothing if R is void.
+ * Used by Algebraic.opDispatch().
+ */
+private @system R byValue(R, T)(auto ref T x)
+{
+    static if (is(R == T))
+    {
+        return x;
+    }
+    else static if (!is(R == void))
+    {
+        R r = x;
+        return r;
+    }
+}
+
+private @safe R byValue(R, T = void)()
+{
+    static if (!is(R == void))
+        return R.init;
+}
+
+unittest
+{
+    static R foo(R)()
+    {
+        return byValue!R(42);
+    }
+    assert(foo!int() == 42);
+    assert(foo!real() == 42.L);
+    assert(is(typeof(foo!void()) == void));
+
+    static R bar(R)()
+    {
+        return byValue!R;
+    }
+    assert(bar!int() == int.init);
+    assert(is(typeof(bar!void()) == void));
+}
+
+
+/*
+ * Compile fails if var is an rvalue.
+ */
+private @safe nothrow void expectLvalue(T)(ref T var);
+
+unittest
+{
+    int x;
+    assert(__traits(compiles, expectLvalue(x)));
+    assert(!__traits(compiles, expectLvalue(42)));
+}
+
+
+/*
+ * Initializes a variable $(D obj) with its default initializer without
+ * invoking copy constructor nor destructor.
+ */
+private @trusted void initialize(T)(ref T obj)
+{
+    static T init;
+    memcpy(&obj, &init, T.sizeof);
+}
+
+unittest
+{
+    struct S
+    {
+        int n;
+        this(this) { assert(0); }
+    }
+    S s;
+    s.n = 42;
+    assert(s != s.init);
+    initialize(s);
+    assert(s == s.init);
+}
+
+
+/*
+ * Workaround for the issue 4444.
+ */
+private @trusted string expandArray(string array, size_t n)
+{
+    string expr = "";
+
+    foreach (i; 0 .. n)
+    {
+        if (i > 0)
+            expr ~= ", ";
+        expr ~= array ~ "[" ~ to!string(i) ~ "]";
+    }
+    return expr;
+}
+
+unittest
+{
+    enum s = expandArray("arr", 3);
+    assert(s == "arr[0], arr[1], arr[2]");
+}
+