[clean up E.FromHs code some more, make it so newtype annotations are properly applied everywhere
John Meacham <john@repetae.net>**20061213020815] hunk ./E/FromHs.hs 184
-  let funcs = runIdentity $ fmapM (\n -> return . fst $ runEither (show n) $ Map.lookup n ds) sFuncNames
+  let funcs = runIdentity $ fmapM (\n -> return . EVar . fst $ runEither (show n) $ Map.lookup n ds) sFuncNames
hunk ./E/FromHs.hs 187
-nameToEntryPoint :: Monad m => DataTable -> TVr -> Name -> Maybe FfiExport -> FuncNames TVr -> m (Name,TVr,E)
+nameToEntryPoint :: Monad m => DataTable -> TVr -> Name -> Maybe FfiExport -> FuncNames E -> m (Name,TVr,E)
hunk ./E/FromHs.hs 195
-                Just x | not (fopts FO.Wrapper) -> EAp (EAp (EVar runNoWrapper) x) maine
-                Just x ->  EAp (EAp (EVar runMain)  x ) maine
-                Nothing | fopts FO.Raw -> EAp (EAp (EVar runRaw) ty) maine
-                Nothing ->  EAp (EAp (EVar runExpr) ty) maine
+                Just x | not (fopts FO.Wrapper) -> EAp (EAp runNoWrapper x) maine
+                Just x ->  EAp (EAp runMain  x ) maine
+                Nothing | fopts FO.Raw -> EAp (EAp runRaw ty) maine
+                Nothing ->  EAp (EAp runExpr ty) maine
hunk ./E/FromHs.hs 291
-            cs <- flip mapM [toTVr assumps (toName Val v) | (v,_) <- hsRuleFreeVars pr ] $ \tvr -> do
+            cs <- flip mapM [toTVr assumps dataTable (toName Val v) | (v,_) <- hsRuleFreeVars pr ] $ \tvr -> do
hunk ./E/FromHs.hs 357
-    Identity funcs = fmapM (return . EVar . toTVr assumps) sFuncNames
+    Identity funcs = fmapM (return . EVar . toTVr assumps dataTable) sFuncNames
hunk ./E/FromHs.hs 413
-        return . (:[]) =<< nameToEntryPoint dataTable tn (toName Name.FfiExportName ecn) (Just ffi) =<< fmapM (return . toTVr assumps) sFuncNames
+        funcs <- asks ceFuncs
+        (:[]) `liftM` nameToEntryPoint dataTable tn (toName Name.FfiExportName ecn) (Just ffi) funcs
hunk ./E/FromHs.hs 585
-toTVr assumps n = tVr (toId n) (typeOfName n) where
-    typeOfName n = fst $ convertVal assumps n
-convertVal assumps n = (foldr ePi t vs, flip (foldr eLam) vs) where
-    (vs,t) = case Map.lookup n assumps of
-        Just z -> fromSigma  z
+toTVr assumps dataTable n = tVr (toId n) typeOfName where
+    typeOfName = case Map.lookup n assumps of
+        Just z -> removeNewtypes dataTable (tipe z)
hunk ./E/FromHs.hs 651
-        [bv] <- newVars [getType b]
+        (lbv,bv) <- varify b
hunk ./E/FromHs.hs 654
-            fe <- convertMatches [EVar bv] [([p],const (EVar v))] (EError "Irrefutable pattern match failed" (getType v))
+            fe <- convertMatches [bv] [([p],const (EVar v))] (EError "Irrefutable pattern match failed" (getType v))
hunk ./E/FromHs.hs 657
-        return (HsPWildCard,eLet bv b . eLetRec zs)
+        return (HsPWildCard,lbv . eLetRec zs)
+
+-- converts a value to an updatable closure if it isn't one already.
+varify b@EVar {} = return (id,b)
+varify b = do
+    [bv] <- newVars [getType b]
+    return (eLet bv b,EVar bv)
hunk ./E/FromHs.hs 687
-    let tv n = tvr { tvrType = removeNewtypes dataTable (tvrType tvr) } where
-            tvr = toTVr assumps (toName Name.Val n)
-    let doNegate e = eAp (eAp (func_negate funcs) (getType e)) e
-        fromInt = func_fromInt funcs
+    let fromInt = func_fromInt funcs
hunk ./E/FromHs.hs 692
+
hunk ./E/FromHs.hs 695
-        match  [] ps err = return $ foldr f err ps where
-            f ([],fe) err = fe err
+        match  [] ps err = return $ foldr f err ps where f ([],fe) err = fe err
hunk ./E/FromHs.hs 713
-                    let tb = getType b
-                    [bv] <- newVars [tb]
-                    let gps = [ (p,[ (ps,e) |  (_,ps,e) <- xs ]) | (p,xs) <- sortGroupUnderF fst3 ps]
-                        eq = EAp (func_equals funcs) tb
-                        f els (HsPLit (HsInt i),ps) = do
-                            let ip | abs i > integer_cutoff  = (EAp (EAp fromInteger tb) (intConvert i))
-                                   | otherwise =  (EAp (EAp fromInt tb) (intConvert i))
-                            m <- match bs ps err
-                            createIf (EAp (EAp eq (EVar bv)) ip) m els
-                        f els (HsPLit (HsFrac i),ps) = do
-                            let ip = (EAp (EAp fromRational tb) (toE i))
-                            m <- match bs ps err
-                            createIf (EAp (EAp eq (EVar bv)) ip) m els
-                    e <- foldlM f err gps
-                    return $ eLet bv b e
+                let tb = getType b
+                (lbv,bv) <- varify b
+                let gps = [ (p,[ (ps,e) |  (_,ps,e) <- xs ]) | (p,xs) <- sortGroupUnderF fst3 ps]
+                    eq = EAp (func_equals funcs) tb
+                    f els (HsPLit (HsInt i),ps) = do
+                        let ip | abs i > integer_cutoff  = (EAp (EAp fromInteger tb) (intConvert i))
+                               | otherwise =  (EAp (EAp fromInt tb) (intConvert i))
+                        m <- match bs ps err
+                        createIf (EAp (EAp eq bv) ip) m els
+                    f els (HsPLit (HsFrac i),ps) = do
+                        let ip = (EAp (EAp fromRational tb) (toE i))
+                        m <- match bs ps err
+                        createIf (EAp (EAp eq bv) ip) m els
+                e <- foldlM f err gps
+                return $ lbv e
hunk ./E/FromHs.hs 729
-                    [bv] <- newVars [getType b]
-                    (eqString,_,_) <- convertValue v_eqString
-                    let gps = [ (p,[ (ps,fe) |  (_,ps,fe) <- xs ]) | (p,xs) <- sortGroupUnderF fst3 ps]
-                        f els (HsPLit (HsString s),ps) = do
-                            m <- match bs ps err
-                            return $ ifzh (EAp (EAp (EVar eqString) (EVar bv)) (toE s)) m els
-                    e <- foldlM f err gps
-                    return $ eLet bv b e
+                (lbv,bv) <- varify b
+                (eqString,_,_) <- convertValue v_eqString
+                let gps = [ (p,[ (ps,fe) |  (_,ps,fe) <- xs ]) | (p,xs) <- sortGroupUnderF fst3 ps]
+                    f els (HsPLit (HsString s),ps) = do
+                        m <- match bs ps err
+                        return $ ifzh (EAp (EAp (EVar eqString) bv) (toE s)) m els
+                e <- foldlM f err gps
+                return $ lbv e