[get rid of needless and buggy module accumulation pass when building libraries, rely on standard module chasing code instead
John Meacham <john@repetae.net>**20070222062242] hunk ./FrontEnd/FrontEnd.hs 32
-parseFiles :: [String]      -- ^ List of files to read
-               -> [Module]  -- ^ List of modules to find
+parseFiles :: [Either Module String]      -- ^ List of files or modules to read
hunk ./FrontEnd/FrontEnd.hs 36
-parseFiles fs deps ifunc func = do
+parseFiles fs ifunc func = do
hunk ./FrontEnd/FrontEnd.hs 41
-    let xs = snub $ map Right fs ++ map Left deps
-        f accumHo ho [] = return (accumHo,ho)
-        f accumHo ho (x:xs) = do
-            (accumHo,ho') <- findModule accumHo x ifunc (doModules func)
-            f accumHo (ho `mappend` ho') xs
-    (initialHo,ho) <- f initialHo mempty  xs
+    (initialHo,ho) <- findModule initialHo fs ifunc (doModules func)
hunk ./Ho/Build.hs 109
-findModule :: CollectedHo                                  -- ^ Accumulated Ho
-              -> (Either Module String)           -- ^ Either a module or filename to find
+findModule :: CollectedHo                                           -- ^ Accumulated Ho
+              -> [Either Module String]                             -- ^ Either a module or filename to find
hunk ./Ho/Build.hs 113
-              -> IO (CollectedHo,Ho)                       -- ^ (Final accumulated ho,just the ho read to satisfy this command)
-findModule cho (Left m) ifunc _
-    | m `mmember` (hoExports . choHo $ cho) = return (cho,mempty)
+              -> IO (CollectedHo,Ho)                                -- ^ (Final accumulated ho,just the ho read to satisfy this command)
hunk ./Ho/Build.hs 115
-    let f (Left (Module m)) = (m,searchPaths m)
-        f (Right n) = (n,[(n,reverse $ 'o':'h':dropWhile (/= '.') (reverse n))])
-        (name,files) = f need
-    (readHo,ms) <- nextModule (fmap Just . hoModules . choHo $ cho) [] mempty [Right (name,files)]
+    let f (Left (Module m)) = Left (Module m)
+        f (Right n) = Right (n,[(n,reverse $ 'o':'h':dropWhile (/= '.') (reverse n))])
+    (readHo,ms) <- nextModule (fmap Just . hoModules . choHo $ cho) [] mempty (map f (snub need))
hunk ./Main.hs 131
-    (_,ho) <- parseFiles [] mods processInitialHo processDecls
+    (_,ho) <- parseFiles (map Left mods) processInitialHo processDecls
hunk ./Main.hs 140
-    processFilesModules [] [Module "Prelude"]
+    processFilesModules [Left (Module "Prelude")]
hunk ./Main.hs 143
-    Module m <- getModule m
-    processFilesModules [] [Module m]
-processFiles cs = do
-    (ms,fs) <- return $ splitEither $ map fileOrModule cs
-    processFilesModules fs ms
+    m <- getModule m
+    processFilesModules [Left m]
+processFiles cs = do processFilesModules (map fileOrModule cs)
hunk ./Main.hs 147
-processFilesModules fs ms = do
-    compileModEnv' =<< parseFiles fs ms processInitialHo processDecls
+processFilesModules fs = do
+    compileModEnv' =<< parseFiles fs processInitialHo processDecls