Robin Green wrote:
In object-oriented languages you can achieve the same effect by
defining a method on each type which has different behaviour depending
on the type.
In Haskell you can achieve much the same effect by defining methods in
typeclasses and then defining instances for types. It's quite
analogous. This is the recommended way of doing it in Haskell.
I thought about that. But consider the following scenario. We have a
Dispatcher and a Handler. The Dispatcher sends messages to Handlers.
There are two ways we could implement this in an OOP language
(0) Have each type of message be a method on a Handler type class. The
problem here is that to dispatch new message types we would have to
recompile the Dispatcher.
(1) Have Handlers implement a method handle(m: Msg). To add new types of
message, we declare message types which extend Msg. The Handler then
uses runtime type testing to decide how to deal with each message. The
advantage of this design is that we can add new Handler and new Msg
types without recompiling the Dispatcher.
Type classes allow us to adopt approach (0) in Haskell, but don't seem
to allow approach (1)....
E.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
