Changeset 22990 for src/Pugs/Eval.hs

Timestamp:

11/12/08 10:01:29 (8 weeks ago)

Author:

audreyt

Message:

* GHC 6.10 support, part 3 of 3: Adjust for GADT's "rigid types" restriction.

Files:

• src/Pugs/Eval.hs (modified) (4 diffs)

src/Pugs/Eval.hs

@@ -196 +196 @@
                 -- auto-enreference
                 esc $ VRef ref
-            case ref of
+            (case ref of
                 MkRef IPair{}   -> esc (VRef ref)
-                _               -> esc =<< readRef ref
+                _               -> esc =<< readRef ref) :: Eval ()
         -- LValue here
         when isCollectionRef $ esc (castV ref)
@@ -508 +508 @@
     sub   <- fromCodeExp body
     -- XXX this is wrong -- should use Array.next
-    elms  <- case av of
+    elms  <- (case av of
         VRef (MkRef sv@IScalar{})   -> return [sv]
-        VList xs                    -> return . (`map` xs) $ \x -> case x of
+        VList xs                    -> return . (`map` xs) $ \x -> ((case x of
             VRef (MkRef sv@IScalar{})   -> sv
-            _                           -> (IScalar x)
-        _                           -> join $ doArray av array_fetchElemAll
+            _                           -> (IScalar x)) :: IVar VScalar)
+        _                           -> join $ doArray av array_fetchElemAll) :: Eval [IVar VScalar]
     -- This makes "for @x { ... }" into "for @x -> $_ is rw {...}"
     let arity = length (subParams sub)
@@ -1151 +1151 @@
         | v     <- vals
         ]
+    forceThunk :: Val -> Eval Val
     forceThunk (VRef (MkRef (IThunk tv)))   = thunk_force tv
     forceThunk x                            = return x
@@ -1491 +1492 @@
                     --- not scalarRef! -- use the new "transparent IType" thing!
                     case showType (typeOfSigilVar var) of
-                        "Hash"  -> ($ v) . fix $ \(redo :: Val -> Eval Val) x -> case x of
+                        "Hash"  -> ($ v) . fix $ \(redo :: Val -> Eval Val) x -> (case x of
                             VRef (MkRef (IHash h)) -> return (VRef $ hashRef h) 
                             VRef ref@(MkRef IScalar{}) -> redo =<< readRef ref
-                            _ -> fmap (VRef . hashRef) (fromVal v :: Eval VHash)
-                        "Array" -> ($ v) . fix $ \(redo :: Val -> Eval Val) x -> case x of
+                            _ -> fmap (VRef . hashRef) (fromVal v :: Eval VHash)) :: Eval Val
+                        "Array" -> ($ v) . fix $ \(redo :: Val -> Eval Val) x -> (case x of
                             VRef (MkRef (IArray a)) -> return (VRef $ arrayRef a) 
                             VRef ref@(MkRef IScalar{}) -> redo =<< readRef ref
-                            _ -> fmap (VRef . arrayRef) (fromVal v :: Eval VArray)
-                        _       -> case v of
+                            _ -> fmap (VRef . arrayRef) (fromVal v :: Eval VArray)) :: Eval Val
+                        _       -> (case v of
                             VRef (MkRef IScalar{}) -> return (VRef $ scalarRef v) 
                             VRef _ -> return v -- XXX - preserving ref
-                            _ -> return (VRef $ scalarRef v) 
+                            _ -> return (VRef $ scalarRef v)) :: Eval Val
                 (False, False)  -> return v -- XXX reduce to val?
                 (False, True)   -> do