Re: Special Type Challenge

[via Digitalmars-d]

On Sunday, 8 February 2015 at 19:59:40 UTC, Meta wrote:
On Sunday, 8 February 2015 at 13:06:08 UTC, Marc Schütz wrote:
No, `alias this` convert from the type it is declared in to 
another type. `opImplicitCast` would be declared in the 
destination type.

So like this?

struct Type1
{
    string str;
}

struct Type2
{
    string str;

    Type2 opImplicitCast(Type1 t)
    {
        return Type2(t.str);
    }
}

void main()
{
    Type2 t2 = Type1("Hello, World!");
}

Instead of the opposite?

Yes. It's almost like a constructor, but would be called wherever 
an explicit call to the constructor is required today:

    struct S {
        this(int x) {}
    }

    S test1() {
        return 10;    // not ok
        return S(10); // works
    }

    struct T {
        static typeof(this) opImplicitCast(int x) {
            return typeof(this)(x);
        }
    }

    T test1() {
        return 10;    // ok
        return T(10); // not sure whether this should
                      // work or not
    }

Because it's so similar to a constructor (it always needs to be 
static and return `typeof(this)`), maybe a special syntax can be 
used:

    struct S {
        @implicit this(int x) {}
    }