Re: lazyness

Philippa Cowderoy <flippa@[EMAIL PROTECTED]
> wrote:
[...]
> Yep. The lazy version with the same optimisation (tail call modulo a 
> slightly odd cons) will, given an arbitrary-size integer type, merely
take 
> longer than the likely life of the universe to blow the heap.
[...]

Looks like handwaving [1] to me :-).  I see no reason for why either
(Haskell)

  let omega = omega + 1 in omega

or (SML)

  let fun omega () = omega () + 1 in omega () end

would be easier to transform to tail-recursive form (neither is in
tail-recursive form) reassociating the arithmetic.  It seems to me that
both the lazy and strict versions have essentially the same
meaning(lessness).  If someone knows a paper that describes an analysis
that allows either version to be transformed to tail-recursive form, it
might be interesting to hear about it.

Anyway, I think that the insight that one should get from this is that in
a strict language, it is the construction of values that can trigger
divergence, while in a lazy language, it is the deconstruction of covalues
that can trigger divergence.  The type of the lazy omega in Haskell is [*]

  Integer

while the type of the strict omega in SML is

  unit -> int .

-Vesa Karvonen

[1] http://en.wikipedia.org/wiki/Handwaving
[2] Simplified for clarity, the type is actually Num a => a