[Reuse closed lggs in mkIndirectCall and eliminate constant functions there
tobias@goedderz.info**20150312131506
 Ignore-this: 48be319d8052c1bab274e0312540d85c
] hunk ./regression_tests/subfunctionwildcard.out 28
-             subfunctionwildcard in 44     loops
+             subfunctionwildcard in 14     loops
hunk ./src/Igor2/RuleDevelopment/Matching.hs 130
-bestMatchings :: Context -> [[(Ordering, ArgList Rule)]] -> [(Ordering, ArgList FunList)]
+bestMatchings :: Context -> [[(Ordering, ArgList Rule)]] -> [(Ordering, ArgList (Either FunList TExp))]
hunk ./src/Igor2/RuleDevelopment/Matching.hs 137
-    TODO: Use ArgList (Either FunList Rule) in the return value, also to
-    optimize mkIndirectCall to avoid introducing constant functions.
-
hunk ./src/Igor2/RuleDevelopment/Matching.hs 141
-bestMatchingsBnb :: Context -> [[(Ordering, ArgList Rule)]] -> [(Ordering, ArgList FunList)]
+bestMatchingsBnb :: Context -> [[(Ordering, ArgList Rule)]] -> [(Ordering, ArgList (Either FunList TExp))]
hunk ./src/Igor2/RuleDevelopment/Matching.hs 178
+        saveClosedLggs :: ArgList FunList -> ArgList Rule -> ArgList (Either FunList TExp)
+        saveClosedLggs = zipWith (\ios lgg -> if Rules.isClosed lgg then Right (rhs lgg) else Left ios)
+
hunk ./src/Igor2/RuleDevelopment/Matching.hs 183
-    in map (\(BnbNode hist _ []) -> hist) solutions
+    in map (\(BnbNode (ord, rules) lggs []) -> (ord, saveClosedLggs rules lggs)) solutions
hunk ./src/Igor2/RuleDevelopment/Matching.hs 280
-mkIndirectCall :: CovrRule -> Name -> (Ordering, ArgList FunList) -> IM (CovrRules,[Call])
+mapBothM :: Monad m => (a -> m a') -> (b -> m b') -> Either a b -> m (Either a' b')
+mapBothM f _ (Left x)  = liftM Left (f x)
+mapBothM _ f (Right x) = liftM Right (f x)
+
+mapLeftM :: Monad m => (a -> m a') -> Either a b -> m (Either a' b)
+mapLeftM f (Left x)  = liftM Left (f x)
+mapLeftM _ (Right x) = return (Right x)
+
+leftToMaybe :: Either a b -> Maybe a
+leftToMaybe (Left x) = Just x
+leftToMaybe _        = Nothing
+
+catLefts :: [Either a b] -> [a]
+catLefts  = catMaybes . map leftToMaybe
+
+mkIndirectCall :: CovrRule -> Name -> (Ordering, ArgList (Either FunList TExp)) -> IM (CovrRules, [Call])
hunk ./src/Igor2/RuleDevelopment/Matching.hs 300
-    subfns        <- mapM (addIO . rules) subargsio
-    let subftys   = map (typeOf . rhs . head) subargsio
-    let subcalls  = map (\(n, ty) -> mkCall n ty (lhs $ crul cr)) (zip subfns subftys)
+    -- a subfn is either the name of a newly added function, or a closed term
+    subfns        <- mapM (mapLeftM (addIO . rules)) subargsio :: IM [Either Name TExp]
+    let subftys   = map (typeOf . either (rhs . head) id) subargsio
+    let subcalls  = map (\(r, ty) -> either (\n -> mkCall n ty (lhs $ crul cr)) id r) (zip subfns subftys)
hunk ./src/Igor2/RuleDevelopment/Matching.hs 305
-    subinis       <- mapM coverAll subfns
-    let call      = ((name cr), tgtn, fst ios)              -- call to target
-    let calls     = map (\n -> (tgtn, n, EQ)) subfns        -- auxiliary calls
+    subinis       <- mapM coverAll $ catLefts subfns
+    let call      = ((name cr), tgtn, fst ios)                  -- call to target
+    let calls     = map (\n -> (tgtn, n, EQ)) $ catLefts subfns -- auxiliary calls
hunk ./tests/ack.out 28
-             ack          in 257     loops
+             ack          in 238     loops
hunk ./tests/ack.out 34
-ack (S a0) a1 = ack (fun4 (S a0) a1) (fun5 (S a0) a1)
-fun4 (S a0) _ = a0
-fun5 (S _) (Z) = S Z
-fun5 (S a0) (S a1) = ack (fun834 (S a0) (S a1)) (fun835 (S a0) (S a1))
-fun834 (S a0) (S _) = S a0
-fun835 (S _) (S a1) = a1
+ack (S a0) a1 = ack a0 (fun3 (S a0) a1)
+fun3 (S _) (Z) = S Z
+fun3 (S a0) (S a1) = ack (S a0) a1
hunk ./tests/add.out 28
-             add          in 6     loops
+             add          in 14     loops
hunk ./tests/appenD.out 28
-             appenD       in 3     loops
+             appenD       in 4     loops
hunk ./tests/droP.out 34
-droP (S a0) a1 = droP (fun13 (S a0) a1) (fun14 (S a0) a1)
-fun13 (S a0) _ = a0
-fun14 (S _) [] = []
-fun14 (S _) (_ : a2) = a2
+droP (S a0) a1 = droP a0 (fun7 (S a0) a1)
+fun7 (S _) [] = []
+fun7 (S _) (_ : a2) = a2
hunk ./tests/member.out 35
-member 1 [2] = []
+member 1 (2 : a0) = a0
hunk ./tests/member.out 38
-member 1 (_ : (_ : _)) = [1]
+member 1 [3, 2, 1] = [1]
hunk ./tests/member.out 57
-member 1 (2 : a0) = a0
+member 1 [2] = []
hunk ./tests/member.out 60
-member 1 [3, 2, 1] = [1]
+member 1 (_ : (_ : _)) = [1]
hunk ./tests/weave.out 28
-             weave        in 3340     loops
+             weave        in 3632     loops
hunk ./tests/weave.out 35
-weave (a0 : (a1 : a2)) a3 = a0 : fun12874 (a0 : (a1 : a2)) a3
-fun12874 (a0 : (a1 : a2)) a3 = weave (fun12884 (a0 : (a1 : a2)) a3) (fun12885 (a0 : (a1 : a2)) a3)
-fun12884 (_ : (_ : _)) a3 = a3
-fun12885 (_ : (a1 : a2)) _ = a1 : a2
+weave (a0 : (a1 : a2)) a3 = a0 : fun7386 (a0 : (a1 : a2)) a3
+fun7386 (_ : (a1 : a2)) a3 = weave a3 (a1 : a2)