cf65dc8 · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

on golang help sign in

Tidy up type signatures, use a better type for optional file paths.

cf65dc8Phil Freeman12 years ago

psc-docs/Main.hs+2−1

compare with golang

unifiedsplit

@@ -17,6 +17,7 @@ module Main where

17import Control.Applicative

18import Control.Monad

19import Control.Monad.Writer

20+import Control.Arrow (first)

20import Data.Function (on)

21import Data.Function (on)

21import Data.List

22import Data.List

22import Data.Version (showVersion)

23import Data.Version (showVersion)

@@ -29,7 +30,7 @@ import System.IO (stderr)

30docgen :: Bool -> [FilePath] -> IO ()

31docgen :: Bool -> [FilePath] -> IO ()

31docgen showHierarchy input = do

32docgen showHierarchy input = do

32− e <- P.parseModulesFromFiles <$> mapM parseFile (nub input)

33+ e <- P.parseModulesFromFiles <$> mapM (fmap (first Just) . parseFile) (nub input)

33 case e of

34 case e of

34 Left err -> do

35 Left err -> do

35 U.hPutStr stderr $ show err

36 U.hPutStr stderr $ show err

psc-make/Main.hs+11−6

@@ -12,7 +12,7 @@

12--

13-----------------------------------------------------------------------------

