On 8/1/14, 7:18 AM, Timon Gehr wrote:
It might also be possible that this is what is actually wanted:
alias Foo = Algebraic!(int,Algebraic!(This[],double)[]);
(I.e. This refers to the inner type.)
There is always this issue as well:
alias ListInt=Algebraic!(Tuple!(),Tuple!(int,ListInt*));
How would you use the proposed enhancement to fix this?
I don't think there's an easy way.
(BTW: Algebraic implements a plain sum type, so I again think the name
is a little strange :o).)
Yah, there'd probably be a more precise name for it.
There is also this kind of approach:
mixin ADT!q{
List(T):
| Nil
| Cons T List!T
};
Interesting! Is there code available for that?
...
You can find an incomplete proof-of-concept implementation here:
http://dpaste.dzfl.pl/77abae58a087
(The 'match' is not particularly great, opEquals is missing, etc.)
It was quite hard to get past the compiler.
On a cursory inspection, looks good! The question there is whether you
or anyone would be interested in taking that to a proposal.
Well one other way to look at it is that striving to do things in a
library pushes introspection forward.
...
Based on past experiences, I think we'd see some opposition if the
language was to be extended in a way to allow those kinds of features to
be implemented completely in the library such that they behave and look
optimally.
In any case, having a template Fix operator would sometimes be convenient:
struct Foo1(T){
T* self;
}
alias Foo=Fix!Foo1;
/+
instantiates to something like:
struct Foo{
Foo* self;
}
+/
:o)
the most natural implementation of Fix does not work for obvious reasons:
alias Fix(alias F)=F!(Fix!F);
Making this work is not completely out of reach though, I think.
The best I can currently do to "save" 'Algebraic' is the following:
http://dpaste.dzfl.pl/65afd3a7ce52
That's interesting. Fix is worth making to work either as a built-in on
a library artifact.
Andrei
