Re: Unit unboxed tuples

On Wed, Jan 11, 2012 at 8:41 AM, Simon Marlow wrote:

On 10/01/2012 16:18, Dan Doel wrote:

...

Copying the list, sorry. I have a lot of trouble replying correctly with gmail's interface for some reason. :)

On Tue, Jan 10, 2012 at 11:14 AM, Dan Doel  wrote:

...

On Tue, Jan 10, 2012 at 5:01 AM, Simon Marlow  wrote:

...

On 09/01/2012 04:46, wren ng thornton wrote:

...

Shouldn't (# T #) be identical to T?

No, because (# T #) is unlifted, whereas T is lifted.  In operational terms, a function that returns (# T #) does not evaluate the T before returning it, but a function returning T does.  This is used in GHC for example to fetch a value from an array without evaluating it, for example:

 indexArray :: Array# e ->  Int# ->  (# e #)

I don't really understand this explanation. (# T #) being unlifted would mean it's isomorphic to T under the correspondence e<->  (# e #). _|_ = (# _|_ #) : (# T #), so this works.

Does the difference have to do with unboxed types? For instance:

   foo :: () ->  Int#    foo _ = foo ()    bar :: () ->  (# Int# #)    bar _ = (# foo () #)

   baz = case bar () of _ ->  5  -- 5    quux = case foo () of _ ->  5 -- non-termination

Because in that case, either (# Int# #) is lifted, or the Int# is effectively lifted when inside the unboxed tuple. The latter is a bit of an oddity.

Unboxed types cannot be lifted, so in fact bar compiles to this:

 bar = \_ -> case foo () of x -> (# x #)

and both baz and quux diverge.

It might help to understand (# T #) by translating it to (# T, () #). There's really no difference.

Then I'm afraid I still don't understand the difference. Is it that case in core always evaluates? So: case undefined of x -> ... blows up, while case (# undefined #) of (# x #) -> ... does not? Also, if so, how is (core-wise): foo :: ... -> (# T #) case foo <v> of (# x #) -> ... different from: foo :: ... -> T let x = foo <v> in ... Stack vs. heap allocation? Sorry for being rather thick. -- Dan