Re: typedef, Typedef

[bearophile]

A late reply.

Andrei Alexandrescu:

Typedef!T is meant as a type with the same behavior as T, but 
otherwise unrelated to it.<

Right.


Allowing uncontrolled conversions to and fro is only making 
typedef weaker.<

Right, on the other hand if this type separation is handled too 
much strictly, the code become less handy. So probably some 
intermediate point is better, some conversions in controlled 
situations.


We could add a flag such that Typedef!(T, supertype) that allows 
T as a supertype, i.e. add an alias this.<

That in this program allows the assignments of x1 to x2 and of x2 
to x1; but what is this useful for? I think this was discussed a 
bit in past:


//-----------
import std.typecons: Proxy;

template Typedef(T) {
    alias .Typedef!(T, T.init) Typedef;
}

struct Typedef(T, T init, string cookie=null) {
    private T Typedef_payload = init;

    this(T init) {
        Typedef_payload = init;
    }

    mixin Proxy!Typedef_payload;
    alias Typedef_payload this; // added
}

void main() {
    alias T = Typedef!int;
    T x1;
    int x2;
    x1 = x2;
    x2 = x1;
}
//-----------


There is no possibility to add implicit construction of 
Typedef!T from T (and that's arguably a good thing).<

This is not very handy:

void main() {
    import std.typecons: Typedef;
    alias T = Typedef!int;
    T[] a1 = [1, 2, 3];      // Error
    T[T] aa = [1:2, 3:4];    // Error
    import std.bigint: BigInt;
    BigInt[] a3 = [1, 2, 3]; // Error
}



Some workarounds:

void main() {
    import std.typecons: Typedef;
    import std.bigint: BigInt;
    import std.conv: to;
    alias T = Typedef!int;
    T[] a1 = [1, 2, 3].to!(T[]);           // OK
    BigInt[] a2 = [1, 2, 3].to!(BigInt[]); // OK
    auto aa1 = [1:2, 3:4].to!(T[BigInt]);  // OK
    auto aa2 = [1:2, 3:4].to!(BigInt[T]);  // OK
}


But it doesn't always work:

import std.typecons: Typedef;
import std.conv: to;
alias T = Typedef!ubyte;
void main() {
    T[] a1 = [100.T, 200.T]; // OK
    T[] a2 = [100, 200].to!(T[]); // Error
}


Bye,
bearophile