Sat, 26 Sep 2009 12:25:23 -0400, Jeremie Pelletier thusly wrote:
> Justin Johansson wrote:
>> language_fan Wrote:
>>
>>> Sat, 26 Sep 2009 09:32:55 -0400, Justin Johansson thusly wrote:
>>>
>>>> I've had a good poke around the forums and couldn't find anything on
>>>> this so ...
>>>>
>>>> What's the recommended method for dispatching code off the runtime
>>>> type of a variant variable (Phobos D2 std.variant)?
>>>>
>>>> Does one use a bunch of
>>>>
>>>> if ( var.peek!(type1)) { ... }
>>>> else if ( var.peek!(type2) { ... }
>>>>
>>>> for all N possible types, or is there a better & faster way with a
>>>> switch or jump table of sorts?
>>> If the type count gets large, how fast it is depends on the backend
>>> optimizations of the compiler. In the worst case it is a O(n) time
>>> linear search. A jump table or almost any other way of dispatching
>>> would be faster. If the variant had an integral tag field, it could be
>>> used in a switch; that way the compiler could easily optimize it
>>> further with the currently available constructs.
>>>
>>> This problem is solved in higher level languages by providing pattern
>>> matching constructs. The compiler is free to optimize the code the way
>>> it likes:
>>>
>>> case var of
>>> type1 => ...
>>> type2 => ...
>>> ...
>>>
>>> But since no C-like language has ever implemented pattern matching, it
>>> might be too radical to add it to D.
>>
>> Thanks both for replies.
>>
>> I've got about 2 dozen types in the variant so the O(n) really hurts.
>> The variant thing seemed like a really cool idea at the time but now
>> ... Without something like suggested above or a computed goto on typeid
>> or Andrei's visitator, it almost pushes me to backout from using
>> variants and having to redesign around some common base class or
>> interface and using virtual function dispatch. :-(
>>
>>
> I see this sort of design in C all the time with event handling,
> although its with unions rather than discriminated unions, the same
> logic applies.
>
> enum EventType {
> Mouse,
> Key,
> Move,
> ...
> }
> struct Event {
> EventType type;
> union {
> MouseEvent mouse;
> KeyEvent key;
> MoveEvent move;
> ...
> }
> }
>
> void dispatchEvent(const(Event)* event) {
> ...
> with(EventType) final switch(event.type) { case Mouse: ...
> case Key: ...
> case Move: ...
> ...
> }
> ...
> }
>
> That's the logic with standard unions, you should be able to get
> something similar with variants. It's more code to setup, but you end up
> with a simple jump table from the switch, and final in D makes it easy
> to change EventType without forgetting to update dispatchEvent.
Exactly, this is what I mentioned previously. Isn't it ugly compared to
type Event = Mouse | Key | Move;
void dispatchEvent(Event event) {
match(event) {
Mouse m => m.squeek();
Key k => ...
...
}
}
What's with all the language proposals here? Why hasn't anyone proposed
this before? This is in fact very helpful - that's why several modern
languages have adopted it.
