Jarrett Billingsley wrote:
On Sat, Sep 26, 2009 at 4:18 PM, Jeremie Pelletier <jerem...@gmail.com> wrote:
type Event = Mouse | Key | Move;
This can be confusing, for example the first thing that comes to mind for me
is that Event is the bitwise OR result of 3 constants, not an enumerated
type.
Besides, how is it any different than:
enum { Mouse, Key, Move };
It's not an enumerated constant. Mouse, Key, and Move are all types,
and Event is a discriminated union of the three. See more below.
match(event) is no different than switch(event), except that pattern
matching often implies runtime semantics and is often slower than a straight
jump table generated from a switch.
Not in this case. See, when you would do "type Event = Mouse | Key |
Move", it's actually more like doing:
struct Event
{
enum Type { Mouse, Key, Move }
Type type;
union
{
Mouse m;
Key k;
Move v;
}
}
Then, when you do "match(e) { Mouse m => ... }" it's actually being turned into:
switch(e.type)
{
case Event.Type.Mouse: alias e.m m; ...
case Event.Type.Key: alias e.k k; ...
}
Basically discriminated unions get rid of this annoying boilerplate
that you have to use every time you want a tagged union.
Oh, that makes sense, but I don't see why you need language support for
that, a variant type should be able to get most of it using type tuples,
maybe just add support to switch on type tuples along with an opSwitch()
method:
alias Algebraic!(Mouse, Key, Move) Event;
final switch(Event) {
case Mouse:
case Key:
case Move:
}
Jeremie