15−{-# LANGUAGE DataKinds, GeneralizedNewtypeDeriving, TupleSections #-}

15+{-# LANGUAGE DataKinds, GeneralizedNewtypeDeriving, TupleSections, RecordWildCards #-}

17module Main where

@@ -33,10 +33,15 @@ import qualified Language.PureScript as P

33import qualified Paths_purescript as Paths

34import qualified System.IO.UTF8 as U

36+data InputOptions = InputOptions

37+ { ioNoPrelude :: Bool

38+ , ioInputFiles :: [FilePath]

39+ }

40+

36−readInput :: Bool -> [FilePath] -> IO [(FilePath, String)]

41+readInput :: InputOptions -> IO [(Maybe FilePath, String)]

37−readInput excludePrelude input = do

42+readInput InputOptions{..} = do

38− content <- forM input $ \inputFile -> (inputFile, ) <$> U.readFile inputFile

43+ content <- forM ioInputFiles $ \inputFile -> (Just inputFile, ) <$> U.readFile inputFile

39− return $ bool (("<prelude>", P.prelude) :) id excludePrelude content

44+ return $ bool ((Nothing, P.prelude) :) id ioNoPrelude content

41newtype Make a = Make { unMake :: ErrorT String IO a } deriving (Functor, Applicative, Monad, MonadIO, MonadError String)

46newtype Make a = Make { unMake :: ErrorT String IO a } deriving (Functor, Applicative, Monad, MonadIO, MonadError String)

@@ -64,7 +69,7 @@ instance P.MonadMake Make where

65compile :: [FilePath] -> FilePath -> P.Options P.Make -> Bool -> IO ()

70compile :: [FilePath] -> FilePath -> P.Options P.Make -> Bool -> IO ()

66compile input outputDir opts usePrefix = do

71compile input outputDir opts usePrefix = do

67− modules <- P.parseModulesFromFiles <$> readInput (P.optionsNoPrelude opts) input

72+ modules <- P.parseModulesFromFiles <$> readInput (InputOptions (P.optionsNoPrelude opts) input)

68 case modules of

73 case modules of

69 Left err -> do

74 Left err -> do

70 U.print err

75 U.print err

psc/Main.hs+13−7

@@ -12,7 +12,7 @@

12--

13-----------------------------------------------------------------------------

15−{-# LANGUAGE DataKinds, GeneralizedNewtypeDeriving, TupleSections #-}

15+{-# LANGUAGE DataKinds, GeneralizedNewtypeDeriving, TupleSections, RecordWildCards #-}

17module Main where

@@ -32,15 +32,21 @@ import qualified Language.PureScript as P

32import qualified Paths_purescript as Paths

33import qualified System.IO.UTF8 as U

35−readInput :: Bool -> Bool -> [FilePath] -> IO [(FilePath, String)]

35+data InputOptions = InputOptions

36+ { ioNoPrelude :: Bool

37+ , ioUseStdIn :: Bool

38+ , ioInputFiles :: [FilePath]

39+ }

40+

41+readInput :: InputOptions -> IO [(Maybe FilePath, String)]

42+readInput InputOptions{..}

36−readInput _ True _ = return . ("<stdin>" ,) <$> getContents

43+ | ioUseStdIn = return . (Nothing ,) <$> getContents

37−readInput excludePrelude _ input = do

38− content <- forM input $ \inputFile -> (inputFile, ) <$> U.readFile inputFile

44+ | otherwise = do content <- forM ioInputFiles $ \inputFile -> (Just inputFile, ) <$> U.readFile inputFile

39− return $ bool (("<prelude>", P.prelude) :) id excludePrelude content

45+ return $ bool ((Nothing, P.prelude) :) id ioNoPrelude content

41compile :: P.Options P.Compile -> Bool -> [FilePath] -> Maybe FilePath -> Maybe FilePath -> Bool -> IO ()

47compile :: P.Options P.Compile -> Bool -> [FilePath] -> Maybe FilePath -> Maybe FilePath -> Bool -> IO ()

42compile opts stdin input output externs usePrefix = do

48compile opts stdin input output externs usePrefix = do

43− modules <- P.parseModulesFromFiles <$> readInput (P.optionsNoPrelude opts) stdin input

49+ modules <- P.parseModulesFromFiles <$> readInput (InputOptions (P.optionsNoPrelude opts) stdin input)

44 case modules of

50 case modules of

45 Left err -> do

51 Left err -> do

46 U.hPutStr stderr $ show err

52 U.hPutStr stderr $ show err

psci/Main.hs+14−14

@@ -66,7 +66,7 @@ import qualified Language.PureScript.Declarations as D

66data PSCiState = PSCiState

67 { psciImportedFilenames :: [FilePath]

68 , psciImportedModuleNames :: [P.ModuleName]

69− , psciLoadedModules :: [(FilePath, P.Module)]

69+ , psciLoadedModules :: [(Maybe FilePath, P.Module)]

70 , psciLetBindings :: [P.Expr -> P.Expr]

71 }

@@ -87,7 +87,7 @@ updateImports name st = st { psciImportedModuleNames = name : psciImportedModule

87-- |

88-- Updates the state to have more loaded files.

89--

90−updateModules :: [(FilePath, P.Module)] -> PSCiState -> PSCiState

90+updateModules :: [(Maybe FilePath, P.Module)] -> PSCiState -> PSCiState

91updateModules modules st = st { psciLoadedModules = psciLoadedModules st ++ modules }

93-- |

@@ -130,12 +130,12 @@ loadModule filename = either (Left . show) Right . P.runIndentParser filename P.

130-- |

131-- Load all modules, including the Prelude

132--

133−loadAllModules :: [FilePath] -> IO (Either ParseError [(FilePath, P.Module)])

133+loadAllModules :: [FilePath] -> IO (Either ParseError [(Maybe FilePath, P.Module)])

134loadAllModules files = do

135 filesAndContent <- forM files $ \filename -> do

136 content <- U.readFile filename

137− return (filename, content)

137+ return (Just filename, content)

138− return $ P.parseModulesFromFiles $ ("<prelude>", P.prelude) : filesAndContent

138+ return $ P.parseModulesFromFiles $ (Nothing, P.prelude) : filesAndContent

139

140

141-- |

@@ -303,7 +303,7 @@ handleDeclaration :: P.Expr -> PSCI ()

303handleDeclaration value = do

304 st <- PSCI $ lift get

305 let m = createTemporaryModule True st value

306− e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [("$PSCI.purs", m)]) []

306+ e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [(Nothing, m)]) []

307 case e of

308 Left err -> PSCI $ outputStrLn err

309 Right _ -> do

@@ -341,13 +341,13 @@ handleShowImportedModules = do

341--

342handleImport :: P.ModuleName -> PSCI ()

343handleImport moduleName = do

344− s <- liftM (updateImports moduleName) $ PSCI $ lift get

344+ st <- updateImports moduleName <$> PSCI (lift get)

345− let m = createTemporaryModuleForImports s

345+ let m = createTemporaryModuleForImports st

346− e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules s ++ [("$PSCI.purs", m)]) []

346+ e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [(Nothing, m)]) []

347 case e of

348 Left err -> PSCI $ outputStrLn err

349 Right _ -> do

350− PSCI $ lift $ put s

350+ PSCI $ lift $ put st

351 return ()

352

353-- |

@@ -357,7 +357,7 @@ handleTypeOf :: P.Expr -> PSCI ()

357handleTypeOf value = do

358 st <- PSCI $ lift get

359 let m = createTemporaryModule False st value

360− e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [("$PSCI.purs", m)]) []

