restructure the project

eval-expr/Main.hs → app/eval-expr/Main.hs

@@ -1,5 +1,5 @@
-import EvalExpr.Expression
-import Parser
+import Expression (eval, parseExpression)
+import Parser (Parser (..))
 
 main :: IO ()
 main = interact (unlines . fmap interpret . lines)

minihasklisp/Main.hs → app/minihasklisp/Main.hs

@@ -1,10 +1,16 @@
 import Control.Monad.IO.Class (liftIO)
-import Data.Either
-import Data.Maybe
-import MiniHaskLisp.Eval
-import MiniHaskLisp.ParseAndEval
-import System.Console.Haskeline
-import System.Environment
+import Data.Either (fromRight)
+import Data.Maybe (isNothing)
+import Eval (Env)
+import ParseAndEval (Result, parseAndEval, renderResult)
+import System.Console.Haskeline (
+    InputT,
+    defaultSettings,
+    getInputLine,
+    outputStrLn,
+    runInputT,
+ )
+import System.Environment (getArgs, getProgName)
 
 data Options = Options
     { opFile :: Maybe String

minihasklisp.cabal

@@ -9,6 +9,7 @@ common defaults
   default-extensions:
     OverloadedStrings
     ScopedTypeVariables
+    TupleSections
   ghc-options:
     -Wall
     -Wcompat
@@ -19,42 +20,77 @@ common defaults
     -Wredundant-constraints
   build-depends: base
 
-library
+-- Parser library
+
+library parser-lib
   import: defaults
-  exposed-modules:
-    EvalExpr.Expression
-    EvalExpr.JSONParser
-    EvalExpr.UrlParser
-    MiniHaskLisp.Eval
-    MiniHaskLisp.ParseAndEval
-    MiniHaskLisp.SExpr
-    Parser
-  hs-source-dirs: src
+  exposed-modules: Parser
+  hs-source-dirs: src/parser
+
+test-suite parser-spec
+  import: defaults
+  type: exitcode-stdio-1.0
+  main-is: Spec.hs
+  other-modules: ParserSpec
+  hs-source-dirs: test/parser
+  build-depends:
+    hspec,
+    parser-lib
+
+-- eval-expr project
+
+library eval-expr-lib
+  import: defaults
+  exposed-modules: Expression
+  hs-source-dirs: src/eval-expr
+  build-depends: parser-lib
 
 executable eval-expr
   import: defaults
   main-is: Main.hs
-  hs-source-dirs: eval-expr
-  build-depends: minihasklisp
+  hs-source-dirs: app/eval-expr
+  build-depends:
+    eval-expr-lib,
+    parser-lib
+
+test-suite eval-expr-spec
+  import: defaults
+  type: exitcode-stdio-1.0
+  main-is: Spec.hs
+  other-modules: ExpressionSpec
+  hs-source-dirs: test/eval-expr
+  build-depends:
+    hspec,
+    eval-expr-lib,
+    parser-lib
+
+-- minihasklisp project
+
+library minihasklisp-lib
+  import: defaults
+  exposed-modules:
+    Eval
+    ParseAndEval
+    SExpr
+  hs-source-dirs: src/minihasklisp
+  build-depends: parser-lib
 
 executable minihasklisp
   import: defaults
   main-is: Main.hs
-  hs-source-dirs: minihasklisp
+  hs-source-dirs: app/minihasklisp
   build-depends:
     haskeline,
-    minihasklisp
+    minihasklisp-lib
 
-test-suite spec
+test-suite minihasklisp-spec
   import: defaults
   type: exitcode-stdio-1.0
   main-is: Spec.hs
-  other-modules:
-    ExpressionSpec
-    ParserSpec
-    SExprSpec
-  hs-source-dirs:
-    test
+  other-modules: SExprSpec
+  hs-source-dirs: test/minihasklisp
   build-depends:
     hspec,
-    minihasklisp
+    minihasklisp-lib,
+    parser-lib
+

src/EvalExpr/Expression.hs → src/eval-expr/Expression.hs

@@ -1,7 +1,13 @@
-module EvalExpr.Expression where
+module Expression (
+    Expression (..),
+    Operator (..),
+    parseExpression,
+    parseOperator,
+    eval,
+) where
 
 import Control.Applicative ((<|>))
-import Parser
+import Parser (Parser (..), parseChar, parseDouble, parseWhitespaces)
 
 data Operator = Plus | Minus | Product | Divide | Power
     deriving (Eq, Show)
@@ -16,16 +22,17 @@ parseExpression = withParenOrNot (parseBinary <|> parseNum) <* parseWhitespaces
     parseBinary =
         ( binaryWithPriority
             <$> parseNum
-                <*> parseOperator'
-                <*> parseExpression
+            <*> parseOperator'
+            <*> parseExpression
         )
-            <|> ( Binary <$> (parseOpen' *> parseExpression <* parseClose')
+            <|> ( Binary
+                    <$> (parseOpen' *> parseExpression <* parseClose')
                     <*> parseOperator'
                     <*> parseExpression
                 )
     binaryWithPriority l op r
         | (Binary l' op' r') <- r
-          , priority op' < priority op =
+        , priority op' < priority op =
             Binary (Binary l op l') op' r'
         | otherwise = Binary l op r
     parseOperator' = parseOperator <* parseWhitespaces

src/MiniHaskLisp/Eval.hs → src/minihasklisp/Eval.hs

@@ -1,11 +1,9 @@
-{-# LANGUAGE TupleSections #-}
+module Eval (Error (..), Env, eval, renderError) where
 
-module MiniHaskLisp.Eval where
-
-import Control.Monad
-import Data.Foldable
-import MiniHaskLisp.SExpr
-import Parser
+import Control.Monad (liftM2, (<=<))
+import Data.Foldable (foldl')
+import Parser (Parser (..), parseInt)
+import SExpr (SExpr (..), toPairs)
 
 type Env = [(String, SExpr)]
 

src/MiniHaskLisp/ParseAndEval.hs → src/minihasklisp/ParseAndEval.hs

@@ -1,11 +1,11 @@
-module MiniHaskLisp.ParseAndEval where
+module ParseAndEval (Error (..), Result, parseAndEval, renderResult) where
 
 import Data.Bifunctor (second)
-import MiniHaskLisp.Eval hiding (Error)
-import MiniHaskLisp.SExpr
-import Parser
+import Eval (Env, eval, renderError)
+import Parser (Parser (..))
+import SExpr (SExpr (..), parseSExpr, render, toPairs)
 
-import qualified MiniHaskLisp.Eval as Eval
+import qualified Eval
 
 data Error = ErParse String | ErEval Eval.Error
     deriving (Eq, Show)

src/MiniHaskLisp/SExpr.hs → src/minihasklisp/SExpr.hs

@@ -1,7 +1,7 @@
-module MiniHaskLisp.SExpr where
+module SExpr (SExpr (..), parseSExpr, render, toPairs) where
 
-import Control.Applicative
-import Parser
+import Control.Applicative (some, (<|>))
+import Parser (Parser (..), parseChar, parsePred, parseString, parseWhitespaces)
 
 data SExpr = Atom String | SExpr [SExpr]
     deriving (Eq, Show)

src/Parser.hs → src/parser/Parser.hs

@@ -1,8 +1,21 @@
-module Parser where
-
-import Control.Applicative
-import Control.Monad
-import Data.Foldable (asum)
+module Parser (
+    Parser (..),
+    parseAnd,
+    parseAndWith,
+    parseAnyChar,
+    parseChar,
+    parseDouble,
+    parsePred,
+    parseString,
+    parseInt,
+    parseUInt,
+    parseTuple,
+    parseTuple',
+    parseWhitespaces,
+) where
+
+import Control.Applicative (Alternative (..), asum, liftA2, optional)
+import Control.Monad (void)
 import qualified Data.List as L
 import Data.Maybe (fromMaybe)
 import Text.Read (readMaybe)

test/ExpressionSpec.hs → test/eval-expr/ExpressionSpec.hs

@@ -1,9 +1,15 @@
 module ExpressionSpec (spec) where
 
-import Test.Hspec
+import Test.Hspec (Spec, describe, it, shouldBe, shouldSatisfy)
 
-import EvalExpr.Expression
-import Parser
+import Expression (
+    Expression (..),
+    Operator (..),
+    eval,
+    parseExpression,
+    parseOperator,
+ )
+import Parser (Parser (..))
 
 spec :: Spec
 spec = do

test/SExprSpec.hs → test/minihasklisp/SExprSpec.hs

@@ -1,10 +1,10 @@
 module SExprSpec (spec) where
 
-import MiniHaskLisp.Eval (Error (NotBound))
-import MiniHaskLisp.ParseAndEval
-import MiniHaskLisp.SExpr
-import Parser
-import Test.Hspec
+import Eval (Error (NotBound))
+import ParseAndEval (Error (..), parseAndEval)
+import Parser (Parser (..))
+import SExpr (SExpr (..), parseSExpr)
+import Test.Hspec (Spec, describe, it, shouldBe, shouldReturn)
 
 spec :: Spec
 spec = do
@@ -202,11 +202,11 @@ spec = do
                 `shouldBe` Right (Atom "here", [])
     describe "Files" $ do
         it "fact" $ do
-            evalFile "test/minihasklisp/fact.scm" `shouldReturn` Right (Atom "3628800")
+            evalFile "test/minihasklisp/files/fact.scm" `shouldReturn` Right (Atom "3628800")
         it "fib" $ do
-            evalFile "test/minihasklisp/fib.scm" `shouldReturn` Right (Atom "55")
+            evalFile "test/minihasklisp/files/fib.scm" `shouldReturn` Right (Atom "55")
         it "sort" $ do
-            evalFile "test/minihasklisp/sort.scm"
+            evalFile "test/minihasklisp/files/sort.scm"
                 `shouldReturn` Right
                     ( SExpr
                         [ Atom "1"
@@ -255,7 +255,7 @@ spec = do
                         ]
                     )
         it "qsort3" $ do
-            evalFile "test/minihasklisp/qsort3.scm"
+            evalFile "test/minihasklisp/files/qsort3.scm"
                 `shouldReturn` Right
                     ( SExpr
                         [ Atom "1"

test/minihasklisp/Spec.hs

@@ -0,0 +1 @@
+{-# OPTIONS_GHC -F -pgmF hspec-discover #-}

test/ParserSpec.hs → test/parser/ParserSpec.hs

@@ -1,10 +1,20 @@
-module ParserSpec (spec)
-where
+module ParserSpec (spec) where
 
-import Test.Hspec
+import Test.Hspec (Spec, describe, it, shouldBe)
 
-import Control.Applicative
-import Parser
+import Control.Applicative (many, some, (<|>))
+import Parser (
+    Parser (..),
+    parseAnd,
+    parseAndWith,
+    parseAnyChar,
+    parseChar,
+    parseDouble,
+    parseInt,
+    parseTuple,
+    parseTuple',
+    parseUInt,
+ )
 
 spec :: Spec
 spec = do