Why is there a space leak here? (fwd)

[Malcolm Wallace]

Hi Claus,

I've had a look at this example in GHood, and you are right, nhc98
does seem to create several copies of v-in.

> import Observe
> 
> foo1 m
>    = take m (observe "v-out" v)
>      where
>        v = 1 : concat (map triple (observe "v-in" v))
>        triple x = [x,x,x]
> 
> main = printO $ (foo1 100::[Int])

> Perhaps Malcolm can explain what nhc98 does with this example?

At a guess, I think the answer lies in lambda-lifting.

   nhc98 -c Leak.hs +CTS -lift -CTS

shows this code for `v' (reformatted a little to make it easier to read):

  Main.Prelude.173.v = \ v223 v224 ->
    Prelude.:
      (Prelude._apply1  (Prelude.fromInteger v223)  1L)
      (Prelude._apply1
        (Prelude.concat)
        (Prelude.map (Main.Prelude.174.triple)
                     (Observe.observe (Observe.Observable.Prelude.[]  v224)
                                      (LAMBDA225)
                                      (Prelude._apply2
                                          (Main.Prelude.173.v) v223  v224))))

v takes two arguments; v223 represents the numeric dictionary, and
v224 the Observer dictionary.  The recursive reference to v is not
a cyclic pointer to a constant structure, but actually a function call.

I believe the real culprit is that nhc98 does not implement the
monomorphism restriction.  IIRC, the DMR applies to every group
of simple pattern bindings at the same let-bound scope, not just
the top-level, so really we ought to default-away the dictionaries,
which would solve this particular space oddity.

Regards,
    Malcolm