Split code, failing test

koaky.cabal

@@ -32,6 +32,9 @@ library
       Computing.Functions
       Computing.ListContainList
       Computing.ReplaceFunctionParams
+      Computing.Operators.Assert
+      Computing.Operators.Calculate
+      Computing.Operators.EvaluateSymbol
       KoakyLibVersion
       Parsing.Parser
       Types

src/Computing/ComputeAST.hs

@@ -8,7 +8,6 @@
 module Computing.ComputeAST
     (
         computeAST,
-        evaluateSymbol
     ) where
 
 import Types
@@ -17,236 +16,11 @@ import Computing.ReplaceFunctionParams
 import Computing.Defines
 import Computing.Functions
 import Computing.Errors
-
--- Compute a "+ - div * mod" list, using defines if needed
-
-addition :: Env -> [Tree] -> (Env, Result)
-addition env [Number a, Number b] = (env, Left (Just (Number (a + b))))
-addition env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (a + symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-addition env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Number (symbolValue + b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-addition env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (symbolValueA + symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-addition env list
-    | length list /= 2 = (registerError env "Addition need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in addition", Right (undefined))
-
-multiplication :: Env -> [Tree] -> (Env, Result)
-multiplication env [Number a, Number b] = (env, Left (Just (Number (a * b))))
-multiplication env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left(Just (Number (a * symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-multiplication env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Number (symbolValue * b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-multiplication env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (symbolValueA * symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-multiplication env list
-    | length list /= 2 = (registerError env "* need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in multiplication", Right (undefined))
-
-subtraction :: Env -> [Tree] -> (Env, Result)
-subtraction env [Number a, Number b] = (env, Left (Just (Number (a - b))))
-subtraction env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (a - symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-subtraction env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Number (symbolValue - b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-subtraction env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (symbolValueA - symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-subtraction env list
-    | length list /= 2 = (registerError env "- need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in subtraction", Right (undefined))
-
-division :: Env -> [Tree] -> (Env, Result)
-division env [Number a, Number b]
-    | b == 0 = (registerError env "Division by 0", Right (undefined))
-    | otherwise = (env, Left (Just (Number (a `div` b))))
-division env [Symbol a, Number b]
-    | b == 0 = (registerError env "Division by 0", Right (undefined))
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Number (symbolValue `div` b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-division env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b
-    , symbolValue == 0 = (registerError env "Division by 0", Right (undefined))
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (a `div` symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-division env [Symbol a, Symbol b]
-    | (_, Just (Number _)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b
-    , symbolValueB == 0 = (registerError env "Division by 0", Right (undefined))
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (symbolValueA `div` symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-division env list
-    | length list /= 2 = (registerError env "/ need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in division", Right (undefined))
-
-modulo :: Env -> [Tree] -> (Env, Result)
-modulo env [Number a, Number b]
-    | b == 0 = (registerError env "Modulo by 0", Right (undefined))
-    | otherwise = (env, Left (Just (Number (a `mod` b))))
-modulo env [Symbol a, Number b]
-    | b == 0 = (registerError env "Modulo by 0", Right (undefined))
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Number (symbolValue `mod` b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-modulo env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b
-    , symbolValue == 0 = (registerError env "Modulo by 0", Right (undefined))
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (a `mod` symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-modulo env [Symbol a, Symbol b]
-    | (_, Just (Number _)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b
-    , symbolValueB == 0 = (registerError env "Modulo by 0", Right (undefined))
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Number (symbolValueA `mod` symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-modulo env list
-    | length list /= 2 = (registerError env "% need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in modulo", Right (undefined))
+import Computing.Operators.Calculate
+import Computing.Operators.Assert
 
 ------------------------- CONDITIONS ---------------------------------
 
-equal :: Env -> [Tree] -> (Env, Result)
-equal env [Number a, Number b] = (env, Left (Just (Boolean (a == b))))
-equal env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (a == symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-equal env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Boolean (symbolValue == b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-equal env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (symbolValueA == symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-equal env list
-    | length list /= 2 = (registerError env "eq? need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in eq?", Right (undefined))
-
-notEqual :: Env -> [Tree] -> (Env, Result)
-notEqual env [Number a, Number b] = (env, Left (Just (Boolean (a /= b))))
-notEqual env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (a /= symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-notEqual env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Boolean (symbolValue /= b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-notEqual env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (symbolValueA /= symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-notEqual env list
-    | length list /= 2 = (registerError env "not-eq? need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in not-eq?", Right (undefined))
-
-inferior :: Env -> [Tree] -> (Env, Result)
-inferior env [Number a, Number b] = (env, Left (Just (Boolean (a < b))))
-inferior env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (a < symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-inferior env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Boolean (symbolValue < b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-inferior env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (symbolValueA < symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-inferior env list
-    | length list /= 2 = (registerError env "< need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in <", Right (undefined))
-
-superior :: Env -> [Tree] -> (Env, Result)
-superior env [Number a, Number b] = (env, Left (Just (Boolean (a > b))))
-superior env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (a > symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-superior env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Boolean (symbolValue > b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-superior env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (symbolValueA > symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-superior env list
-    | length list /= 2 = (registerError env "> need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in >", Right (undefined))
-
-inferiorOrEqual :: Env -> [Tree] -> (Env, Result)
-inferiorOrEqual env [Number a, Number b] = (env, Left (Just (Boolean (a <= b))))
-inferiorOrEqual env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (a <= symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-inferiorOrEqual env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Boolean (symbolValue <= b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-inferiorOrEqual env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (symbolValueA <= symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-inferiorOrEqual env list
-    | length list /= 2 = (registerError env "<= need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in <=", Right (undefined))
-
-superiorOrEqual :: Env -> [Tree] -> (Env, Result)
-superiorOrEqual env [Number a, Number b] = (env, Left (Just (Boolean (a >= b))))
-superiorOrEqual env [Number a, Symbol b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (a >= symbolValue))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-superiorOrEqual env [Symbol a, Number b]
-    | (_, Just (Number symbolValue)) <- evaluateSymbol env a =
-        (env, Left (Just (Boolean (symbolValue >= b))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-superiorOrEqual env [Symbol a, Symbol b]
-    | (_, Just (Number symbolValueA)) <- evaluateSymbol env a
-    , (_, Just (Number symbolValueB)) <- evaluateSymbol env b =
-        (env, Left (Just (Boolean (symbolValueA >= symbolValueB))))
-    | otherwise = (registerError env "Symbol not found", Right (undefined))
-superiorOrEqual env list
-    | length list /= 2 = (registerError env ">= need 2 params", Right (undefined))
-    | otherwise = (registerError env "Bad types in >=", Right (undefined))
-
 handleIf :: Env -> [Tree] -> (Env, Result)
 handleIf env (Boolean (True) : thenBranch : _ : [])
     = computeASTWithoutList env thenBranch
@@ -256,21 +30,6 @@ handleIf env _ = (registerError env "Bad if statement", Right (undefined))
 
 ----------------------------------------------------------------------------------
 
--- Evaluate a symbol and return its value
-evaluateSymbol :: Env -> Symbol -> (Env, Maybe Tree)
-evaluateSymbol env smbl =
-    case getSymbolValue env smbl of
-        (_, Nothing) -> (env, Nothing)
-        (_, Just (Number number)) -> (env, Just (Number number))
-        (_, Just (Boolean value)) -> (env, Just (Boolean value))
-        (_, Just (List list)) ->
-            case computeAST env (List list) of
-                (_, Left (Just result)) -> (env, Just result)
-                (_, _) -> (env, Nothing)
-        (_, _) -> (env, Nothing)
-
-----------------------------------------------------------------------------------
-
 
 -- Find nested lists and resolve them
 resolveNestedLists :: Env -> [Tree] -> [Tree] -> (Env, Maybe [Tree])

src/Computing/Defines.hs

@@ -20,9 +20,9 @@ import Computing.Errors
 getSymbolValue :: Env -> String -> (Env, Maybe Tree)
 getSymbolValue (Env { defines = [], errors = _, functions = _ }) _ =
     (Env { defines = [], errors = [], functions = [] }, Nothing)
-getSymbolValue (Env { defines = (Define smbl value):xs, errors = err }) expr
-    | smbl == expr = (Env { defines = xs, errors = err, functions = [] }, Just value)
-    | otherwise = getSymbolValue (Env { defines = xs, errors = err, functions = [] }) expr
+getSymbolValue (Env { defines = (Define smbl value):xs, errors = err, functions = fcts }) expr
+    | smbl == expr = (Env { defines = xs, errors = err, functions = fcts }, Just value)
+    | otherwise = getSymbolValue (Env { defines = xs, errors = err, functions = fcts }) expr
 
 -- Register a define in the Defines list
 registerDefine :: Env -> Symbol -> Tree -> Env

src/Computing/Operators/Assert.hs

@@ -0,0 +1,55 @@
+module Computing.Operators.Assert
+  (
+    equal,
+    notEqual,
+    inferior,
+    inferiorOrEqual,
+    superior,
+    superiorOrEqual
+  ) where
+
+import Types
+import Computing.Operators.EvaluateSymbol
+import Data.Int (Int64)
+import Computing.Errors
+
+assert :: Int64 -> Int64 -> Symbol -> Tree
+assert a b ">" = Boolean (a > b)
+assert a b "<" = Boolean (a < b)
+assert a b ">=" = Boolean (a >= b)
+assert a b "<=" = Boolean (a <= b)
+assert a b "eq?" = Boolean (a == b)
+assert a b "diff?" = Boolean (a /= b)
+assert _ _ _ = Boolean (False)
+
+maybeAssert :: Maybe Tree -> Maybe Tree -> Symbol -> Env -> (Env, Result)
+maybeAssert (Just (Number a)) (Just (Number b)) operator env = (env, Left (Just (assert a b operator)))
+maybeAssert _ _ _ env = (registerError env "Symbol not found", Right (undefined))
+
+assertOperator :: Env -> [Tree] -> Symbol -> (Env, Result)
+assertOperator env [Number a, Number b] operator = (env, Left (Just (assert a b operator)))
+assertOperator env [Number a, Symbol b] operator = maybeAssert (Just (Number a)) (evaluateSymbol env b) operator env
+assertOperator env [Symbol a, Number b] operator = maybeAssert (evaluateSymbol env a) (Just (Number b)) operator env
+assertOperator env [Symbol a, Symbol b] operator = maybeAssert (evaluateSymbol env a) (evaluateSymbol env b) operator env
+assertOperator env list _
+  | length list /= 2 = (registerError env "assert need 2 params", Right (undefined))
+  | otherwise = (registerError env "Bad types in assert", Right (undefined))
+
+equal :: Env -> [Tree] -> (Env, Result)
+equal env trees = assertOperator env trees "eq?"
+
+notEqual :: Env -> [Tree] -> (Env, Result)
+notEqual env trees = assertOperator env trees "diff?"
+
+inferior :: Env -> [Tree] -> (Env, Result)
+inferior env trees = assertOperator env trees "<"
+
+superior :: Env -> [Tree] -> (Env, Result)
+superior env trees = assertOperator env trees ">"
+
+inferiorOrEqual :: Env -> [Tree] -> (Env, Result)
+inferiorOrEqual env trees = assertOperator env trees "<="
+
+superiorOrEqual :: Env -> [Tree] -> (Env, Result)
+superiorOrEqual env trees = assertOperator env trees ">="
+