Make unqualified imports explicit

Author: jrp2014

Build.hs

@@ -3,7 +3,15 @@ module Main where
 
 import Prelude
 import Development.Shake
-import Development.Shake.FilePath
+ ( cmd,
+ shakeArgs,
+ shakeOptions,
+ getDirectoryFiles,
+ (%>),
+ need,
+ phony,
+ want )
+import Development.Shake.FilePath ( (-<.>), (</>), dropDirectory1 )
 
 main :: IO ()
 main = shakeArgs shakeOptions $ do

src/Cli.hs

@@ -2,11 +2,25 @@ module Cli (
  cliIface
 ) where
 
-import Eval -- evalFile :: T.Text -> IO ()
-import Repl -- Repl.mainLoop :: IO ()
-import System.Directory
-import Data.Text.IO as TIO
+import Eval ( evalFile ) -- evalFile :: T.Text -> IO ()
+import Repl ( mainLoop ) -- Repl.mainLoop :: IO ()
+import System.Directory ( doesFileExist )
+import Data.Text.IO as TIO ( readFile, putStrLn )
 import Options.Applicative
+ ( helper,
+ execParser,
+ strOption,
+ short,
+ progDesc,
+ metavar,
+ long,
+ info,
+ help,
+ header,
+ fullDesc,
+ flag',
+ Alternative((<|>)),
+ Parser )
 
 -- SOURCES
 --http://book.realworldhaskell.org/read/io.html

src/Eval.hs

@@ -15,19 +15,29 @@ module Eval (
  getFileContents
 ) where
 
-import Prim
-import Parser
+import Prim ( primEnv, unop )
+import Parser ( readExpr, readExprFile )
 import LispVal
+ ( LispException(Default, PError, UnboundVar, TypeMismatch,
+ BadSpecialForm, NotFunction),
+ IFunc(IFunc),
+ LispVal(..),
+ Eval(unEval),
+ EnvCtx(..),
+ showVal )
 
 import Data.Map as Map
+ ( empty, fromList, insert, lookup, partition, toList, union, Map )
 import qualified Data.Text as T
 import qualified Data.Text.IO as TIO
-import System.Directory
+import System.Directory ( doesFileExist )
 
-import Text.Parsec
+import Text.Parsec ( ParseError )
 
 import Control.Monad.Reader
+ ( MonadIO(liftIO), MonadReader(local, ask), ReaderT(runReaderT) )
 import Control.Exception
+ ( try, throw, Exception(fromException), SomeException )
 
 funcEnv :: Map.Map T.Text LispVal
 funcEnv = Map.fromList $ primEnv

src/LispVal.hs

@@ -14,8 +14,9 @@ import Data.Typeable (Typeable)
 import qualified Data.Text as T
 import qualified Data.Map as Map
 
-import Control.Exception
+import Control.Exception ( Exception )
 import Control.Monad.Reader
+ ( MonadIO, MonadReader, ReaderT(ReaderT) )
 
 type ValCtx = Map.Map T.Text LispVal
 type FnCtx = Map.Map T.Text LispVal

src/Parser.hs

@@ -5,10 +5,26 @@ module Parser (
  readExprFile
 ) where
 
-import LispVal
+import LispVal ( LispVal(List, Bool, Nil, Number, String, Atom) )
 
 import Text.Parsec
-import Text.Parsec.Text
+ ( char,
+ digit,
+ hexDigit,
+ letter,
+ octDigit,
+ oneOf,
+ string,
+ eof,
+ many1,
+ sepBy,
+ (<?>),
+ (<|>),
+ parse,
+ try,
+ ParseError,
+ SourceName )
+import Text.Parsec.Text ( Parser )
 import qualified Text.Parsec.Token as Tok
 import qualified Text.Parsec.Language as Lang
 

src/Prim.hs

@@ -3,15 +3,20 @@
 module Prim where
 
 import LispVal
-
-import Data.Text as T
-import Data.Text.IO as TIO
-import System.Directory
+ ( LispException(NumArgs, IOError, TypeMismatch, ExpectedList),
+ IFunc(IFunc),
+ LispVal(Atom, Fun, Number, String, Bool, Nil, List),
+ Eval )
+
+import Data.Text as T ( Text, concat, pack, unpack )
+import Data.Text.IO as TIO ( hGetContents, hPutStr )
+import System.Directory ( doesFileExist )
 import System.IO
-import Network.HTTP
+ ( Handle, hIsWritable, withFile, IOMode(WriteMode, ReadMode) )
+import Network.HTTP ( getRequest, getResponseBody, simpleHTTP )
 
-import Control.Monad.Except
-import Control.Exception hiding (handle)
+import Control.Monad.Except ( foldM, MonadIO(liftIO) )
+import Control.Exception ( throw )
 
 type Prim = [(T.Text, LispVal)]
 type Unary = LispVal -> Eval LispVal

src/Repl.hs

@@ -4,11 +4,12 @@ module Repl (
  mainLoop,
 ) where
 
-import Eval
-import Data.Text as T
+import Eval ( safeExec, runParseTest, evalText )
+import Data.Text as T ( pack )
 
-import Control.Monad.Trans
+import Control.Monad.Trans ( MonadIO(liftIO) )
 import System.Console.Haskeline
+ ( defaultSettings, getInputLine, outputStrLn, runInputT, InputT )
 
 type Repl a = InputT IO a
 

test-hs/Golden/Main.hs

@@ -1,13 +1,18 @@
 {-# LANGUAGE OverloadedStrings #-}
 module Main (main) where
 
-import LispVal
+import LispVal ( LispVal )
 import Eval
+ ( basicEnv,
+ getFileContents,
+ runASTinEnv,
+ safeExec,
+ textToEvalForm )
 
 import qualified Data.Text as T
 
-import Test.Tasty
-import Test.Tasty.Golden
+import Test.Tasty ( defaultMain, testGroup, TestName, TestTree )
+import Test.Tasty.Golden ( goldenVsString )
 import qualified Data.ByteString.Lazy.Char8 as C
 import Data.Functor ((<&>))
 

test-hs/Spec/Main.hs

@@ -1,14 +1,19 @@
 {-# LANGUAGE OverloadedStrings #-}
 module Main (main) where
 
-import LispVal
-import Parser
+import LispVal ( LispVal(String, Nil, Atom, List, Bool, Number) )
+import Parser ( readExpr )
 import Eval
+ ( basicEnv,
+ fileToEvalForm,
+ getFileContents,
+ runASTinEnv,
+ textToEvalForm )
 
 import qualified Data.Text as T
 
-import Test.Hspec
-import System.IO.Unsafe
+import Test.Hspec ( hspec, describe, it, shouldBe, SpecWith )
+import System.IO.Unsafe ( unsafePerformIO )
 
 
 main :: IO ()