[switch the standard libraries to treat World__ as a standard unboxed type, rather than specially by the compiler
John Meacham <john@repetae.net>**20061110034422] hunk ./DataConstructors.hs 71
-tipe' (TCon (Tycon n k)) | n == tc_World__ = return $ ELit (litCons { litName = rt_Worldzh, litArgs = [], litType = eHash })
hunk ./DataConstructors.hs 204
-worlds = [(rt_Worldzh,tWorld__),(tc_World__,tWorld__)] where
-    tWorld__ = Constructor {
-                conName = rt_Worldzh,
-                conType = eHash,
-                conSlots = [],
-                conDeriving = [],
-                conExpr = ELit (litCons { litName = rt_Worldzh, litArgs = [], litType = eHash }),
-                conAlias = NotAlias,
-                conVirtual = Nothing,
-                conInhabits = tHash,
-                conChildren = Nothing
-        }
+worlds = []
hunk ./DataConstructors.hs 296
-{-
--- | determine if types are the same expanding newtypes and
-typesCompatable :: Monad m => DataTable -> E -> E -> m ()
-typesCompatable dataTable a b = go a b where
-    go :: Monad m => E -> E -> m ()
-    go a b = g' [] [] a b
-    g' xs ys a b = g a b where
-        g (ELit LitCons { litName = n, litArgs = xs, litType = t }) (ELit LitCons { litName = n', litArgs = xs', litType = t' }) | n == n' = do
-            go t t'
-            when (not $ sameShape1 xs xs') $ fail "Arg lists don't match"
-            zipWithM_ go xs xs'
-        g a b | isAbsurd a && isAbsurd b = do
-            go (getType a) (getType b)
-            return ()
-        g (ESort a) (ESort b) = when (a /= b) $ fail $ "Sorts don't match: " ++ pprint (ESort a,ESort b)
-        g (EVar a) (EVar b) = when (a /= b) $ fail $ "Vars don't match: " ++ pprint (a,b)
-        g (EAp a b) (EAp a' b') = do
-            go a a'
-            go b b'
-        g x@(EPi {}) y@(EPi {}) = do
-            let EPi (TVr { tvrType =  a}) b = allShadow x
-                EPi (TVr { tvrType =  a'}) b' = allShadow y
-            go a a'
-            go b b'
-        g (EPi (TVr { tvrIdent = 0, tvrType =  a}) b) (ELit (LitCons { litName = n, litArgs = [a',b'], litType = t })) | conName tarrow == n, t == eStar = do go a a'; go b b'
-        g (ELit (LitCons { litName = n, litArgs = [a',b'], litType = t })) (EPi (TVr { tvrIdent = 0, tvrType =  a}) b) | conName tarrow == n, t == eStar = do go a a'; go b b'
-        g x@(ELam {}) y@(ELam {}) = do
-            let ELam (TVr { tvrType = a}) b = allShadow x
-                ELam (TVr { tvrType =  a'}) b' = allShadow y
-            go a a'
-            go b b'
-        g a b = case f xs ys a b of
-            Right () -> return ()
-            Left s' -> case f ys xs b a of
-                Right () -> return ()
-                Left s -> fail (s ++ "\n" ++ s' ++ "\n")
-    f :: Monad m => [Name] -> [Name] -> E -> E -> m ()
-    f xs ys (ELit LitCons { litName = n }) _ | n `elem` xs = fail "Loop detected"
-    f xs ys a@(ELit LitCons { litName = n }) b | Just x <- followAlias dataTable a = g' (n:xs) ys x b
-    f _ _ box b | box == tBox, canBeBox b = return ()
-    f _ _ a box | box == tBox, canBeBox a = return ()
-    f _ _ a b = fail $ "Types don't match: " ++ pprint (a,b)
--}
hunk ./DataConstructors.hs 314
-    {-
-
-followAlias :: Monad m => DataTable -> E -> m E
---followAlias _ e | not (sortTypeLike e) = fail "followAlias: not a type"
-followAlias dataTable (EAp a b) = do
-    a' <- followAlias dataTable a
-    return (eAp a' b)
-followAlias dataTable (ELit LitCons { litName = c, litArgs = ts, litType = e }) = do
-    con <- getConstructor c dataTable
-    Just [cn] <- return $ conChildren con
-    ccon <- getConstructor cn dataTable
-    [sl] <- return $ conSlots ccon
-    True <- return $ sameLength (conSlots con) ts && (conAlias ccon == ErasedAlias)
-    return $ doSubst False False (fromList $ zip [2..] (map Just ts)) sl
-followAlias _ e = fail "followAlias: not an alias"
-
-followAliases :: DataTable -> E -> E
-followAliases dataTable l = f l (10::Int) where
-    f l 0 = l
-    f l n = case followAlias dataTable l of
-        Just e -> f e (n - 1)
-        Nothing -> l
-
-    -}
hunk ./DataConstructors.hs 460
-            conInhabits = tStar,
+            conInhabits = if theTypeFKind == eStar then tStar else tHash,
hunk ./E/FromHs.hs 91
-    f (TCon (Tycon n k)) | n == tc_World__ =  ELit (litCons { litName = rt_Worldzh, litArgs = [], litType = eHash })
hunk ./E/ToHs.hs 90
-    builtIns = [tc_Int,tc_Char,dc_Int,dc_Char,rt_int,rt_HsChar,rt_Worldzh,rt_HsPtr]
+    builtIns = [tc_Int,tc_Char,dc_Int,dc_Char,rt_int,rt_HsChar,tc_World__,rt_HsPtr]
hunk ./E/ToHs.hs 115
-showCon c [] | c == rt_Worldzh = text "World__"
+showCon c [] | c == tc_World__ = text "World__"
hunk ./E/Values.hs 177
-tWorldzh = ELit litCons { litName = rt_Worldzh, litArgs = [], litType = eHash }
+tWorldzh = ELit litCons { litName = tc_World__, litArgs = [], litType = eHash }
hunk ./Name/Names.hs 29
-    tWorld__ = rt_Worldzh
+    tWorld__ = tc_World__
hunk ./Name/Names.hs 89
-rt_Worldzh = toName RawType "World#"
hunk ./lib/base/Jhc/Prim.hs 11
-data World__
+data World__ :: #
hunk ./lib/base/Jhc/Prim.hs 14
-runRaw :: a -> World__ -> World__
-runRaw x w = x `seq` w
+foreign import primitive "seq" runRaw :: a -> World__ -> World__
+
hunk ./lib/base/Jhc/Prim.hs 17
-foreign import primitive seq :: a -> b -> b