[add field to LitCons to hold the expansion of newtype aliases
John Meacham <john@repetae.net>**20061012060533] hunk ./DataConstructors.hs 70
-tipe' (TCon (Tycon n k)) | n == tc_World__ = return $ ELit (LitCons rt_Worldzh [] eHash)
-tipe' (TCon (Tycon n k)) =  return $ ELit (LitCons n [] (kind k))
+tipe' (TCon (Tycon n k)) | n == tc_World__ = return $ ELit (litCons { litName = rt_Worldzh, litArgs = [], litType = eHash })
+tipe' (TCon (Tycon n k)) =  return $ ELit litCons { litName = n, litType = kind k }
hunk ./DataConstructors.hs 89
-    return $ ELit (LitCons (unboxedNameTuple TypeConstructor (length xs' + 1)) (t':xs') eHash)
+    return $ ELit litCons { litName = unboxedNameTuple TypeConstructor (length xs' + 1), litArgs = (t':xs'), litType = eHash }
hunk ./DataConstructors.hs 169
-        tipe = ELit (LitCons tc [] eHash)
+        tipe = ELit (litCons { litName = tc, litArgs = [], litType = eHash })
hunk ./DataConstructors.hs 205
-                conExpr = ELit (LitCons rt_Worldzh [] eHash),
+                conExpr = ELit (litCons { litName = rt_Worldzh, litArgs = [], litType = eHash }),
hunk ./DataConstructors.hs 232
-        conExpr = ELit (LitCons rn [] eHash),
+        conExpr = ELit (litCons { litName = rn, litArgs = [], litType = eHash }),
hunk ./DataConstructors.hs 244
-            conExpr = ELam (tVr 2 rt) (ELit (LitCons dc [EVar (tVr 2 rt)] tipe)),
+            conExpr = ELam (tVr 2 rt) (ELit (litCons { litName = dc, litArgs = [EVar (tVr 2 rt)], litType = tipe })),
hunk ./DataConstructors.hs 263
-        tipe = ELit (LitCons tc [] eStar)
+        tipe = ELit (litCons { litName = tc, litArgs = [], litType = eStar })
hunk ./DataConstructors.hs 267
-isAbsurd (ELit (LitCons _ xs@(_:_) _)) = all isAbsurd xs
+isAbsurd (ELit LitCons { litArgs = xs@(_:_) }) = all isAbsurd xs
hunk ./DataConstructors.hs 293
-        g (EPi (TVr { tvrIdent = 0, tvrType =  a}) b) (ELit (LitCons n [a',b'] t)) | conName tarrow == n, t == eStar = do go a a'; go b b'
-        g (ELit (LitCons n [a',b'] t)) (EPi (TVr { tvrIdent = 0, tvrType =  a}) b) | conName tarrow == n, t == eStar = do 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'
hunk ./DataConstructors.hs 306
-    f xs ys (ELit LitCons { litName = n, litArgs = _, litType = _ }) _ | n `elem` xs = fail "Loop detected"
-    f xs ys a@(ELit LitCons { litName = n, litArgs = _, litType = _ }) b | Just x <- followAlias dataTable a = g' (n:xs) ys x b
+    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
hunk ./DataConstructors.hs 367
-            ec v i e = eCase v [Alt (LitCons con [i] typ) e] Unknown
+            ec v i e = eCase v [Alt (litCons { litName = con, litArgs = [i], litType = typ }) e] Unknown
hunk ./DataConstructors.hs 377
-            ib_te = ELam int1 (ec tInt dc_Int (EVar int1) i1 (ELit (LitCons con [EVar i1] typ)))
-            ib_fe = ELam val1 (ec typ con (EVar val1) i1 (ELit (LitCons dc_Int [EVar i1] tInt)))
-            ec typ con v i e = eCase v [Alt (LitCons con [i] typ) e] Unknown
+            ib_te = ELam int1 (ec tInt dc_Int (EVar int1) i1 (ELit (litCons { litName = con, litArgs = [EVar i1], litType = typ })))
+            ib_fe = ELam val1 (ec typ con (EVar val1) i1 (ELit (litCons { litName = dc_Int, litArgs = [EVar i1], litType = tInt })))
+            ec typ con v i e = eCase v [Alt (litCons { litName = con, litArgs = [i], litType = typ }) e] Unknown
hunk ./DataConstructors.hs 383
-            ib_eq = unbox (eStrictLet i3 (oper_III op (EVar i1) (EVar i2)) (ELit (LitCons dc_Boolzh [EVar i3] tBool)))
+            ib_eq = unbox (eStrictLet i3 (oper_III op (EVar i1) (EVar i2)) (ELit (litCons { litName = dc_Boolzh, litArgs = [EVar i3], litType = tBool })))
hunk ./DataConstructors.hs 406
-            f (n,vc) = vc { conExpr = ELit (LitCons consName [ELit (LitInt (fromIntegral n) tIntzh)] (conType vc)), conVirtual = virt }
+            f (n,vc) = vc { conExpr = ELit (litCons { litName = consName, litArgs = [ELit (LitInt (fromIntegral n) tIntzh)], litType = conType vc }), conVirtual = virt }
hunk ./DataConstructors.hs 409
-            dataCons = fc { conName = consName, conType = getType (conExpr dataCons), conSlots = [tIntzh], conExpr = ELam (tVr 12 tIntzh) (ELit (LitCons consName [EVar (tVr 12 tIntzh)] (conExpr theType))) }
+            dataCons = fc { conName = consName, conType = getType (conExpr dataCons), conSlots = [tIntzh], conExpr = ELam (tVr 12 tIntzh) (ELit (litCons { litName = consName, litArgs = [EVar (tVr 12 tIntzh)], litType =  conExpr theType })) }
hunk ./DataConstructors.hs 432
-        theExpr =  foldr ($) (strictize $ ELit (LitCons dataConsName (map EVar vars) theTypeExpr)) (map ELam vars)
+        theExpr =  foldr ($) (strictize $ ELit litCons { litName = dataConsName, litArgs = map EVar vars, litType = theTypeExpr }) (map ELam vars)
hunk ./DataConstructors.hs 456
-        theTypeExpr =  (ELit (LitCons theTypeName (map EVar theTypeArgs) theTypeFKind))
+        theTypeExpr = ELit litCons { litName = theTypeName, litArgs = map EVar theTypeArgs, litType = theTypeFKind }
hunk ./DataConstructors.hs 506
-        Nothing -> Alt (LitCons name vs typ) e
-        Just _ -> let ELit (LitCons _ [ELit (LitInt n t)] _) = conExpr mc in Alt (LitInt n t) e
+        Nothing -> Alt (litCons { litName = name, litArgs = vs, litType = typ }) e
+        Just _ -> let ELit LitCons {  litArgs = [ELit (LitInt n t)] } = conExpr mc in Alt (LitInt n t) e
hunk ./DataConstructors.hs 573
-    f (ELit LitCons { litName = n, litArgs = as, litType = _ }) | (a:as') <- reverse as = f $ EAp (ELit (LitCons n (reverse as') undefined)) a
-    f (ELit LitCons { litName = n, litArgs = [], litType = _ }) = return $ atom $ text $ show n
+    f (ELit LitCons { litName = n, litArgs = as }) | (a:as') <- reverse as = f $ EAp (ELit litCons { litName = n, litArgs = reverse as' }) a
+    f (ELit LitCons { litName = n, litArgs = [] }) = return $ atom $ text $ show n
hunk ./E/E.hs 37
-    | LitCons  { litName :: Name, litArgs :: [e], litType :: t }
+    | LitCons  { litName :: Name, litArgs :: [e], litType :: t, litAliasFor :: Maybe E }
hunk ./E/E.hs 42
-litCons = LitCons { litName = error "litName: name not set", litArgs = [], litType = error "litCons: type not set" }
+litCons = LitCons { litName = error "litName: name not set", litArgs = [], litType = error "litCons: type not set", litAliasFor = Nothing }
hunk ./E/E.hs 53
-        LitCons { litName = a, litArgs = es, litType = e } -> do  e <- f e; return LitCons { litName = a, litArgs = es, litType = e }
+        LitCons { litName = a, litArgs = es, litType = e, litAliasFor = af } -> do  e <- f e; return LitCons { litName = a, litArgs = es, litType = e, litAliasFor = af }
hunk ./E/E.hs 172
-litHead LitCons { litName = s } = LitCons s [] ()
+litHead LitCons { litName = s } = litCons { litName = s, litType = () }
hunk ./E/E.hs 178
-patToLitEE LitCons { litName = n, litArgs = xs, litType = t } = ELit $ LitCons n (map EVar xs) t
+patToLitEE LitCons { litName = n, litArgs = xs, litType = t, litAliasFor = af } = ELit $ LitCons { litName = n, litArgs = (map EVar xs), litType = t, litAliasFor = af }
hunk ./E/E.hs 185
-caseBinds ec = eCaseBind ec : concat [ xs  | LitCons _ xs _ <- casePats ec]
+caseBinds ec = eCaseBind ec : concat [ xs  | LitCons { litArgs = xs } <- casePats ec]
hunk ./E/E.hs 334
-ltTuple ts = ELit $ LitCons (nameTuple TypeConstructor (length ts)) ts eStar
-ltTuple' ts = ELit $ LitCons (unboxedNameTuple TypeConstructor (length ts)) ts eHash
+ltTuple ts = ELit $ litCons { litName = nameTuple TypeConstructor (length ts), litArgs = ts, litType = eStar }
+ltTuple' ts = ELit $ litCons { litName = unboxedNameTuple TypeConstructor (length ts), litArgs = ts, litType = eHash }
hunk ./E/Eval.hs 26
-    eval' (ELit LitCons { litName = n, litArgs = es, litType = t }) [] = ELit $ LitCons n (map eval es) t
+    eval' (ELit lc@LitCons { litName = n, litArgs = es, litType = t }) [] = ELit lc { litArgs = map eval es }
hunk ./E/Eval.hs 30
-    eval' (ELit (LitCons n es ty@EPi {})) (t:rest) = eval' (ELit $ LitCons n (es ++ [t]) (eval $ EAp ty t)) rest
+    eval' (ELit lc@LitCons { litArgs = es, litType = EPi tb tt }) (t:rest) = eval' (ELit lc { litArgs = es ++ [t], litType = subst tb t tt }) rest
hunk ./E/Eval.hs 73
-    eval' ds (ELit LitCons { litName = n, litArgs = es, litType = t }) [] = do
+    eval' ds (ELit lc@LitCons { litArgs = es, litType = t }) [] = do
hunk ./E/Eval.hs 76
-        return $ ELit $ litCons { litName = n, litArgs = es', litType = t' }
+        return $ ELit $ lc { litArgs = es', litType = t' }
hunk ./E/Eval.hs 78
-    eval' ds (ELit (LitCons n es ty@EPi {})) (t:rest) = do
-        t' <- (eval' ds (EAp ty t) [])
-        eval' ds (ELit $ LitCons n (es ++ [t]) t') rest
+    eval' ds (ELit lc@LitCons { litArgs = es, litType = EPi tb tt }) (t:rest) = eval' ds (ELit lc { litArgs = es ++ [t], litType = subst tb t tt }) rest
hunk ./E/FromHs.hs 26
-import Class
hunk ./E/FromHs.hs 28
+import Class
hunk ./E/FromHs.hs 30
-import PrimitiveOperators
hunk ./E/FromHs.hs 33
-import E.Eval(eval)
hunk ./E/FromHs.hs 34
+import E.Eval(eval)
hunk ./E/FromHs.hs 36
-import E.Program
hunk ./E/FromHs.hs 37
+import E.Program
hunk ./E/FromHs.hs 48
-import FrontEnd.Tc.Type hiding(Rule(..), unbox)
hunk ./E/FromHs.hs 49
+import FrontEnd.Tc.Type hiding(Rule(..), unbox)
hunk ./E/FromHs.hs 59
-import qualified FlagOpts as FO
-import qualified FrontEnd.Tc.Monad as TM
-import qualified FrontEnd.Tc.Type as T(Rule(..))
-import qualified Info.Info as Info
-import qualified Stats
-import qualified Util.Seq as Seq
+import PrimitiveOperators
hunk ./E/FromHs.hs 66
+import qualified FlagOpts as FO
+import qualified FrontEnd.Tc.Monad as TM
+import qualified FrontEnd.Tc.Type as T(Rule(..))
+import qualified Info.Info as Info
+import qualified Stats
+import qualified Util.Seq as Seq
hunk ./E/FromHs.hs 103
-    f (TCon (Tycon n k)) =  ELit (LitCons n [] (kind k))
+    f (TCon (Tycon n k)) =  ELit litCons { litName = n, litType = kind k }
hunk ./E/FromHs.hs 109
-        in ELit (LitCons (unboxedNameTuple TypeConstructor (length xs' + 1)) (f t:xs') eHash)
+        in ELit litCons { litName = unboxedNameTuple TypeConstructor (length xs' + 1), litArgs = f t:xs', litType = eHash }
hunk ./E/FromHs.hs 221
-        ELit (LitCons n [x] _) | n ==  tc_IO -> Just x
-        (EPi ioc (EPi tvr (ELit (LitCons n [x] _)))) | n == tc_IOResult -> Just x
+        ELit LitCons { litName = n, litArgs = [x] } | n ==  tc_IO -> Just x
+        (EPi ioc (EPi tvr (ELit LitCons { litName = n, litArgs = [x] }))) | n == tc_IOResult -> Just x
hunk ./E/FromHs.hs 419
-                ELit (litCons { litName = c, litArgs = [x], litType = _ }) | c == tc_IO -> (True,x)
+                ELit (LitCons { litName = c, litArgs = [x] }) | c == tc_IO -> (True,x)
hunk ./E/FromHs.hs 744
-                        return $ eCase b [Alt (litCons { litName = vCons, litArgs = [z] (getType b)) (eCase (EVar z) as err')], litType = Unknown }
+                        return $ eCase b [Alt litCons { litName = vCons, litArgs = [z], litType = getType b } (eCase (EVar z) as err')] Unknown
hunk ./E/FromHs.hs 799
-    f ECase { eCaseScrutinee = e, eCaseAlts =  ((Alt (litCons { litName = n, litArgs = [v], litType = t }) z):_) } | alias == ErasedAlias = eLet v (f e)  (f z) where
+    f ECase { eCaseScrutinee = e, eCaseAlts =  ((Alt (LitCons { litName = n, litArgs = [v], litType = t }) z):_) } | alias == ErasedAlias = eLet v (f e)  (f z) where
hunk ./E/FromHs.hs 801
-    f ECase { eCaseScrutinee = e, eCaseAlts =  ((Alt (litCons { litName = n, litArgs = [v], litType = t }) z):_) } | alias == RecursiveAlias = eLet v (prim_unsafeCoerce (f e) (getType v)) (f z) where
+    f ECase { eCaseScrutinee = e, eCaseAlts =  ((Alt (LitCons { litName = n, litArgs = [v], litType = t }) z):_) } | alias == RecursiveAlias = eLet v (prim_unsafeCoerce (f e) (getType v)) (f z) where
hunk ./E/Inline.hs 65
-app' (ELit (LitCons n xs t@EPi {})) (a:as)  = do
+app' (ELit lc@LitCons { litName = n, litArgs = xs, litType = EPi ta tt }) (a:as)  = do
hunk ./E/Inline.hs 67
-    app (ELit (LitCons n (xs ++ [a]) (eAp t a)),as)
+    app (ELit (lc { litArgs = xs ++ [a], litType = subst ta a tt }),as)
hunk ./E/LetFloat.hs 93
+        _ -> error "E.LetFloat.g: bad"
hunk ./E/LetFloat.hs 148
-canFloatPast t | getType t == ELit (LitCons tc_IOErrorCont [] (ESort EStar)) = True
+canFloatPast t | ELit LitCons { litName = n } <- getType t, n == tc_IOErrorCont = True -- getType t == ELit (litCons tc_IOErrorCont [] (ESort EStar)) = True
hunk ./E/LetFloat.hs 283
-            ma (Alt LitCons { litName = n, litArgs = xs, litType = t }  b) = Alt (LitCons n (map m xs) t) b
+            ma (Alt lc@LitCons { litName = n, litArgs = xs, litType = t }  b) = Alt lc { litArgs = map m xs } b
hunk ./E/PrimOpt.hs 132
-            ELit (LitCons _ [a,b] (ESort EStar)) = rt
+            ELit LitCons { litArgs = [a,b], litType = ESort EStar } = rt
hunk ./E/PrimOpt.hs 135
-            ELit (LitCons _ [a,b] (ESort EStar)) = rt
-        primopt (PrimPrim "newHole__") [y] (ELit (LitCons name [b] (ESort EStar))) | name == tc_IOResult =
+            ELit LitCons { litArgs = [a,b], litType = ESort EStar } = rt
+        primopt (PrimPrim "newHole__") [y] (ELit LitCons { litName = name, litArgs = [b], litType = ESort EStar }) | name == tc_IOResult =
hunk ./E/SSimplify.hs 124
-    f (ELit LitCons { litName = n, litArgs = as, litType = t }) = arg $ do
+    f (ELit lc@LitCons { litName = n, litArgs = as, litType = t }) = arg $ do
hunk ./E/SSimplify.hs 127
-        return (ELit (LitCons n as t))
+        return (ELit lc { litArgs = as, litType = t })
hunk ./E/SSimplify.hs 202
-mapLitBinds f LitCons { litName = n, litArgs = es, litType = t } = LitCons n (map f es) t
+mapLitBinds f lc@LitCons { litArgs = es } = lc { litArgs = map f es }
hunk ./E/SSimplify.hs 204
-mapLitBindsM f LitCons { litName = n, litArgs = es, litType = t } = do
+mapLitBindsM f lc@LitCons { litArgs = es } = do
hunk ./E/SSimplify.hs 206
-    return (LitCons n es t)
+    return lc { litArgs = es }
hunk ./E/SSimplify.hs 490
-    g (ELit LitCons { litName = n, litArgs = es, litType = t }) inb = do
+    g (ELit lc@LitCons { litName = n, litArgs = es, litType = t }) inb = do
hunk ./E/SSimplify.hs 493
-        return $ ELit (LitCons n es' t')
+        return $ ELit lc { litArgs = es', litType = t' }
hunk ./E/SSimplify.hs 588
-                let wtd = ELit $ LitCons n (map EVar ts) te
-                return $ Alt (LitCons n ts te) (eLet b wtd d)
+                let wtd = ELit $ litCons { litName = n, litArgs = map EVar ts, litType = te }
+                return $ Alt litCons { litName = n, litArgs = ts, litType = te } (eLet b wtd d)
hunk ./E/SSimplify.hs 644
-            da (Alt LitCons { litName = n, litArgs = ns, litType = t } ae) = do
+            da (Alt lc@LitCons { litName = n, litArgs = ns, litType = t } ae) = do
hunk ./E/SSimplify.hs 647
-                let p' = LitCons n ns' t'
+                let p' = lc { litArgs = ns', litType = t' }
hunk ./E/SSimplify.hs 772
-    app' (ELit (LitCons n xs t@EPi {})) (a:as)  = do
+    app' (ELit lc@LitCons { litName = n, litArgs = xs, litType = EPi ta tt }) (a:as)  = do
hunk ./E/SSimplify.hs 774
-        app' (ELit (LitCons n (xs ++ [a]) (eAp t a))) as
+        app' (ELit lc { litArgs = xs ++ [a], litType = subst ta a tt }) as
+--    app' (ELit (LitCons n xs t@EPi {})) (a:as)  = do
+--        mtick (toAtom $ "E.Simplify.typecon-reduce.{" ++ show n ++ "}" )
+--        app' (ELit (LitCons n (xs ++ [a]) (eAp t a))) as
hunk ./E/Show.hs 72
-        f (LitCons n [a,b] _) | dc_Cons == n  = do
+        f LitCons { litName = n, litArgs = [a,b] } | dc_Cons == n  = do
hunk ./E/Show.hs 76
-        f (LitCons n [e] _) | tc_List == n = do
+        f LitCons { litName = n, litArgs = [e] } | tc_List == n = do
hunk ./E/Show.hs 80
-        f (LitCons n [v] _)
+        f LitCons { litName = n, litArgs = [v] }
hunk ./E/Show.hs 170
-        f (EError s t) = do
-            ty <- showE t
-            return $ atom $ angles ( UC.bottom <> char ':' <> text s <>  UC.coloncolon <> unparse ty)
hunk ./E/Show.hs 173
+        f (EError s t) = do
+            ty <- showE t
+            return $ atom $ angles ( UC.bottom <> char ':' <> text s <>  UC.coloncolon <> unparse ty)
hunk ./E/Show.hs 249
-rawType s  = ELit (LitCons (toName RawType s) [] eHash)
+rawType s  = ELit litCons { litName = toName RawType s, litType = eHash }
hunk ./E/Subst.hs 56
-litSMapM f LitCons { litName = s, litArgs = es, litType = t } = do
+litSMapM f LitCons { litName = s, litArgs = es, litType = t, litAliasFor = af } = do
hunk ./E/Subst.hs 59
-    return $ LitCons s es' t'
+    return $ LitCons s es' t' af
hunk ./E/Subst.hs 102
-        let da (Alt LitCons { litName = s, litArgs = vs, litType = t } e) = do
+        let da (Alt lc@LitCons { litName = s, litArgs = vs, litType = t } e) = do
hunk ./E/Subst.hs 106
-                return $ Alt (LitCons s as t') e'
+                return $ Alt lc { litArgs = as, litType = t' } e'
hunk ./E/Subst.hs 168
-eAp (ELit (LitCons n es (EPi t r))) b = ELit (LitCons n (es ++ [b]) (subst t b r))
+eAp (ELit lc@LitCons { litArgs = es, litType = (EPi t r) }) b = ELit lc { litArgs = es ++ [b], litType = subst t b r }
hunk ./E/Subst.hs 220
-        let da (Alt LitCons { litName = s, litArgs = vs, litType = t } e) = do
+        let da (Alt lc@LitCons { litName = s, litArgs = vs, litType = t } e) = do
hunk ./E/Subst.hs 224
-                return $ Alt (LitCons s as t') e'
+                return $ Alt lc { litArgs = as, litType = t' } e'
hunk ./E/Subst.hs 249
-    litSMapM LitCons { litName = s, litArgs = es, litType = t } = do
+    litSMapM lc@LitCons { litName = s, litArgs = es, litType = t } = do
hunk ./E/Subst.hs 252
-        return $ LitCons s es' t'
+        return $ lc { litArgs = es', litType = t' }
hunk ./E/Traverse.hs 56
-    z (ELit LitCons { litName = n, litArgs = es, litType = t }) = do t' <- g t; es' <- mapM f es; return $ ELit (LitCons n es' t')
+    z (ELit lc@LitCons { litArgs = es, litType = t }) = do t' <- g t; es' <- mapM f es; return $ ELit lc { litArgs = es', litType = t' }
hunk ./E/Traverse.hs 70
-    mapmAlt (Alt LitCons { litName = n, litArgs = xs, litType = t } e) = do
+    mapmAlt (Alt lc@LitCons {  litArgs = xs, litType = t } e) = do
hunk ./E/Traverse.hs 74
-        return $ Alt (LitCons n xs' t') e'
+        return $ Alt lc { litArgs = xs', litType = t' } e'
hunk ./E/Traverse.hs 99
-    f  (ELit LitCons { litName = n, litArgs = xs, litType = t }) = do
+    f  (ELit lc@LitCons { litArgs = xs, litType = t }) = do
hunk ./E/Traverse.hs 102
-        return $ ELit (LitCons n xs' t')
+        return $ ELit lc { litArgs = xs', litType = t' }
hunk ./E/Traverse.hs 138
-    da (Alt LitCons { litName = n, litArgs = xs, litType = t } l) = do
+    da (Alt lc@LitCons { litName = n, litArgs = xs, litType = t } l) = do
hunk ./E/Traverse.hs 143
-            return (Alt (LitCons n (snds xs') t') l')
+            return (Alt lc { litArgs = snds xs', litType = t' } l')
hunk ./E/TypeAnalysis.hs 243
-    as = [ n | LitCons n _ _ <- casePats ec ]
+    as = [ n | LitCons { litName = n } <- casePats ec ]
hunk ./E/TypeAnalysis.hs 258
-        return $ ELit (LitCons h as' kind)
+        return $ ELit (litCons { litName = h, litArgs = as', litType = kind })
hunk ./E/TypeAnalysis.hs 272
-repi (ELit (LitCons n [a,b] _)) | n == tc_Arrow = EPi tvr { tvrIdent = 0, tvrType = a } b
+repi (ELit LitCons { litName = n, litArgs = [a,b] }) | n == tc_Arrow = EPi tvr { tvrIdent = 0, tvrType = a } b
hunk ./E/TypeAnalysis.hs 341
-        valToPat' (ELit LitCons { litName = x, litArgs = ts, litType = t }) = LitCons x [ z | ~(EVar z) <- ts ] t
-        valToPat' (EPi (TVr { tvrType =  EVar a}) (EVar b))  = LitCons tc_Arrow [a,b] eStar
+        valToPat' (ELit LitCons { litName = x, litArgs = ts, litType = t }) = LitCons { litName = x, litArgs = [ z | ~(EVar z) <- ts ], litType = t }
+        valToPat' (EPi (TVr { tvrType =  EVar a}) (EVar b))  = litCons { litName = tc_Arrow, litArgs = [a,b], litType = eStar }
hunk ./E/Values.hs 29
-    tupleMany es = ELit $ LitCons (nameTuple DataConstructor (length es)) es (ltTuple ts) where
+    tupleMany es = ELit litCons { litName = nameTuple DataConstructor (length es), litArgs = es, litType = ltTuple ts } where
hunk ./E/Values.hs 38
-unboxedTuple es =  LitCons (unboxedNameTuple DataConstructor (length es)) es (ltTuple' ts) where
+unboxedTuple es =  litCons { litName = unboxedNameTuple DataConstructor (length es), litArgs = es, litType = ltTuple' ts } where
hunk ./E/Values.hs 78
-    toE ch = ELit (LitCons dc_Char [toEzh ch] tChar)
+    toE ch = ELit (litCons { litName = dc_Char, litArgs = [toEzh ch], litType = tChar })
hunk ./E/Values.hs 82
-    toE rat = ELit (LitCons dc_Rational [toE (numerator rat), toE (denominator rat)] tRational)
+    toE rat = ELit (litCons { litName = dc_Rational, litArgs = [toE (numerator rat), toE (denominator rat)], litType = tRational })
hunk ./E/Values.hs 86
-    toE ch = ELit (LitCons dc_Integer [toEzh ch] tInteger)
+    toE ch = ELit (litCons { litName = dc_Integer, litArgs = [toEzh ch], litType = tInteger })
hunk ./E/Values.hs 90
-    toE ch = ELit (LitCons dc_Int [toEzh ch] tInt)
+    toE ch = ELit (litCons { litName = dc_Int, litArgs = [toEzh ch], litType = tInt })
hunk ./E/Values.hs 96
-    typeE (_::[a]) = ELit (LitCons tc_List [typeE (undefined::a)] eStar)
+    typeE (_::[a]) = ELit (litCons { litName = tc_List, litArgs = [typeE (undefined::a)], litType = eStar })
hunk ./E/Values.hs 101
-eCons x xs = ELit $ LitCons vCons [x,xs] (getType xs)
-eNil t = ELit $ LitCons vEmptyList [] t
+eCons x xs = ELit $ litCons { litName = vCons, litArgs = [x,xs], litType = getType xs }
+eNil t = ELit $ litCons { litName = vEmptyList, litArgs = [], litType = t }
hunk ./E/Values.hs 106
-eCaseTup e vs w = emptyCase { eCaseScrutinee = e, eCaseBind =  (tVr 0 (getType e)), eCaseType = getType w, eCaseAlts =  [Alt (LitCons (nameTuple DataConstructor (length vs)) vs (getType e)) w] }
-eCaseTup' e vs w = emptyCase { eCaseScrutinee = e, eCaseBind = (tVr 0 (getType e)), eCaseType = getType w, eCaseAlts =  [Alt (LitCons (unboxedNameTuple DataConstructor (length vs)) vs (getType e)) w] }
+eCaseTup e vs w = emptyCase { eCaseScrutinee = e, eCaseBind =  (tVr 0 (getType e)), eCaseType = getType w, eCaseAlts =  [Alt litCons { litName = nameTuple DataConstructor (length vs), litArgs = vs, litType = getType e } w] }
+eCaseTup' e vs w = emptyCase { eCaseScrutinee = e, eCaseBind = (tVr 0 (getType e)), eCaseType = getType w, eCaseAlts =  [Alt litCons { litName = unboxedNameTuple DataConstructor (length vs), litArgs = vs, litType = getType e} w] }
hunk ./E/Values.hs 109
-eJustIO w x = ELit (LitCons dc_JustIO [w,x] (ELit (LitCons tc_IOResult [getType x] eStar)))
-tIO t = ELit (LitCons tc_IO [t] eStar)
+eJustIO w x = ELit litCons { litName = dc_JustIO, litArgs = [w,x], litType = ELit litCons { litName = tc_IOResult, litArgs = [getType x], litType = eStar } }
+tIO t = ELit (litCons { litName = tc_IO, litArgs = [t], litType = eStar })
hunk ./E/Values.hs 154
-vTag n = ELit $ LitCons n [] tTag
+vTag n = ELit $ litCons { litName = n, litArgs = [], litType = tTag }
hunk ./E/Values.hs 175
-rawType s = ELit (LitCons (toName RawType s) [] eHash)
+rawType s = ELit litCons { litName = toName RawType s, litType = eHash }
hunk ./E/Values.hs 177
-tWorldzh = ELit (LitCons rt_Worldzh [] eHash)
-tTag = ELit (LitCons rt_tag [] eHash)
+tWorldzh = ELit litCons { litName = rt_Worldzh, litArgs = [], litType = eHash }
+tTag = ELit litCons { litName = rt_tag, litArgs = [], litType = eHash }
hunk ./E/Values.hs 186
-    f n (ELit LitCons { litName = x, litArgs = y }) t = (n,ELit (LitCons x y t),id)
+    f n (ELit lc@LitCons {}) t = (n,ELit lc { litType = t },id)
hunk ./E/WorkerWrapper.hs 90
-        f (Cons c ts,t) = [(t,ELit (LitCons (conName c) (map EVar (snds ts)) (getType t)))] ++ concatMap f ts
+        f (Cons c ts,t) = [(t,ELit (litCons { litName = conName c, litArgs = map EVar (snds ts), litType = getType t }))] ++ concatMap f ts
hunk ./E/WorkerWrapper.hs 95
-        f ((Cons c ts,t):rs) = eCase (EVar t) [Alt (LitCons (conName c) (snds ts) (getType t)) (f (ts ++ rs))] Unknown
+        f ((Cons c ts,t):rs) = eCase (EVar t) [Alt (litCons { litName = conName c, litArgs = snds ts, litType = getType t }) (f (ts ++ rs))] Unknown
hunk ./E/WorkerWrapper.hs 102
-                cb = Alt (LitCons cname vars bodyTyp) (if isSingleton then EVar sv else (ELit $ unboxedTuple (map EVar vars)))
+                cb = Alt (litCons { litName = cname, litArgs = vars, litType = bodyTyp }) (if isSingleton then EVar sv else (ELit $ unboxedTuple (map EVar vars)))
hunk ./E/WorkerWrapper.hs 106
-        ne | Just cname <- cname, isSingleton = cases $ eStrictLet sv workerCall  (ELit $ LitCons cname [EVar sv] bodyTyp)
-           | Just cname <- cname = let ca = Alt (unboxedTuple vars) (ELit $ LitCons cname (map EVar vars) bodyTyp) in  cases $ eCase workerCall [ca] Unknown
+        ne | Just cname <- cname, isSingleton = cases $ eStrictLet sv workerCall  (ELit $ litCons { litName = cname, litArgs = [EVar sv], litType = bodyTyp })
+           | Just cname <- cname = let ca = Alt (unboxedTuple vars) (ELit $ litCons { litName = cname, litArgs = (map EVar vars), litType = bodyTyp }) in  cases $ eCase workerCall [ca] Unknown
hunk ./data/PrimitiveOperators-in.hs 19
-create_integralCast c1 t1 c2 t2 e t = eCase e [Alt (LitCons c1 [tvra] te) cc] Unknown  where
+create_integralCast c1 t1 c2 t2 e t = eCase e [Alt (litCons { litName = c1, litArgs = [tvra], litType = te }) cc] Unknown  where
hunk ./data/PrimitiveOperators-in.hs 25
-    cc = if n1 == n2 then ELit (LitCons c2 [EVar tvra] t) else
-        eStrictLet  tvrb (EPrim (APrim (CCast (show n1) (show n2)) mempty) [EVar tvra] t2)  (ELit (LitCons c2 [EVar tvrb] t))
+    cc = if n1 == n2 then ELit (litCons { litName = c2, litArgs = [EVar tvra], litType = t }) else
+        eStrictLet  tvrb (EPrim (APrim (CCast (show n1) (show n2)) mempty) [EVar tvra] t2)  (ELit (litCons { litName = c2, litArgs = [EVar tvrb], litType = t }))
hunk ./data/PrimitiveOperators-in.hs 40
-unbox' e cn tvr wtd = eCase e [Alt (LitCons cn [tvr] te) wtd] Unknown where
+unbox' e cn tvr wtd = eCase e [Alt (litCons { litName = cn, litArgs = [tvr], litType = te }) wtd] Unknown where
hunk ./data/PrimitiveOperators-in.hs 59
-    rebox x = ELit (LitCons cn [x] t)
+    rebox x = ELit (litCons { litName = cn, litArgs = [x], litType = t })
hunk ./data/PrimitiveOperators-in.hs 68
-    rebox x = ELit (LitCons cn [x] t)
+    rebox x = ELit (litCons { litName = cn, litArgs = [x], litType = t })
hunk ./data/PrimitiveOperators-in.hs 75
-    rebox x = ELit (LitCons cn [x] t)
+    rebox x = ELit (litCons { litName = cn, litArgs = [x], litType = t })
hunk ./data/PrimitiveOperators-in.hs 84
-    rebox x = ELit (LitCons dc_Int [x] t)
+    rebox x = ELit (litCons { litName = dc_Int, litArgs = [x], litType = t })
hunk ./data/PrimitiveOperators-in.hs 93
-    wtd = eStrictLet tvrc (oper_aaI op ct (EVar tvra) (EVar tvrb)) (ELit (LitCons dc_Boolzh [EVar tvrc] tBool))  -- (caseof (EVar tvrc))
+    wtd = eStrictLet tvrc (oper_aaI op ct (EVar tvra) (EVar tvrb)) (ELit (litCons { litName = dc_Boolzh, litArgs = [EVar tvrc], litType = tBool }))  -- (caseof (EVar tvrc))
hunk ./data/PrimitiveOperators-in.hs 104
-    rebox x = ELit (LitCons cn [x] te)
+    rebox x = ELit (litCons { litName = cn, litArgs = [x], litType = te })
hunk ./data/PrimitiveOperators-in.hs 114
-    rebox x = ELit (LitCons cn [x] te)
+    rebox x = ELit (litCons { litName = cn, litArgs = [x], litType = te })
hunk ./data/PrimitiveOperators-in.hs 126
-    rest = eCaseTup' (EPrim (APrim (Peek p) mempty) [EVar tvrWorld, EVar tvr'] (ltTuple' [tWorld__,rawType p])) [tvrWorld2,rtVar] (eLet rtVar' (ELit $ LitCons cn [EVar rtVar] t) $ eJustIO (EVar tvrWorld2) (EVar rtVar') )
+    rest = eCaseTup' (EPrim (APrim (Peek p) mempty) [EVar tvrWorld, EVar tvr'] (ltTuple' [tWorld__,rawType p])) [tvrWorld2,rtVar] (eLet rtVar' (ELit $ litCons { litName = cn, litArgs = [EVar rtVar], litType = t }) $ eJustIO (EVar tvrWorld2) (EVar rtVar') )
hunk ./data/PrimitiveOperators-in.hs 156
-prim_number cn v t et = ELit (LitCons cn [ELit (LitInt v t)] et) where
+prim_number cn v t et = ELit litCons { litName = cn, litArgs = [ELit (LitInt v t)], litType = et }
hunk ./data/PrimitiveOperators-in.hs 158
-prim_number _ _ _ _ = error "prim_number: invalid arg"
+--prim_number _ _ _ _ = error "prim_number: invalid arg"
hunk ./data/PrimitiveOperators-in.hs 161
---prim_const cn s st et = eStrictLet (tVr 2 st) (EPrim (APrim (CConst s t) mempty) [] st) (ELit (LitCons cn [EVar $ tVr 2 st] et)) where
-prim_const cn s st t et = ELit (LitCons cn [(EPrim (APrim (CConst s t) mempty) [] st)] et)
-prim_const _ _ _ _ _ = error "prim_const: invalid arg"
+--prim_const cn s st et = eStrictLet (tVr 2 st) (EPrim (APrim (CConst s t) mempty) [] st) (ELit (litCons { litName = cn, litArgs = [EVar $ tVr 2 st], litType = et })) where
+prim_const cn s st t et = ELit litCons { litName = cn, litArgs = [EPrim (APrim (CConst s t) mempty) [] st], litType = et }
+--prim_const _ _ _ _ _ = error "prim_const: invalid arg"
hunk ./data/PrimitiveOperators-in.hs 165
-prim_sizeof s = (ELit (LitCons dc_Int [rp] tInt)) where
+prim_sizeof s = (ELit (litCons { litName = dc_Int, litArgs = [rp], litType = tInt })) where
hunk ./utils/op_process.prl 71
-    my $v = "$n = ELit (LitCons tc_$x [] eStar)";
+    my $v = "$n = ELit litCons { litName = tc_$x, litType = eStar}";
hunk ./utils/op_process.prl 82
-    my $v = "$n " . " "x(14-length $n) . "= ELit (LitCons rt_$c  [] eHash)";
+    my $v = "$n " . " "x(14-length $n) . "= ELit litCons { litName = rt_$c, litType = eHash }";