OK, just to let everybody know why I'm dropping Haskell. Basically, the reasoning is this: * I want to write a process that doesn't terminate. * Since the environment can and will enforce termination occasionally, the process must be able to write its state to some external storage ("serialize it"; flat file or database doesn't make much of a difference). In fact I'll want to serialize most of the program's state on a regular basis (say, once per day), just to safeguard against bugs and hardware crashes. * In all Haskell implementations (with the exception of Yhc), there is no way to write out data without forcing unevaluated expressions inside. (Yhc isn't mature yet, so it's not an option currently.) * Forcing the expressions that get written out means that I cannot use lazy evaluation freely. In particular, if some library code returns a data structure that contains a lazy-infinite subexpression, serializing it would not terminate, and I'd have little chance of fixing that. Now that the first serialization will destroy many of the advantages of laziness, I don't think I should try to wrestle with its disadvantages. I'll move on to the alternatives - Alice ML and/or Clean. Both can serialize without forcing lazy subexpressions. This all said, I still don't think that Haskell or its execution environments are bad. They just don't fit my requirements, which are A) I want to get my feet wet with an FPL (seriously, this time), and B) I want to do a webserver application (I know the domain). Regards, Jo