tagging release w.t.f.

Author: felixbd

README.org

@@ -162,6 +162,29 @@ or use
 stack ghci
 #+end_src
 
+#+begin_src haskell
+--      ast              tokens       lines of code     file name
+ast <- runASTParser . tokenize <$> readFileContent "./filename.wile"
+
+-- print $ eval ast []  -- eval v1
+-- print $ evalT ast []  -- eval v2
+
+let program = evalM ast  -- Monad eval
+print $ getVarState program []
+
+-- eg.
+--
+--  let program2 = evalM ast_1 >> evalM ast_2 >> ...
+--  print $ getVarState program2 []
+--
+-- where `ast_1` could set global vars and `ast_2` could
+--  contain a script using the global vars ...
+
+
+-- or use:
+--  print $ runEvalM ast []
+#+end_src
+
 
 *** compile
 

app/Main.hs

@@ -6,12 +6,12 @@ module Main (main) where
 import System.Environment (getArgs)
 
 import WhileParser (tokenize, readFileContent, runASTParser)  -- WhileAST(..),
-import WhileEvaluation (eval, evalT, evalM, getVST, runEvalM)
-  --, evalM, VarName, VarVal, VarState, VarStateWorld)
+import WhileEvaluation (eval, evalT, evalM, getVarState, runEvalM)
+  -- VarName, VarVal, VarState, VarStateWorld)
 
 
 -- | Define a data type to represent the command-line options
-newtype Options = Options { getFileName :: FilePath }
+newtype Options = Options { getFileName :: FilePath } deriving Show
 
 
 -- | Parse command-line arguments manually
@@ -26,31 +26,21 @@ runInterpreter options = do
 
   putStrLn $ "\ESC[92m[Interpreting file]\ESC[0m    " ++ getFileName options
 
-  -- Read the content of the specified file
-  whileLines <- readFileContent $ getFileName options
-  let tokens = tokenize whileLines
-
-  putStrLn "\ESC[92m[DONE TOKENIZE]\ESC[0m"
-  -- print tokens
-
-  let ast = runASTParser tokens
-  putStrLn "\ESC[92m[DONE PARSING AST]\ESC[0m"
-  -- print ast
-
-  putStrLn "\ESC[92m[RESULT OF EVALUATION]\ESC[0m"
+  --      ast              tokens       lines of code     file name
+  ast <- runASTParser . tokenize <$> (readFileContent . getFileName) options
 
   -- print $ eval ast []  -- eval v1
   -- print $ evalT ast []  -- eval v2
 
   let program = evalM ast  -- Monad eval
-  print $ getVST program []
+  print $ getVarState program []
 
   -- eg.
-  -- let program2 = evalM ast >> evalM ast
-  -- print $ getVST program2 []
+  --  let program2 = evalM ast_1 >> evalM ast_2 >> ...
+  --  print $ getVarState program2 []
 
   -- or use:
-  -- print $ runEvalM ast []
+  --  print $ runEvalM ast []
 
   putStrLn $ "\n" ++ concat (replicate 40 "= ") ++ "=\n"
 

src/WhileEvaluation.hs

@@ -39,17 +39,17 @@ infixl 1 >>>=
 vst >>>= f = uncurry f . vst
 
 -- | Variable State Monade
-newtype VarStateM a = VarStateM { getVST :: VarStateT a } deriving Functor
+newtype VarStateM a = VarStateM { getVarState :: VarStateT a } deriving Functor
 
 instance Applicative VarStateM where
   pure x = VarStateM (x,)
 
-  vstf <*> vst = VarStateM (getVST vstf
-                            >>>= \f -> getVST vst
-                            >>>= \x -> getVST (pure (f x)))
+  vstf <*> vst = VarStateM (getVarState vstf
+                            >>>= \f -> getVarState vst
+                            >>>= \x -> getVarState (pure (f x)))
 
 instance Monad VarStateM where
-  vst >>= f = VarStateM (getVST vst >>>= getVST . f)
+  vst >>= f = VarStateM (getVarState vst >>>= getVarState . f)
 
 
 -- getState :: VarStateM VarStateWorld
@@ -129,4 +129,4 @@ evalM = VarStateM . evalT
 
 
 runEvalM :: WhileAST -> VarStateWorld -> ((), VarStateWorld)
-runEvalM ast = getVST $ evalM ast
+runEvalM ast = getVarState $ evalM ast

test/Spec.hs

@@ -6,9 +6,24 @@
 import Test.Tasty
 import Test.Tasty.HUnit
 
-import WhileParser (WhileAST(..), MetaToken(..), LineNum, Token(..), Expression(..), tokenize, readFileContent, runASTParser)
-import WhileEvaluation (evalM, VarName, VarVal, VarState, VarStateWorld)
+import WhileParser
+  (WhileAST(..)
+  ,MetaToken(..)
+  ,LineNum
+  ,Token(..)
+  ,Expression(..)
+  ,tokenize
+  ,readFileContent
+  ,runASTParser
+  )
 
+import WhileEvaluation
+  (evalM
+  ,VarName
+  ,VarVal
+  ,VarState
+  ,VarStateWorld
+  )
 
 main :: IO ()
 main = defaultMain $ testGroup "0. ./src/WhileParser.hs" [tokenizerTest0, parserTest0]
@@ -49,7 +64,7 @@ tokenizerTest0 = testGroup "tokenizer" [
      MetaToken 5 (ConstToken 1),
      MetaToken 5 EndToken]
 
-  , testCase "tokenize .while file" $ show (10 + 10) @?= "20"
+  , testCase "tokenize .while file" $ (show (10 + 10) :: String) @?= "20"
   -- whileLines <- readFileContent "./examples/foo.while"
   -- let tokens = tokenize whileLines
   ]
@@ -66,11 +81,11 @@ parserTest0 = testGroup "parser" [
            (5, "loop 8 do i := i + 1 end")])
       @?=
         Sequential
-                (Assignment "x_1" (Constant 10))
-                (Sequential
-                        (While
-                                (Neq (Variable "x") (Constant 0))
-                                (Assignment "x" (Subtract (Variable "x") (Constant 1))))
-                        (Loop
-                                (Constant 8) (Assignment "i" (Add (Variable "i") (Constant 1)))))
+          (Assignment "x_1" (Constant 10))
+          (Sequential
+            (While
+              (Neq (Variable "x") (Constant 0))
+              (Assignment "x" (Subtract (Variable "x") (Constant 1))))
+            (Loop
+              (Constant 8) (Assignment "i" (Add (Variable "i") (Constant 1)))))
   ]