[removed dead code and some warnings
martin.hofmann@uni-bamberg.de**20090623075608] hunk ./src/Data/IOData.hs 139
-
---moreGeneralSuperset :: Rules -> IOData -> Maybe Name
---moreGeneralSuperset rs iod =
---        listToMaybe $ map fst $ filter (( flip subsumesAll rs).snd)  (M.toList.evidence $ iod ) 
---       
+      
hunk ./src/Data/Rules.hs 6
-    RulePos(..), ruleSubtermAt, lhsSubtermAt, ruleVarPos, sameSymAt,
+    RulePos(..), ruleVarPos, sameSymAt,
hunk ./src/Data/Rules.hs 9
-    Rules, mkRules, rules, subrule, mkCallAt, subsumesAll,
-    
+    Rules, mkRules, rules, subrule, mkCallAt,     
hunk ./src/Data/Rules.hs 125
-replaceInLhs :: Rule -> RulePos -> TExp -> Rule
-replaceInLhs r (Arg i pos) t = 
-    let (pb,(p:pa)) = splitAt i (lhs r)
-    in r{lhs= concat [pb, [(substitute t pos p)],pa]}
+-- DEAD CODE
+--replaceInLhs :: Rule -> RulePos -> TExp -> Rule
+--replaceInLhs r (Arg i pos) t = 
+--    let (pb,(p:pa)) = splitAt i (lhs r)
+--    in r{lhs= concat [pb, [(substitute t pos p)],pa]}
+--
hunk ./src/Data/Rules.hs 145
-        
-ruleSubtermAt :: RulePos -> Rule -> Either (Maybe TExp) (Maybe TExp)
-ruleSubtermAt p@(Arg _ _) r = Left $ lhsSubtermAt p r
-ruleSubtermAt p@(Body _) r  = Right $ rhsSubtermAt p r
-
-lhsSubtermAt :: RulePos -> Rule -> Maybe TExp
-lhsSubtermAt (Arg i p) r = subtermAt ((lhs r) !! i) p
-lhsSubtermAt _ _ = error $ "Data.Rules.lhsSubtermAt : The given position is" ++ 
-                           "not a position on the left-hand side of the rule"  
hunk ./src/Data/Rules.hs 146
-rhsSubtermAt :: RulePos -> Rule -> Maybe TExp
-rhsSubtermAt (Body p) r  = subtermAt (rhs r) p
-rhsSubtermAt _ _ = error $ "Data.Rules.rhsSubtermAt : The given position is" ++ 
-                           "not a position on the right-hand side of the rule"
+-- DEAD CODE        
+--ruleSubtermAt :: RulePos -> Rule -> Either (Maybe TExp) (Maybe TExp)
+--ruleSubtermAt p@(Arg _ _) r = Left $ lhsSubtermAt p r
+--ruleSubtermAt p@(Body _) r  = Right $ rhsSubtermAt p r
+--
+-- DEAD CODE
+--lhsSubtermAt :: RulePos -> Rule -> Maybe TExp
+--lhsSubtermAt (Arg i p) r = subtermAt ((lhs r) !! i) p
+--lhsSubtermAt _ _ = error $ "Data.Rules.lhsSubtermAt : The given position is" ++ 
+--                           "not a position on the left-hand side of the rule"  
+--
+-- DEAD CODE
+--rhsSubtermAt :: RulePos -> Rule -> Maybe TExp
+--rhsSubtermAt (Body p) r  = subtermAt (rhs r) p
+--rhsSubtermAt _ _ = error $ "Data.Rules.rhsSubtermAt : The given position is" ++ 
+--                           "not a position on the right-hand side of the rule"
hunk ./src/Data/Rules.hs 179
-        (left,right)<-  antiunify2 tlhss rhss id
-        return $ rule left right
+        (r:l) <- mapM antiunify (rhss:tlhss)
+--        (left,right)<-  antiunify2 tlhss rhss id
+        return $ rule l r
hunk ./src/Data/Rules.hs 183
-matchRules :: Rule -> Rule -> LM Bool
-matchRules (R l1 r1) (R l2 r2) = matches2 (l1,r1) (l2,r2) id
+-- DEAD CODE
+--matchRules :: Rule -> Rule -> LM Bool
+--matchRules (R l1 r1) (R l2 r2) = matches2 (l1,r1) (l2,r2) id
hunk ./src/Data/Rules.hs 187
-   
-isMoreSpecific :: Rule -> Rule -> Bool
-isMoreSpecific a b = (&&) (matchLhss a b) (matchRhs a b)
-
-isMoreGeneral :: Rule -> Rule -> Bool
-isMoreGeneral = flip isMoreSpecific
+-- DEAD CODE
+--isMoreSpecific :: Rule -> Rule -> Bool
+--isMoreSpecific a b = (&&) (matchLhss a b) (matchRhs a b)
+--
+-- DEAD CODE
+--isMoreGeneral :: Rule -> Rule -> Bool
+--isMoreGeneral = flip isMoreSpecific
hunk ./src/Data/Rules.hs 368
-subsumesAll :: Rules -> Rules -> Bool
-subsumesAll r1 r2 =  all (anySubsumes r1) (S.toAscList r2) 
-    
-anySubsumes :: Rules -> Rule -> Bool
-anySubsumes rs r = 
-        any (isMoreSpecific r) (S.toAscList rs)
+-- DEAD CODE
+--subsumesAll :: Rules -> Rules -> Bool
+--subsumesAll r1 r2 =  all (anySubsumes r1) (S.toAscList r2) 
+--    
+-- DEAD CODE
+--anySubsumes :: Rules -> Rule -> Bool
+--anySubsumes rs r = 
+--        any (isMoreSpecific r) (S.toAscList rs)
hunk ./src/Syntax/Antiunifier.hs 10
-        antiunifyWithMap, -- ::  (Antiunifiable k v t) => (VarMap k v) -> [t] -> LM t
-        antiunify2,        -- :: (Antiunifiable k v t') => [[t]] -> [t'] -> LM ([t],t')
+--        antiunifyWithMap, -- ::  (Antiunifiable k v t) => (VarMap k v) -> [t] -> LM t
+--        antiunify2,        -- :: (Antiunifiable k v t') => [[t]] -> [t'] -> LM ([t],t')
hunk ./src/Syntax/Antiunifier.hs 84
-   
-    -- | Same as 'antiunify' but uses a 'VarMap' as initial state
-    antiunifyWithMap ::  (Antiunifiable t) => (VarMap t) -> [t] -> LM t
-    antiunifyWithMap  = (\m t -> evalAU (aunify t) m)
-    
-    {- | Convenience function to antiunify different kind of terms, but keeping 
-         track of the VarMap. @antiunify2 t1 t2@ corresponds approcimately to 
-         @liftM2 (,) (mapM antiunify t1) (antiunify t2)@, where the latter 
-         antiunify uses the VarMap of the further. 
-         This is needed to antiunify all patterns on the lhs and the rhs of 
-         multiple rules.
-    -}
-    antiunify2        :: (Ord t', Antiunifiable t', Antiunifiable t) => [[t]] -> [t'] -> (t -> t') -> LM ([t],t')
-    antiunify2 ts ts' trans = do
-            (ait,varmap) <- runAU ((mapM aunify) ts) M.empty
-            ait'         <- antiunifyWithMap (M.mapKeys (map trans) varmap) ts'
-            return (ait,ait')   
-    
---    -- | Given a term 't' and a Name 'n', returns a variable of type 'v' with name 'n'
---    --   The first argument is moe or less to dissolve the functional 
---    --   dependencies.
---    mkVar            :: t -> Name -> t
-    
+        
hunk ./src/Syntax/Antiunifier.hs 89
+-- DEAD CODE       
+--    -- | Same as 'antiunify' but uses a 'VarMap' as initial state
+--    antiunifyWithMap ::  (Antiunifiable t, Monad m) => (VarMap t) -> [t] -> m t
+--    antiunifyWithMap  = (\m t -> evalAU (aunify t) m)
+    
+-- DEAD CODE    
+--    {- | Convenience function to antiunify different kind of terms, but keeping 
+--         track of the VarMap. @antiunify2 t1 t2@ corresponds approcimately to 
+--         @liftM2 (,) (mapM antiunify t1) (antiunify t2)@, where the latter 
+--         antiunify uses the VarMap of the further. 
+--         This is needed to antiunify all patterns on the lhs and the rhs of 
+--         multiple rules.
+--    -}
+--    antiunify2        :: (Ord t', Antiunifiable t', Antiunifiable t, Monad m) 
+--                      => [[t]] -> [t'] -> (t -> t') -> m ([t],t')
+--    antiunify2 ts ts' trans = do
+--            (ait,varmap) <- runAU ((mapM aunify) ts) M.empty
+--            ait'         <- antiunifyWithMap (M.mapKeys (map trans) varmap) ts'
+--            return (ait,ait')   
hunk ./src/Syntax/Patterns.hs 127
+    
+    isWild _ = False
hunk ./src/Syntax/Patterns.hs 459
+    isWild _ = False
+    
hunk ./src/Syntax/Types.hs 181
+    
+    isWild _ = False
hunk ./src/Syntax/Unifier.hs 12
-    mgu2, matchesWithSubs2, matches2,
+    
+    zipPairsWithM, 
hunk ./src/Syntax/Unifier.hs 202
-{- | Convenience function to unify different kind of terms, but keeping 
-     track of the Substitution. @unify2 t1 t2@ corresponds approximately to 
-     @liftM2 (,) (mapM unify t1) (unify t2)@, where the latter 
-     unify uses the Substitution of the further. 
-     This is needed to unify all patterns on the lhs and the rhs of 
-     multiple rules.
--}
-mgu2        :: (Ord t', Unifiable t', Unifiable t) => ([t],t') -> ([t],t') -> (t -> t') -> LM (Substitution t')
-mgu2 (t1,t1') (t2,t2') trans = do
-        subs  <- execStateT (unifyLs t1 t2) []
-        subs' <- execStateT (unify t1' t2') (transSubs trans subs)
-        return subs' 
-        where
-        transSubs f =  map (\(a,b) -> on (,) f a b)  
-        
-matchesWithSubs2 :: (Ord t', Unifiable t', Unifiable t) => ([t],t') -> ([t],t') -> (t -> t') -> LM (Substitution t')
-matchesWithSubs2 (t1,t1') (t2,t2') trans = do
-        subs  <- execStateT (matchLs t1 t2) []
-        subs' <- execStateT (match t1' t2') (transSubs trans subs)
-        return subs' 
-        where
-        transSubs f =  map (\(a,b) -> on (,) f a b)
-          
-matches2 t1 t2 f = do{matchesWithSubs2 t1 t2 f >> return True} 
-                         `catchError` (const.return $ False)
+-- DEAD CODE 
+--{- | Convenience function to unify different kind of terms, but keeping 
+--     track of the Substitution. @unify2 t1 t2@ corresponds approximately to 
+--     @liftM2 (,) (mapM unify t1) (unify t2)@, where the latter 
+--     unify uses the Substitution of the further. 
+--     This is needed to unify all patterns on the lhs and the rhs of 
+--     multiple rules.
+---}
+--mgu2        :: (Ord t', Unifiable t', Unifiable t) => ([t],t') -> ([t],t') -> (t -> t') -> LM (Substitution t')
+--mgu2 (t1,t1') (t2,t2') trans =
+--        execStateT (unifyLs t1 t2) [] >>= 
+--        (execStateT $ unify t1' t2') . (transSubs trans)
+--        where
+--        transSubs f =  map $ uncurry (on (,) f)
+--        
+-- DEAD CODE
+--matchesWithSubs2 :: (Ord t', Unifiable t', Unifiable t) => ([t],t') -> ([t],t') -> (t -> t') -> LM (Substitution t')
+--matchesWithSubs2 (t1,t1') (t2,t2') trans = do
+--        subs  <- execStateT (matchLs t1 t2) []
+--        subs' <- execStateT (match t1' t2') (transSubs trans subs)
+--        return subs' 
+--        where
+--        transSubs f =  map (\(a,b) -> on (,) f a b)
+--          
+-- DEAD CODE
+--matches2 t1 t2 f = do{matchesWithSubs2 t1 t2 f >> return True} 
+--                         `catchError` (const.return $ False)
+