360+ e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [(Nothing, m)]) []

361 case e of

362 Left err -> PSCI $ outputStrLn err

363 Right env' ->

@@ -407,7 +407,7 @@ handleKindOf typ = do

407 st <- PSCI $ lift get

408 let m = createTemporaryModuleForKind st typ

409 mName = P.ModuleName [P.ProperName "$PSCI"]

410− e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [("$PSCI.purs", m)]) []

410+ e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [(Nothing, m)]) []

411 case e of

412 Left err -> PSCI $ outputStrLn err

413 Right env' ->

@@ -453,7 +453,7 @@ handleCommand (LoadFile filePath) = do

453 m <- psciIO $ loadModule absPath

454 case m of

455 Left err -> PSCI $ outputStrLn err

456− Right mods -> PSCI . lift $ modify (updateModules (map ((,) absPath) mods))

456+ Right mods -> PSCI . lift $ modify (updateModules (map ((,) (Just absPath)) mods))

457 else

458 PSCI . outputStrLn $ "Couldn't locate: " ++ filePath

459handleCommand Reset = do

@@ -504,7 +504,7 @@ loop singleLineMode files = do

504 Left err -> putStrLn (show err) >> exitFailure

505 Right modules -> do

506 historyFilename <- getHistoryFilename

507− let settings = defaultSettings {historyFile = Just historyFilename}

507+ let settings = defaultSettings { historyFile = Just historyFilename }

508 flip evalStateT (PSCiState files defaultImports modules []) . runInputT (setComplete completion settings) $ do

509 outputStrLn prologueMessage

510 traverse_ (mapM_ (runPSCI . handleCommand)) config

src/Language/PureScript.hs+4−3

@@ -42,6 +42,7 @@ import Data.Time.Clock

42import Data.Function (on)

43import Data.Maybe (fromMaybe)

44import Data.FileEmbed (embedFile)

45+import Data.Traversable (traverse)

46import Control.Monad.Error

47import Control.Monad.Error

47import Control.Arrow ((&&&))

48import Control.Arrow ((&&&))

@@ -138,7 +139,7 @@ class MonadMake m where

138-- If timestamps have not changed, the externs file can be used to provide the module's types without

139-- If timestamps have not changed, the externs file can be used to provide the module's types without

139-- having to typecheck the module again.

140-- having to typecheck the module again.

140--

141--

141−make :: (Functor m, Applicative m, Monad m, MonadMake m) => FilePath -> Options Make -> [(FilePath, Module)] -> [String] -> m Environment

142+make :: (Functor m, Applicative m, Monad m, MonadMake m) => FilePath -> Options Make -> [(Maybe FilePath, Module)] -> [String] -> m Environment

