[replace Maybe inside Monads be ErrorMonad and catchError
martin.hofmann@uni-bamberg.de**20091217151048] hunk ./src/Igor2/Data/HypoSpace.hs 46
-initHSpace :: (MonadError e m) => CovrRule -> C m HSpace  
+initHSpace :: (MonadPlus m, MonadError e m) => CovrRule -> C m HSpace  
hunk ./src/Igor2/Data/HypoSpace.hs 49
-pushHypo :: (MonadError e m) => HSpace -> Hypo -> C m HSpace
+pushHypo :: (MonadPlus m, MonadError e m) => HSpace -> Hypo -> C m HSpace
hunk ./src/Igor2/Data/HypoSpace.hs 52
-pushHypos :: (MonadError e m) => [Hypo] -> HSpace -> C m HSpace
+pushHypos :: (MonadPlus m, MonadError e m) => [Hypo] -> HSpace -> C m HSpace
hunk ./src/Igor2/Data/HypoSpace.hs 73
-pushUnsafe :: (MonadError e m) => HSpace -> Hypo -> C m HSpace
+pushUnsafe :: (MonadPlus m, MonadError e m) => HSpace -> Hypo -> C m HSpace
hunk ./src/Igor2/Data/Hypotheses.hs 69
-hypo :: (MonadError e m) => [CovrRule] -> C m Hypo
+hypo :: (MonadPlus m, MonadError e m) => [CovrRule] -> C m Hypo
hunk ./src/Igor2/Data/Hypotheses.hs 98
-simplifiedBindings :: (MonadError e m) => Hypo -> C m (CallDep, [(Name,Rules)])
+simplifiedBindings :: (MonadPlus m, MonadError e m) => Hypo -> C m (CallDep, [(Name,Rules)])
hunk ./src/Igor2/Data/Hypotheses.hs 135
-developH ::  (MonadError e m) => 
+developH ::  (MonadPlus m, MonadError e m) => 
hunk ./src/Igor2/Data/Hypotheses.hs 174
-updateRating :: (MonadError e m) => Hypo -> C m Hypo
+updateRating :: (MonadPlus m, MonadError e m) => Hypo -> C m Hypo
hunk ./src/Igor2/Data/IgorMonad.hs 228
-    ios <- liftM (getAll n) getEvidence
-    evls <- lift . lift . lift . lift $ mapM ((matchEval e).crul) ios
-    return $ msum evls
+    ios <- liftM (getAll n) getEvidence    
+    r   <- (applyC $ matchEvals e $ map crul ios) :: (IM (Either String RHS))
+    return $ either (const Nothing) Just r
hunk ./src/Igor2/Data/Rateable.hs 34
-    rate :: (MonadError e m) => r -> C m RatingData
+    rate :: (MonadPlus m, MonadError e m) => r -> C m RatingData
hunk ./src/Igor2/Data/Rules.hs 206
-matchEval :: (MonadError e m) => LHS -> Rule -> C m (Maybe TExp)
-matchEval args r =  
-    (matchL args (lhs r) >>= return . Just . (flip apply (rhs r)))
-     `catchError` \_ -> return Nothing 
+matchEval :: (MonadPlus m, 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 209
-matchEvals :: (MonadError e m) => LHS -> [Rule] -> C m (Maybe TExp)
-matchEvals l rs = mapM (matchEval l) rs >>= return . listToMaybe . catMaybes 
+matchEvals :: (MonadPlus m, MonadError e m) => LHS -> [Rule] -> C m TExp
+matchEvals l rs = msum $ map (matchEval l) rs 
hunk ./src/Igor2/Data/Rules.hs 311
-replaceInAll :: (MonadError e m) => TExp -> TExp -> [(Name,Rules)] -> C m [(Name,Rules)]
+replaceInAll :: (MonadPlus m, MonadError e m) => TExp -> TExp -> [(Name,Rules)] -> C m [(Name,Rules)]
hunk ./src/Igor2/Data/Rules.hs 319
-replaceCall :: (MonadError e m) => Rule -> RHS -> C m RHS
+replaceCall :: (MonadPlus m, MonadError e m) => Rule -> RHS -> C m RHS
hunk ./src/Igor2/Data/Rules.hs 326
-    replaceCall' r t =  matchEval [t] r >>= maybe (repSubterms t) return
+    replaceCall' r t =  (matchEval [t] r) `catchError` \_ -> repSubterms t
hunk ./src/Igor2/RuleDevelopment/Cata.hs 26
-    llogNO  $ text "Check if 'cata' applies to: " <^> pretty cr
-    llogNO $ text "Try generic catamorphism"  
+    llogNO $ text "Check if 'cata' applies to: " <^> pretty cr    
hunk ./src/Igor2/RuleDevelopment/Cata.hs 28
-    gcr <- genCataArgIs cr >>= mapM (genericCata cr) >>= return . oneOnly . concat
+    gcr <- llogNO gmsg >> genCataArgIs cr >>= mapM (genericCata cr)
+           >>= return . oneOnly . concat
hunk ./src/Igor2/RuleDevelopment/Cata.hs 31
-      else do llogNO $ text "Try special catamorphism on lists"  
-              mapM (listCata cr) (lstCataArgIs cr) >>=
-               return . oneOnly . concat
-      
+      else llogNO smsg >> mapM (listCata cr) (lstCataArgIs cr)
+           >>= return . oneOnly . concat
+    
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 28
-    evi  <-  liftM (map crul) $ breakupM cr
-    mbios <- lift . lift . lift . lift $ (checkUniPropAndMkIOs i evi)
-    maybe (naiveMap i cr evi) (mkFoldCall  i cr) mbios
+    evi   <- breakupM cr
+    catchError (checkUniPropAndMkIOs i evi cr >>= mkFoldCall i cr) 
+               (\_ -> naiveMap i cr evi)
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 40
-naiveMap :: Int -> CovrRule -> [Rule] -> IM [(CovrRules,[Call])]
-naiveMap i cr evi = do
+naiveMap :: Int -> CovrRule -> [CovrRule] -> IM [(CovrRules,[Call])]
+naiveMap i cr evi' = do
+    let evi = map crul evi'
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 217
-{- | Check if the given IO examples fulfill the universal property of fold:
-      - they are defined on the empty list
-      - all IOs are closed
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 218
--}
-checkUniPropAndMkIOs :: (MonadError e m) => Int -> [Rule] -> C m (Maybe (Rule,[Rule]))
-checkUniPropAndMkIOs i evi = 
-    case definedOnNil i evi of
-        Just (r,rs) -> do ios <- mapM (abduceIO i evi) rs
-                          return $ case (sequence ios) of
-                                    Just rs' -> Just (r,rs')
-                                    Nothing   -> Nothing
-        Nothing -> return Nothing 
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 219
-{-| If the given IO exmaples are defined on for the empty list, a tuple 
+{-| If the given IO exmaples are defined on for the empty list, a tuple
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 222
-definedOnNil :: Int -> [Rule] -> Maybe (Rule,[Rule])
-definedOnNil i = maybeStripNil . partition (hasNilIn.(!!i).lhs)
+definedOnNil :: (Monad m) => Int -> [CovrRule] -> m (CovrRule,[CovrRule])
+definedOnNil i = maybeStripNil . partition (hasNilIn . (ithArg i) . crul)
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 225
-maybeStripNil :: ([Rule], [Rule]) -> Maybe (Rule,[Rule])
-maybeStripNil (l1, l2) =  listToMaybe l1 >>= return . flip (,) l2 
+maybeStripNil :: (Monad m) => ([CovrRule], [CovrRule]) -> m (CovrRule,[CovrRule])
+maybeStripNil (l1, l2) =  headM l1 >>= return . flip (,) l2 
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 272
-abduceIO :: (MonadError e m) => Int -> [Rule] -> Rule -> C m (Maybe Rule)
-abduceIO i evi r =
-    let temp = liftM ((,) (butIthArg i r)) $ headTail $ ithArg i r in 
-    case temp of 
-        (Just (as,(x,xs))) -> do mbxs'    <- matchEvals (as ++ [xs]) evi
-                                 case mbxs' of 
-                                    Just xs' -> let io = rule (as ++ [x,xs']) (rhs r) in
-                                                return $ if not . hasFreeVars $ io then Just io else Nothing
-                                    _owise -> return Nothing
-        _owise -> return Nothing
---         _owise     -> return Nothing         
+{- | Check if the given IO examples fulfill the universal property of fold:
+      - they are defined on the empty list
+      - all IOs are closed
+
+-}
+checkUniPropAndMkIOs :: Int -> [CovrRule] -> CovrRule -> IM (Rule,[Rule])
+checkUniPropAndMkIOs i evi cr = do
+    (r,rs) <- definedOnNil i evi
+    rs'    <- mapM (abduceIO i evi) rs 
+    return (crul r,rs')
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 283
-headTail :: TExp -> Maybe (TExp,TExp)
+       
+abduceIO :: Int -> [CovrRule] -> CovrRule -> IM Rule
+abduceIO i evi cr = (do
+    (x,xs) <- headTail carg
+    xs'    <- evalIO (name cr) (args ++ [xs]) >>= 
+               maybe (fail "Insufficient support in Examples") return
+    let io = rule (args ++ [x,xs']) (rhs . crul $  cr) 
+    if not . hasFreeVars $ io then return io else fail "Open vars in abduced examples!")
+    `catchError` \e -> fail $ "Insufficient suport in examples!" ++ (show e)
+    where
+    args = butIthArg i $ crul cr
+    carg = ithArg i $ crul cr
+    
+headTail :: (Monad m) => TExp -> m (TExp,TExp)
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 298
-headTail (TListE (x:xs) ty)          = Just (x, TListE xs ty)
+headTail (TListE (x:xs) ty)          = return  (x, TListE xs ty)
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 300
-    if isCons n then Just (l,r) else Nothing
+    if isCons n then return (l,r) else fail "headTail: No list!"
hunk ./src/Igor2/RuleDevelopment/ListCata.hs 303
-    in if isCons n then Just (x,foldTAppE o xs) else Nothing
-headTail _                           = Nothing
+    in if isCons n then return (x,foldTAppE o xs) else fail "headTail: No list!"
+headTail _                           = fail "headTail: No list!"
hunk ./src/Igor2/RuleDevelopment/Matching.hs 123
-        rside <- lift . lift . lift . lift $  mapM (matchEval.lhs $ cr) rs
-        rside' <- maybe (return Nothing) (evalIO n) (sequence rside)
+        rside <- (applyC $ mapM (matchEval.lhs $ cr) rs) :: (IM (Either String [TExp]))
+        rside' <- either (return  . (const Nothing)) (evalIO n) rside