Brian Hulley wrote:
Brian Hulley wrote:
Robin Green wrote:
<snip>
So simply make strictness the default and have laziness annotations
(for arguments), instead of making laziness the default and having
strictness annotations.
Where would you put these laziness annotations?
If you put them in the function declaration eg as in:
if' :: Bool -> ~a -> ~a -> a [corrected]
presumably you'd want the compiler to pass the args as thunks instead
of evaluated values. However this means that all args to every
function would have to be passed as thunks, even though for strict
functions these thunks would immediately be evaluated. The problem is
that there is no way for the compiler to optimize out the thunk
creation / evaluation step because it occurs across the "black box"
of a function call, thus we wouldn't get the same efficiency as in a
language such as ML where no thunks are created in the first place.
I'm just soooo slow!!! ;-) Of course the laziness info would now be
part of the function's type so the compiler would be able to generate
the correct code to prepare thunks or evaluated values before calling
the function. So your idea of laziness annotations for args would
give the best of both worlds :-)
For an eager language, a state monad could perhaps be defined by
data ST m a = ST ~(m -> (m,a))
and the other operations would work as normal without any additional
annotations. (?)
I must admit I'm a bit confused as to why the strictness annotations in
Haskell (and Clean) are only allowed in data declarations and not function
declarations, since it seems a bit random to have to guess which args can be
evaluated strictly at the call site although it of course gives flexibility
(eg to use (+) strictly or lazily). The type system doesn't prevent someone
from writing (>>) m0 $! m1 even though the author of (>>) may have been
relying on m1 being lazily evaluated... (?)
For an eager language, it would seem that lazy annotations would have to be
allowed as part of a function's type so that if' could be implemented. Does
anyone know of a type system that incorporates lazy annotations, and/or how
these would be propagated?
What would the signature of a lazy map function be?
map :: (~a -> ~b) -> ~[a] -> ~[b]
map :: (a -> b) -> ~[~a~] -> ~[b~]
etc etc - quite a puzzle!!!
Thanks, Brian.
_______________________________________________
Haskell-Cafe mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-cafe