Comments only
authorSimon Peyton Jones <simonpj@microsoft.com>
Thu, 9 Jun 2016 13:42:26 +0000 (14:42 +0100)
committerSimon Peyton Jones <simonpj@microsoft.com>
Fri, 10 Jun 2016 16:18:56 +0000 (17:18 +0100)
...about unarisation and unboxed tuples

compiler/simplStg/UnariseStg.hs
compiler/stgSyn/CoreToStg.hs
compiler/types/Type.hs

index d580942..1b94cbc 100644 (file)
@@ -50,6 +50,22 @@ Of course all this applies recursively, so that we flatten out nested tuples.
 Note [Unarisation and nullary tuples]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The above scheme has a special cases for nullary unboxed tuples, x :: (# #)
+To see why, consider
+    f2 :: (# Int, Int #) -> Int
+    f1 :: (# Int #) -> Int
+    f0 :: (# #) -> Int
+
+When we "unarise" to eliminate unboxed tuples (this is done at the STG level),
+we'll transform to
+    f2 :: Int -> Int -> Int
+    f1 :: Int -> Int
+    f0 :: ??
+
+We do not want to give f0 zero arguments, otherwise a lambda will
+turn into a thunk! So we want to get
+    f0 :: Void# -> Int
+
+So here is what we do for nullary tuples
 
   * Extend the UnariseEnv with   x :-> [voidPrimId]
 
index d2010a8..273cbdb 100644 (file)
@@ -451,7 +451,7 @@ mkStgAltType bndr alts = case repType (idType bndr) of
                                         PolyAlt
         Nothing                      -> PolyAlt
     UbxTupleRep rep_tys -> UbxTupAlt (length rep_tys)
-    -- NB Nullary unboxed tuples have UnaryRep, and generate a PrimAlt
+        -- UbxTupAlt includes nullary and and singleton unboxed tuples
   where
    _is_poly_alt_tycon tc
         =  isFunTyCon tc
index 9aaf3de..724a9a4 100644 (file)
@@ -1714,33 +1714,11 @@ typeSize (CoercionTy co)  = coercionSize co
 *                                                                       *
 ********************************************************************** -}
 
-{- Note [Nullary unboxed tuple]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-At runtime we represent the nullary unboxed tuple as the type Void#.
-To see why, consider
-    f2 :: (# Int, Int #) -> Int
-    f1 :: (# Int #) -> Int
-    f0 :: (# #) -> Int
-
-When we "unarise" to eliminate unboxed tuples (this is done at the STG level),
-we'll transform to
-    f2 :: Int -> Int -> Int
-    f1 :: Int -> Int
-    f0 :: ??
-
-We do not want to give f0 zero arguments, otherwise a lambda will
-turn into a thunk! So we want to get
-    f0 :: Void# -> Int
-
-See Note [Unarisation and nullary tuples] in UnariseStg for more detail.
--}
-
 type UnaryType = Type
 
 data RepType
   = UbxTupleRep [UnaryType] -- Represented by multiple values
-                            -- INVARIANT: never an empty list
-                            -- (see Note [Nullary unboxed tuple])
+                            -- Can be zero, one, or more
   | UnaryRep UnaryType      -- Represented by a single value
 
 instance Outputable RepType where