Hi all,
I like the title:
The story behind monads
The quest for modular semanticsmonads achieve semantic modularity
(a uniform computation model for adding sematic aspects)
in fact, this is more about
monad transformers
Monad Transformers and Modular Interpreterscatamorphisms (also metioned in the discussion on concurrency)
achieve syntactic modularity
(by separating recursion from summing)
together, monad transformers and catamorphisms achieve 'true' modularity
[ cfr. slides: for writing interpreter modules (for sum, product, ...) in
different files ]
I have once (1995)) implemented all of this in Haskell and written a technical report on this
(it is never published (but nevertheless it is cited from time to time (as a draft))).
What I wanted to say is the following:
In Scala it is also possible to work with catamorphisms
and, probably also to work with monad transformers
(and combine everything to obtain 'true' modularity).
for the catamorphism part you can use something similar to:
trait Structures {
type Struct[+A] <: Structure[A]
trait Structure[+A] { self: Struct[A] =>
def struct[B](a2b: A => B): Struct[B]
}
trait Rec {
def open: Struct[Rec]
def fold[A](algebra: Struct[A] => A): A = algebra(open struct (_.fold(algebra)))
}
}the real question is, probably,
if Scala's type system can cope with all of this in an elegant way
by the way:
modularity can, at the syntactic level,
also be modeled nicely using attribute grammars,
so any nice implementation of
attribute grammars[ maybe as a DSL] combined with monads is also a way to go
(maybe even a better one)
Luc
Luc
--
__~O
-\ <,
(*)/ (*)
reality goes far beyond imagination
