Add: Enable to convert from Source syntax

app/Mlx1.hs

@@ -0,0 +1,15 @@
+module Mlx1 where
+
+import           Compile            (compileIntermediateFile)
+import           Reporting.Report   (printReport)
+
+import           System.Environment (getArgs)
+
+
+main :: IO ()
+main = do
+  args <- getArgs
+  result <- compileIntermediateFile Nothing $ head args
+  case result of
+    Right output -> putStrLn output
+    Left err     -> printReport err

app/Main.hs → app/Mlx2.hs

@@ -1,6 +1,6 @@
-module Main where
+module Mlx2 where
 
-import           Compile            (compileFile)
+import           Compile            (compileSourceFile)
 import           Reporting.Report   (printReport)
 
 import           System.Environment (getArgs)
@@ -9,7 +9,7 @@ import           System.Environment (getArgs)
 main :: IO ()
 main = do
   args <- getArgs
-  result <- compileFile Nothing $ head args
+  result <- compileSourceFile Nothing $ head args
   case result of
     Right output -> putStrLn output
     Left err     -> printReport err

package.yaml

@@ -42,13 +42,25 @@ library:
   source-dirs: src
 
 executables:
-  constraint-ad-hoc-exe:
-    main:                Main.hs
+  mlx1:
+    main:                Mlx1.hs
     source-dirs:         app
     ghc-options:
     - -threaded
     - -rtsopts
     - -with-rtsopts=-N
+    - -main-is Mlx1
+    dependencies:
+    - constraint-ad-hoc
+
+  mlx2:
+    main:                Mlx2.hs
+    source-dirs:         app
+    ghc-options:
+    - -threaded
+    - -rtsopts
+    - -with-rtsopts=-N
+    - -main-is Mlx2
     dependencies:
     - constraint-ad-hoc
 

src/Compile.hs

@@ -1,22 +1,30 @@
 module Compile where
 
+import qualified AST.Intermediate as I
 import           Config           (Config, loadConfigFile,
                                    loadDefaultConfigFile)
+import qualified Dictionary       (compile)
 import qualified Emit             (emit)
 import qualified Overload         (compile)
-import qualified Parse            (parseIntermediate)
+import qualified Parse            (parseIntermediate, parseSource)
 import           Reporting.Result (Result)
 
-import           Control.Monad    ((<=<))
+import           Control.Monad    (join, (<=<))
 import           Data.Text
 import qualified Data.Text.IO     as T
 
 
-compileFile :: Maybe FilePath -> FilePath -> IO (Result String)
-compileFile mconfig file = do
+compileSourceFile :: Maybe FilePath -> FilePath -> IO (Result String)
+compileSourceFile = compileFile (Dictionary.compile <=< Parse.parseSource)
+
+compileIntermediateFile :: Maybe FilePath -> FilePath -> IO (Result String)
+compileIntermediateFile = compileFile Parse.parseIntermediate
+
+compileFile :: (Text -> Result I.Expr) -> Maybe FilePath -> FilePath -> IO (Result String)
+compileFile f mconfig file = do
   config <- maybe loadDefaultConfigFile loadConfigFile mconfig
   content <- T.readFile file
-  return $ flip compile content =<< config
+  return . join $ compile <$> config <*> f content
 
-compile :: Config -> Text -> Result String
-compile c = fmap Emit.emit . Overload.compile c <=< Parse.parseIntermediate
+compile :: Config -> I.Expr -> Result String
+compile c = fmap Emit.emit . Overload.compile c

src/Dictionary.hs

@@ -0,0 +1,10 @@
+module Dictionary where
+
+import qualified AST.Intermediate as T
+import qualified AST.Source       as S
+
+import           Reporting.Result (Result)
+
+
+compile :: S.Expr -> Result T.Expr
+compile = undefined

test/Spec.hs

@@ -5,7 +5,7 @@ import           System.IO        (hClose, hPutStr)
 import           System.IO.Temp   (withSystemTempFile)
 import           Test.Hspec
 
-import           Compile          (compileFile)
+import           Compile          (compileIntermediateFile)
 import           Reporting.Report (report)
 import           Reporting.Result (Result)
 import           Reporting.Error (Error)
@@ -28,7 +28,7 @@ runML source = withSystemTempFile ".ml" $ \file h -> do
   return $ strip out
 
 compileFile' :: FilePath -> IO (Result String)
-compileFile' file = compileFile (Just "test/data/env.yaml") ("test/data/" ++ file)
+compileFile' file = compileIntermediateFile (Just "test/data/env.yaml") ("test/data/" ++ file)
 
 testSample :: FilePath -> IO Text
 testSample file = do