[Haskell-cafe] Re[2]: strict Haskell dialect

[Brian Hulley]

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.