[Yhc] single element tuple

[Tom Shackell]

 > Hi,
 >
 > Printing the core one of my programs I see:
 >
 >   data Prelude;1() a =
 >     Preluse;1() a
 >
 > What is this?  A single element tuple?  I didn't think Haskell had
 > these.  My program has a monad similar to IO.  It appears these
 > Prelude;1() things are created in the lambda lifted version of f1.
 > Perhaps is it the parenthesis around (System m)?

Indeed Yhc has the 1 tuple. You can't write it in any programs but the 
compiler does generate things that use it. The reason is that classes 
are implemented as tuples of functions. For example

instance Eq MyData where
     x == y = False
     x /= y = True

f :: [MyData] -> MyData -> Bool
f ds d = elem d ds

elem :: Eq a => a -> [a] -> Bool
elem x [] = False
elem x (y:ys) | x == y = True
               | otherwise = elem x ys

this is compiled into something along the lines of

dict_Eq_MyData = ( eq_Eq_MyData, neq_Eq_MyData )
eq_Eq_MyData x y = False
neq_Eq_MyData x y = True

(==) (eq,neq) = eq

f ds d = elem dict_Eq_MyData d ds

elem dict x zs =
    case zs of
      [] -> False
      (:) y ys -> if ((==) dict) x y then True
                                     else elem dict x ys

The question is, what do you get when your class only has one method? 
The answer is a one-tuple.

dict_OneMethodClass_MyData = 1( ... )

I can't see specifically why your example would create one-tuples as 
arguments to f1. However you can bet that it is related to class 
dictionaries, since (as far as I know) that is the only way one-tuples 
can be created.

> data Return a = Return a World
> data System a = System (World -> Return a)
> data World = World
> instance Monad System where
>   (System m) >>= k = System f1
>     where
>     f1 w = f2 w'
>       where
>       Return r w' = m w
>       System f2 = k r
> 
>   return a = System (\ w -> Return a w)

This should compiled into something like:

dict_Monad_System =
   ( bind_Monad_System, seq_default, return_Monad_System, fail_default )

bind_Monad_System n k =
   case n of
     System m -> System (f1 m k)

return_Monad_System a = System (lambda1 a)

f1 m k w =
     let Return r w' = m w
         System f2 = k r
     in f2 w		

lambda1 a w = Return a w

At least if my hand lambda lifting is correct :) As I say, I can't see 
how you'd end up with a 1-tuple being passed to f1. Though if you paste 
the Yhc-Core that you get then I'd be happy to look at it :)

> It's a bit difficult to correlate arguments of lifted lambdas to the
> original source.  Is there a convention YHC uses for adding the extra
> arguments to lifted lambdas?

Additional arguments tend to get added to the front of the function, if 
I remember correctly. Simply because it makes life easier with currying.

Hope that helps :)


Tom


P.S. you can make your 'System' type a 'newtype' rather than a 'data', 
which will make it a bit quicker :) Also your 'Return' type probably 
doesn't actually need to return the 'World' since there is no way it 
could sensibly be modified. Thus the following would probably be 
equivalent/better.

data Return a = Return a
newtype System = System (World -> Return a)

but note that the 'Return' type couldn't be a newtype because that would 
change the semantics from Lazy to Strict.