142make outputDir opts ms prefix = do

143make outputDir opts ms prefix = do

143 let filePathMap = M.fromList (map (\(fp, Module mn _ _) -> (mn, fp)) ms)

144 let filePathMap = M.fromList (map (\(fp, Module mn _ _) -> (mn, fp)) ms)

144

145

@@ -149,11 +150,11 @@ make outputDir opts ms prefix = do

149

150

150 jsFile = outputDir </> filePath </> "index.js"

151 jsFile = outputDir </> filePath </> "index.js"

151 externsFile = outputDir </> filePath </> "externs.purs"

152 externsFile = outputDir </> filePath </> "externs.purs"

152− inputFile = fromMaybe (error "Input file is undefined in make") $ M.lookup moduleName' filePathMap

153+ inputFile = join $ M.lookup moduleName' filePathMap

153

154

154 jsTimestamp <- getTimestamp jsFile

155 jsTimestamp <- getTimestamp jsFile

155 externsTimestamp <- getTimestamp externsFile

156 externsTimestamp <- getTimestamp externsFile

156− inputTimestamp <- getTimestamp inputFile

157+ inputTimestamp <- join <$> traverse getTimestamp inputFile

157

158

158 return $ case (inputTimestamp, jsTimestamp, externsTimestamp) of

159 return $ case (inputTimestamp, jsTimestamp, externsTimestamp) of

159 (Just t1, Just t2, Just t3) | t1 < min t2 t3 -> s

160 (Just t1, Just t2, Just t3) | t1 < min t2 t3 -> s

src/Language/PureScript/Parser/Declarations.hs+9−5

@@ -232,13 +232,17 @@ parseModule = do

232 decls <- mark (P.many (same *> parseDeclaration))

233 return $ Module name decls exports

234

235+-- |

236+-- Parse a collection of modules

237+--

235−parseModulesFromFiles :: [(FilePath, String)] -> Either P.ParseError [(FilePath, Module)]

238+parseModulesFromFiles :: [(Maybe FilePath, String)] -> Either P.ParseError [(Maybe FilePath, Module)]

239+parseModulesFromFiles input =

236−parseModulesFromFiles input = fmap collect . forM input $ \(filename, content) -> do

240+ fmap collect . forM input $ \(filename, content) -> do

237− ms <- runIndentParser filename parseModules content

241+ ms <- runIndentParser (fromMaybe "" filename) parseModules content

238 return (filename, ms)

242 return (filename, ms)

239 where

243 where

240− collect :: [(FilePath, [Module])] -> [(FilePath, Module)]

244+ collect :: [(k, [v])] -> [(k, v)]

241− collect xs = [ (fp, m) | (fp, ms) <- xs, m <- ms ]

245+ collect vss = [ (k, v) | (k, vs) <- vss, v <- vs ]

242

246

243-- |

247-- |

244-- Parse a collection of modules

248-- Parse a collection of modules

tests/Main.hs+3−3

@@ -30,14 +30,14 @@ import System.Directory (getCurrentDirectory, getTemporaryDirectory, getDirector

30import Text.Parsec (ParseError)

31import qualified System.IO.UTF8 as U

33−readInput :: [FilePath] -> IO [(FilePath, String)]

33+readInput :: [FilePath] -> IO [(Maybe FilePath, String)]

34readInput inputFiles = forM inputFiles $ \inputFile -> do

35 text <- U.readFile inputFile

36− return (inputFile, text)

36+ return (Just inputFile, text)

38loadPrelude :: Either String (String, String, P.Environment)

39loadPrelude =

40− case P.parseModulesFromFiles [("<prelude>", P.prelude)] of

40+ case P.parseModulesFromFiles [(Nothing, P.prelude)] of

41 Left parseError -> Left (show parseError)

42 Right ms -> P.compile (P.defaultCompileOptions { P.optionsAdditional = P.CompileOptions "Tests" [] [] }) (map snd ms) []