[use throwError where possible
Helmut Grohne <grohne@cs.uni-bonn.de>**20140108091026
 Ignore-this: e06ab5b6869087360b7a19fc56a8c2c4
 Since the use of fail changed in past GHC releases, part of the code base now
 uses throwError instead. The biggest part is the introduction of an Error e
 requirement to many of the functions to be able to use throwError. As a side
 effect of this change, interactive igor2 no longer dies on a syntax error.
] hunk ./src/Igor2/Data/HypoSpace.hs 46
-initHSpace :: (MonadPlus m, MonadError e m) => CovrRule -> C m HSpace  
-initHSpace r = hypo [r] >>= return . (pushHypo emptyHSpace)    
+initHSpace :: (MonadPlus m, Error e, MonadError e m) => CovrRule -> C m HSpace
+initHSpace r = hypo [r] >>= return . pushHypo emptyHSpace
hunk ./src/Igor2/Data/Hypotheses.hs 69
-hypo :: (MonadPlus m, MonadError e m) => [CovrRule] -> C m Hypo
+hypo :: (MonadPlus m, Error e, MonadError e m) => [CovrRule] -> C m Hypo
hunk ./src/Igor2/Data/Hypotheses.hs 97
-simplifiedBindings :: (MonadPlus m, MonadError e m) => 
+simplifiedBindings :: (MonadPlus m, Error e, MonadError e m) =>
hunk ./src/Igor2/Data/Hypotheses.hs 141
-developH :: (MonadPlus m, MonadError e m) => 
+developH :: (MonadPlus m, Error e, MonadError e m) =>
hunk ./src/Igor2/Data/Hypotheses.hs 176
-updateRating :: (MonadPlus m, MonadError e m) => Hypo -> C m Hypo
+updateRating :: (MonadPlus m, Error e, MonadError e m) => Hypo -> C m Hypo
hunk ./src/Igor2/Data/Hypotheses.hs 232
-numberOfPartitions ::  (MonadError e m) => Hypo -> C m Int
+numberOfPartitions ::  (Error e, MonadError e m) => Hypo -> C m Int
hunk ./src/Igor2/Data/Hypotheses.hs 235
-numberOfClosedPartitions :: (MonadError e m) => Hypo -> C m Int
+numberOfClosedPartitions :: (Error e, MonadError e m) => Hypo -> C m Int
hunk ./src/Igor2/Data/Hypotheses.hs 239
-numberOfLeastPatterns :: (MonadError e m) => Rules -> C m Int
+numberOfLeastPatterns :: (Error e, MonadError e m) => Rules -> C m Int
hunk ./src/Igor2/Data/Hypotheses.hs 253
-heuristic :: (MonadPlus m, MonadError e m) => Hypo -> C m ([Float], Float)        
+heuristic :: (MonadPlus m, Error e, MonadError e m) => Hypo -> C m ([Float], Float)
hunk ./src/Igor2/Data/Rateable.hs 36
-    rate :: (MonadPlus m, MonadError e m) => r -> C m RatingData
+    rate :: (MonadPlus m, Error e, MonadError e m) => r -> C m RatingData
hunk ./src/Igor2/Data/Rules.hs 217
-matchEval :: (MonadPlus m, MonadError e m) => LHS -> Rule -> C m TExp
-matchEval args r =  matchL args (lhs r) >>= return . (flip apply (rhs r))
+matchEval :: (MonadPlus m, Error e, MonadError e m) => LHS -> Rule -> C m TExp
+matchEval args r =  matchL args (lhs r) >>= return . flip apply (rhs r)
hunk ./src/Igor2/Data/Rules.hs 220
-matchEvals :: (MonadPlus m, MonadError e m) => LHS -> [Rule] -> C m TExp
+matchEvals :: (MonadPlus m, Error e, MonadError e m) => LHS -> [Rule] -> C m TExp
hunk ./src/Igor2/Data/Rules.hs 223
-matchesLhs :: (MonadError e m) => Rule -> Rule -> C m (Subst TExp)
+matchesLhs :: (Error e, MonadError e m) => Rule -> Rule -> C m (Subst TExp)
hunk ./src/Igor2/Data/Rules.hs 226
-matchesRhs :: (MonadError e m) => Rule -> Rule -> C m (Subst TExp)
+matchesRhs :: (Error e, MonadError e m) => Rule -> Rule -> C m (Subst TExp)
hunk ./src/Igor2/Data/Rules.hs 229
-matchLhss :: (MonadError e m) => Rule -> Rule -> C m Bool
+matchLhss :: (Error e, MonadError e m) => Rule -> Rule -> C m Bool
hunk ./src/Igor2/Data/Rules.hs 232
-matchRhs :: (MonadError e m) => Rule -> Rule -> C m Bool
+matchRhs :: (Error e, MonadError e m) => Rule -> Rule -> C m Bool
hunk ./src/Igor2/Data/Rules.hs 235
-subsumeLhss :: (MonadError e m) => Rule -> Rule -> C m Bool
-subsumeLhss = flip matchLhss
-
-subsumeRhs :: (MonadError e m) => Rule -> Rule -> C m Bool
-subsumeRhs = flip matchRhs
-   
hunk ./src/Igor2/Data/Rules.hs 318
-replaceInAll :: (MonadPlus m, MonadError e m) => TExp -> TExp -> [(Name,Rules)] -> C m [(Name,Rules)]
+replaceInAll :: (MonadPlus m, Error e, MonadError e m) => TExp -> TExp -> [(Name,Rules)] -> C m [(Name,Rules)]
hunk ./src/Igor2/Data/Rules.hs 326
-replaceCall :: (MonadPlus m, MonadError e m) => Rule -> RHS -> C m RHS
+replaceCall :: (MonadPlus m, Error e, MonadError e m) => Rule -> RHS -> C m RHS
hunk ./src/Igor2/UI/UIStarter.hs 517
-parseCmdLine line = 
-    case parse pBatch "" line of
-        Right r -> return r
-        Left er -> fail (show er)
+parseCmdLine = either (Left . show) Right . parse pBatch ""
hunk ./src/Syntax/Builder.hs 169
-class ToTExp t     where toTExp   :: (MonadError e m) => Type -> t -> C m TExp
-class ToFunBind d  where toFunBind :: (MonadError e m) => Context -> d -> m [FunBind]
-class ToEquation d where toEquation :: (MonadError e m) => Type -> d -> C m Equation
+class ToTExp t     where toTExp   :: (Error e, MonadError e m) => Type -> t -> C m TExp
+class ToFunBind d  where toFunBind :: (Error e, MonadError e m) => Context -> d -> m [FunBind]
+class ToEquation d where toEquation :: (Error e, MonadError e m) => Type -> d -> C m Equation
hunk ./src/Syntax/Builder.hs 187
-             Nothing   -> fail $ "No type in Context for '" ++ (show n) ++"'"
-        | otherwise     = fail $ "Binding geroups inside a let ot where clause are not supported."
+             Nothing   -> throwError . strMsg $ "No type in Context for '" ++ show n ++"'"
+        | otherwise     = throwError . strMsg $ "Binding geroups inside a let ot where clause are not supported."
hunk ./src/Syntax/Builder.hs 221
-                ty <- getType n' >>= maybe (fail $ "Fun " ++ (show n') ++ " not in Context") (specialise t)
+                ty <- getType n' >>= maybe (throwError . strMsg $ "Fun " ++ show n' ++ " not in Context") (specialise t)
hunk ./src/Syntax/Builder.hs 227
-                ty <- getType n' >>= maybe (fail $ "Ctor " ++ (show n') ++ " not in Context") (specialise t)
+                ty <- getType n' >>= maybe (throwError . strMsg $ "Ctor " ++ show n' ++ " not in Context") (specialise t)
hunk ./src/Syntax/Builder.hs 236
-        ty <- getType n' >>= maybe (fail $ "Ctor " ++ (show n') ++ " not in Context") (specialise t)
+        ty <- getType n' >>= maybe (throwError . strMsg $ "Ctor " ++ show n' ++ " not in Context") (specialise t)
hunk ./src/Syntax/Builder.hs 242
-    toTExp _ e =  fail $ errorMsg "toTExp" e
+    toTExp _ e =  throwError . strMsg $ errorMsg "toTExp" e
hunk ./src/Syntax/Builder.hs 253
-        ty <- getType n' >>= maybe (fail $ "Ctor " ++ (show n') ++ " not in Context") (specialise t)
+        ty <- getType n' >>= maybe (throwError . strMsg $ "Ctor " ++ show n' ++ " not in Context") (specialise t)
hunk ./src/Syntax/Builder.hs 266
-        ty <- getType n' >>= maybe (fail $ "Ctor " ++ (show n') ++ " not in Context") (specialise t)
+        ty <- getType n' >>= maybe (throwError . strMsg $ "Ctor " ++ show n' ++ " not in Context") (specialise t)
hunk ./src/Syntax/Builder.hs 272
-    toTExp _ p = fail $ errorMsg "toTExp" p
+    toTExp _ p = throwError . strMsg $ errorMsg "toTExp" p
hunk ./src/Syntax/Builder.hs 276
-    toTExp _ s = fail $ errorMsg "toTExp" s
+    toTExp _ s = throwError . strMsg $ errorMsg "toTExp" s
hunk ./src/Syntax/Class/Antiunifier.hs 55
-    aunify :: (MonadError e m) => [t] -> AU m t t
+    aunify :: (Error e, MonadError e m) => [t] -> AU m t t
hunk ./src/Syntax/Class/Antiunifier.hs 57
-    lgg :: (MonadError e m, Pretty t) =>  [t] -> C m t
+    lgg :: (Error e, MonadError e m, Pretty t) =>  [t] -> C m t
hunk ./src/Syntax/Class/Antiunifier.hs 62
-lggL :: (Pretty t, AUnify t, MonadError e m) => [[t]] -> C m [t]
+lggL :: (Pretty t, AUnify t, Error e, MonadError e m) => [[t]] -> C m [t]
hunk ./src/Syntax/Class/Unifier.hs 44
-    match :: (MonadError e m) => t -> t -> C m (Subst t) 
+    match :: (Error e, MonadError e m) => t -> t -> C m (Subst t)
hunk ./src/Syntax/Class/Unifier.hs 46
-    matches :: (MonadError e m) => t -> t -> C m Bool
-    matches t1 t2 = ( match t1 t2 >>= return . (const True) )
+    matches :: (Error e, MonadError e m) => t -> t -> C m Bool
+    matches t1 t2 = (match t1 t2 >>= return . const True)
hunk ./src/Syntax/Class/Unifier.hs 50
-    matchL :: (MonadError e m) => [t] -> [t] -> C m (Subst t)
+    matchL :: (Error e, MonadError e m) => [t] -> [t] -> C m (Subst t)
hunk ./src/Syntax/Class/Unifier.hs 53
-    matchesL :: (MonadError e m) => [t] -> [t] -> C m Bool
-    matchesL t1 t2 = ( matchL t1 t2 >>= return . (const True) )
+    matchesL :: (Error e, MonadError e m) => [t] -> [t] -> C m Bool
+    matchesL t1 t2 = (matchL t1 t2 >>= return . const True)
hunk ./src/Syntax/Class/Unifier.hs 57
-    mgu ::  (MonadError e m) => t -> t -> C m (Subst t)
+    mgu ::  (Error e, MonadError e m) => t -> t -> C m (Subst t)
hunk ./src/Syntax/Class/Unifier.hs 59
-    mguL :: (MonadError e m) => [t] -> [t] -> C m (Subst t)
+    mguL :: (Error e, MonadError e m) => [t] -> [t] -> C m (Subst t)
hunk ./src/Syntax/Class/Unifier.hs 65
-    unify :: (MonadError e m) => t -> t -> C m t
-    unify t1 t2 = mgu t1 t2 >>= return . (flip apply t1)
+    unify :: (Error e, MonadError e m) => t -> t -> C m t
+    unify t1 t2 = mgu t1 t2 >>= return . flip apply t1
hunk ./src/Syntax/Specification.hs 59
-      then fail $ errmsg ls
+      then Left $ errmsg ls
hunk ./src/Syntax/UnifyExp.hs 56
-    | n `elem` (getVarNames t)           = fail "varBind: Occurs check failed!"
+    | n `elem` getVarNames t             = throwError . strMsg $ "varBind: Occurs check failed!"
hunk ./src/Syntax/UnifyExp.hs 58
-varBind _ _                              = fail "varBind: Cannot bind to non-variable term"   
+varBind _ _                              = throwError . strMsg $ "varBind: Cannot bind to non-variable term"
hunk ./src/Syntax/UnifyExp.hs 73
-bindVarAU :: (MonadError e m) => [TExp] -> AU m TExp TExp
-bindVarAU img =  getMap >>= (maybe (mkVar img) (return)) . (lookup img)
+bindVarAU :: (Error e, MonadError e m) => [TExp] -> AU m TExp TExp
+bindVarAU img =  getMap >>= maybe (mkVar img) return . lookup img
hunk ./src/Syntax/UnifyExp.hs 76
-mkVar :: (MonadError e m) => [TExp] -> AU m TExp TExp
+mkVar :: (Error e, MonadError e m) => [TExp] -> AU m TExp TExp
hunk ./src/Syntax/UnifyExp.hs 84
-{- *** gross hack ahead ***
- -
- - In base 4.3 the behaviour of fail (originally used here) changed. While
- - previously in a few Monads (notably Either) a failured created by fail could
- - be handled using catchError, this is no longer the case. Thus a failure
- - generated here passes by the catchError in the definition of matches. We
- - therefore need to use throwError here. Unfortunately we do not know Error e,
- - so there is no way to create a parameter to throwError. So instead we pass
- - an error value to throwError itself. In the normal case (catchError), the
- - throwError will be handled and its parameter remain unevaluated. Should it
- - ever go unhandled, the printing of the error will fail and the inner error
- - will be printed.
- -
- -}
-nomatch :: MonadError e m => String -> String -> m a
-nomatch l s = throwError . error $ "Expressions." ++ l ++ ": No Match! " ++ s
+nomatch :: (Error e, MonadError e m) => String -> String -> m a
+nomatch l s = throwError . strMsg $ "Expressions." ++ l ++ ": No Match! " ++ s
hunk ./src/Syntax/UnifyTy.hs 32
-specialise :: (MonadError e m) => Type -> Type -> C m Type
+specialise :: (Error e, MonadError e m) => Type -> Type -> C m Type
hunk ./src/Syntax/UnifyTy.hs 34
-    (mgu (last . unArrowT $ t2) t1 >>= return . (flip apply t2))
-     `catchError` \_ -> fail "Types not specialisable!"     
+    (mgu (last . unArrowT $ t2) t1 >>= return . flip apply t2)
+     `catchError` \_ -> throwError . strMsg $ "Types not specialisable!"
hunk ./src/Syntax/UnifyTy.hs 56
-    match t1 t2                      = fail $ "Type " ++ (show t1) ++
+    match t1 t2                      = throwError . strMsg $ "Type " ++ show t1 ++
hunk ./src/Syntax/UnifyTy.hs 75
-    mgu t1 t2                      = fail $ "Type " ++ (show t1) ++
-                                              " and type " ++ (show t2) ++ 
+    mgu t1 t2                      = throwError . strMsg $ "Type " ++ show t1 ++
+                                              " and type " ++ show t2 ++
hunk ./src/Syntax/UnifyTy.hs 84
-check :: (MonadError e m) => TySubst -> TyCxt -> C m ()
+check :: (Error e, MonadError e m) => TySubst -> TyCxt -> C m ()
hunk ./src/Syntax/UnifyTy.hs 92
-    failIfFalse False = fail $ "Substitution " ++ (show s) ++ 
-                               " not satisfieable in " ++ (show c)
+    failIfFalse False = throwError . strMsg $ "Substitution " ++ show s ++
+                               " not satisfieable in " ++ show c
hunk ./src/Syntax/UnifyTy.hs 101
-satisfies :: (MonadError e m) => Type -> Pred -> C m Bool
+satisfies :: (Error e, MonadError e m) => Type -> Pred -> C m Bool
hunk ./src/Syntax/UnifyTy.hs 114
-reduce :: (MonadError e m) => TyCxt -> C m TyCxt
+reduce :: (Error e, MonadError e m) => TyCxt -> C m TyCxt
hunk ./src/Syntax/UnifyTy.hs 117
-simplify :: (MonadError e m) => TyCxt -> C m TyCxt
+simplify :: (Error e, MonadError e m) => TyCxt -> C m TyCxt
hunk ./src/Syntax/UnifyTy.hs 124
-toHnfs :: (MonadError e m) => TyCxt -> C m TyCxt
+toHnfs :: (Error e, MonadError e m) => TyCxt -> C m TyCxt
hunk ./src/Syntax/UnifyTy.hs 127
-toHnf  :: (MonadError e m) => Pred -> C m TyCxt
+toHnf  :: (Error e, MonadError e m) => Pred -> C m TyCxt
hunk ./src/Syntax/UnifyTy.hs 130
-    | otherwise = byInst p >>= maybe (fail "context reduction") toHnfs
+    | otherwise = byInst p >>= maybe (throwError . strMsg $ "context reduction") toHnfs
hunk ./src/Syntax/UnifyTy.hs 143
-entails :: (MonadError e m) => TyCxt -> Pred -> C m Bool
+entails :: (Error e, MonadError e m) => TyCxt -> Pred -> C m Bool
hunk ./src/Syntax/UnifyTy.hs 157
-byInst :: (MonadError e m) => Pred -> C m (Maybe [Pred])
+byInst :: (Error e, MonadError e m) => Pred -> C m (Maybe [Pred])
hunk ./src/Syntax/UnifyTy.hs 163
-tryInst :: (MonadError e m) => Pred -> Type -> C m (Maybe [Pred])
+tryInst :: (Error e, MonadError e m) => Pred -> Type -> C m (Maybe [Pred])
hunk ./src/Syntax/UnifyTy.hs 183
-bindVar :: (MonadError e m) => [Type] -> AU m Type Type
-bindVar img =  getMap >>= (maybe (mkVar img) (return)) . (lookup img)
+bindVar :: (Error e, MonadError e m) => [Type] -> AU m Type Type
+bindVar img =  getMap >>= maybe (mkVar img) return . lookup img
hunk ./src/Syntax/UnifyTy.hs 186
-mkVar :: (MonadError e m) => [Type] -> AU m Type Type
+mkVar :: (Error e, MonadError e m) => [Type] -> AU m Type Type
hunk ./src/Syntax/UnifyTy.hs 194
-cmpCxt :: (MonadError e m) => String -> [Type] -> C m TyCxt
+cmpCxt :: (Error e, MonadError e m) => String -> [Type] -> C m TyCxt
hunk ./src/Syntax/UnifyTy.hs 200
-collectPreds :: (MonadError e m) => String -> [(Name,[Type])] -> Type -> C m [Pred] 
+collectPreds :: (Error e, MonadError e m) => String -> [(Name,[Type])] -> Type -> C m [Pred]
