>> You wouldn't be able to do this for arbitrary code.
>
> And that's what I'm talking about. If you want your program to run 15
> years without ever stopping, you pretty much need to be able to replace
> arbitrary bits of code, including type signatures, while you're running.

And if this was a problem for your application, you would write it in 
such a way as to facilitate doing this.

Yes, it would be cooler if you could do it for /arbitrary/ code, but 
with extant implementations, you'd have to do the next best thing.

(And, again, if somebody wanted this, you could probably come up with a 
Haskell implementation that supports it natively. It's just that nobody 
has. It would take some design work, but I think you could do it without 
changing the language itself.)

>> But if you insert a
>> suitable layer of indirection, it wouldn't be too hard. Haskell supports
>> first-class functions, after all. You can do crazy things with stuff like
>> continuation-passing and so on.
>
> Sure, and Erlang translates into machine code instructions at some
> point. Or hell, implement an Erlang interpreter in Haskell. This isn't
> an argument. :-)

Implementing an Erlang interpreter in BBC BASIC would be hellishly 
difficult. Doing it in Haskell wouldn't be all that hard. That's the 
difference.

Post a reply to this message