From 0e9becb6af0b1226b6f010c113548d1753c5a8b8 Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Wed, 29 Nov 2023 16:41:50 +0100
Subject: [PATCH 01/20] add executable to gitignore MINOR

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 7d017d8..e38e5aa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -170,3 +170,4 @@ tags
 /glados
 
 *.log
+*.exe

From 91274a7c3b449a9c0710d9069f8951ebe0bec4c5 Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Wed, 29 Nov 2023 16:42:06 +0100
Subject: [PATCH 02/20] add powershell build script MINOR

---
 scripts/Build.ps1 | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 scripts/Build.ps1

diff --git a/scripts/Build.ps1 b/scripts/Build.ps1
new file mode 100644
index 0000000..80e9d97
--- /dev/null
+++ b/scripts/Build.ps1
@@ -0,0 +1,6 @@
+stack build --copy-bins --local-bin-path .
+
+if (Test-Path ".\koaky-exe.exe")
+{
+    Rename-Item ".\koaky-exe.exe" "koaky.exe"
+}

From 594458006767e2efcb8632f58f067b64839c4e48 Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Wed, 29 Nov 2023 21:28:27 +0100
Subject: [PATCH 03/20] Add work in progress

---
 app/Main.hs       | 17 +++++++++++------
 scripts/Build.ps1 |  5 +++++
 src/AST.hs        | 10 +++++++---
 src/ComputeAST.hs | 37 +++++++++++++++++++++++++++++++++----
 4 files changed, 56 insertions(+), 13 deletions(-)

diff --git a/app/Main.hs b/app/Main.hs
index 8f4b288..9be72fa 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -1,11 +1,16 @@
 {-
---  EPITECH PROJECT, 2023
---  Main
---  File description:
---  Main
+-- EPITECH PROJECT, 2023
+-- Koaky
+-- File description:
+-- Main
 -}
 
-module Main (main) where
+import ComputeAST
+import AST
+
+createDefineTestTree :: Tree
+-- data Tree = Node Symbol (Maybe Tree) (Maybe Tree) | Leaf Atom
+createDefineTestTree = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 21)))
 
 main :: IO ()
-main = putStrLn "Hello, World!"
+main = computeAST createDefineTestTree
diff --git a/scripts/Build.ps1 b/scripts/Build.ps1
index 80e9d97..5a07d83 100644
--- a/scripts/Build.ps1
+++ b/scripts/Build.ps1
@@ -1,3 +1,8 @@
+if (Test-Path ".\koaky.exe")
+{
+    Remove-Item ".\koaky.exe"
+}
+
 stack build --copy-bins --local-bin-path .
 
 if (Test-Path ".\koaky-exe.exe")
diff --git a/src/AST.hs b/src/AST.hs
index a1cf1ff..7d039cc 100644
--- a/src/AST.hs
+++ b/src/AST.hs
@@ -2,14 +2,14 @@
 --  EPITECH PROJECT, 2023
 --  Abstract Syntax Tree
 --  File description:
---  ast
+--  Ast
 -}
 
 module AST
     (
         Symbol,
         Atom (Number, Symbol),
-        Tree (Node, Leaf),
+        Tree (Node, Leaf)
     ) where
 
 import Data.Int (Int64)
@@ -18,4 +18,8 @@ type Symbol = String
 
 data Atom = Number Int64 | Symbol Symbol
 
-data Tree = Node Symbol [Tree] | Leaf Atom
+data Tree = Node Symbol (Maybe Tree) (Maybe Tree) | Leaf Atom
+
+instance Show Atom where
+    show (Number n) = show n
+    show (Symbol s) = s
diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index 97eff66..e61f9c8 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -1,10 +1,39 @@
 {-
---  EPITECH PROJECT, 2023
---  Compute an AST
---  File description:
---  ComputeAST
+-- EPITECH PROJECT, 2023
+-- Koaky
+-- File description:
+-- ComputeAST
 -}
 
 module ComputeAST
     (
+        computeAST
     ) where
+
+import AST
+
+--Defines :
+-- <SYMBOL> <EXPRESSION> with <EXPRESSION> being a type Atom or Symbol
+--foo 21
+--func add (lambda (a b) (+ a b))
+
+type Expression = Atom
+
+data Define = Define {
+    symbol :: String,
+    value :: Expression
+}
+
+type Defines = [Define]
+
+print
+
+handleDefine :: Tree -> IO ()
+handleDefine (Node "define" (Just (Leaf (Symbol symbol))) (Just (Leaf value))) = putStrLn ("defining: " ++ symbol ++ " as " ++ show value)
+handleDefine _ = putStrLn "Error: Invalid AST"
+
+--data Tree = Node Symbol Tree Tree | Leaf Atom
+
+computeAST :: Tree -> IO ()
+computeAST (Node "define" (Just (Leaf (Symbol symbol))) (Just value)) = handleDefine (Node "define" (Just (Leaf (Symbol symbol))) (Just value))
+computeAST _ = putStrLn "Error: Invalid AST"

From 434e120b649df1a144999ed50891d278a9fc8584 Mon Sep 17 00:00:00 2001
From: tenshi <tenshii.tv@gmail.com>
Date: Thu, 30 Nov 2023 05:02:56 +0100
Subject: [PATCH 04/20] add work in progress

---
 src/ComputeAST.hs | 44 ++++++++++++++++++++++++++------------------
 1 file changed, 26 insertions(+), 18 deletions(-)

diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index e61f9c8..ecc9f0b 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -12,28 +12,36 @@ module ComputeAST
 
 import AST
 
---Defines :
--- <SYMBOL> <EXPRESSION> with <EXPRESSION> being a type Atom or Symbol
---foo 21
---func add (lambda (a b) (+ a b))
-
-type Expression = Atom
+-- Define = <SYMBOL> <EXPRESSION>
 
 data Define = Define {
     symbol :: String,
-    value :: Expression
-}
+    expression :: Atom
+} deriving (Show)
 
 type Defines = [Define]
 
-print
-
-handleDefine :: Tree -> IO ()
-handleDefine (Node "define" (Just (Leaf (Symbol symbol))) (Just (Leaf value))) = putStrLn ("defining: " ++ symbol ++ " as " ++ show value)
-handleDefine _ = putStrLn "Error: Invalid AST"
-
---data Tree = Node Symbol Tree Tree | Leaf Atom
-
+-- Function to print Defines if needed (debugging)
+printDefines :: Defines -> IO ()
+printDefines [] = return ()
+printDefines (x:xs) = putStrLn output >> printDefines xs
+    where output =
+            ("Symbol: " ++ (symbol x) ++
+            " Expr: " ++ (show (expression x)))
+
+-- Register a define in the Defines list
+registerDefine :: Defines -> Tree -> Defines
+registerDefine defines
+        (Node "define"
+        (Just (Leaf (Symbol defSymbol)))
+        (Just (Leaf defexpression)))
+        = defines ++ [Define defSymbol defexpression]
+registerDefine defines _ = defines
+
+-- Temporary function to compute defines only
+-- Will be replaced by a function to compute the whole AST
 computeAST :: Tree -> IO ()
-computeAST (Node "define" (Just (Leaf (Symbol symbol))) (Just value)) = handleDefine (Node "define" (Just (Leaf (Symbol symbol))) (Just value))
-computeAST _ = putStrLn "Error: Invalid AST"
+computeAST tree = do
+    let defines = registerDefine [] tree
+    printDefines defines
+    return ()

From e0aac41b7023528a98495bf88318fbf049e0b89a Mon Sep 17 00:00:00 2001
From: Xavier Mitault <xavier.mitault@epitech.eu>
Date: Sat, 2 Dec 2023 20:29:02 +0000
Subject: [PATCH 05/20] Add flags

PATCH
---
 koaky.cabal  | 6 +++---
 package.yaml | 3 +++
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/koaky.cabal b/koaky.cabal
index 7cccb21..b9d8583 100644
--- a/koaky.cabal
+++ b/koaky.cabal
@@ -32,7 +32,7 @@ library
       Paths_koaky
   hs-source-dirs:
       src
-  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints
+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -Wdefault -W -Woperator-whitespace
   build-depends:
       base >=4.7 && <5
   default-language: Haskell2010
@@ -43,7 +43,7 @@ executable koaky-exe
       Paths_koaky
   hs-source-dirs:
       app
-  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N
+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -Wdefault -W -Woperator-whitespace -threaded -rtsopts -with-rtsopts=-N
   build-depends:
       base >=4.7 && <5
     , koaky
@@ -56,7 +56,7 @@ test-suite koaky-test
       Paths_koaky
   hs-source-dirs:
       test
-  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N
+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -Wdefault -W -Woperator-whitespace -threaded -rtsopts -with-rtsopts=-N
   build-depends:
       base >=4.7 && <5
     , koaky
diff --git a/package.yaml b/package.yaml
index a961c6a..b4a3ae8 100644
--- a/package.yaml
+++ b/package.yaml
@@ -32,6 +32,9 @@ ghc-options:
 - -Wmissing-home-modules
 - -Wpartial-fields
 - -Wredundant-constraints
+- -Wdefault
+- -W
+- -Woperator-whitespace
 
 library:
   source-dirs: src

From 47ed9fb64d6a5ba730d3e1c510260230c37d79fe Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Mon, 4 Dec 2023 14:07:07 +0100
Subject: [PATCH 06/20] Add env and new functions

---
 app/Main.hs       | 10 +++++++---
 src/AST.hs        |  7 +++++++
 src/ComputeAST.hs | 41 ++++++++---------------------------------
 src/Defines.hs    | 35 +++++++++++++++++++++++++++++++++++
 4 files changed, 57 insertions(+), 36 deletions(-)
 create mode 100644 src/Defines.hs

diff --git a/app/Main.hs b/app/Main.hs
index 9be72fa..5bb164e 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -7,10 +7,14 @@
 
 import ComputeAST
 import AST
+import Defines
 
-createDefineTestTree :: Tree
+testTreeDefine :: Tree
 -- data Tree = Node Symbol (Maybe Tree) (Maybe Tree) | Leaf Atom
-createDefineTestTree = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 21)))
+testTreeDefine = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 21)))
+
+testTreeDefine2 :: Tree
+testTreeDefine2 = Node "define" (Just (Leaf (Symbol "bar"))) (Just (Leaf (Number 42)))
 
 main :: IO ()
-main = computeAST createDefineTestTree
+main = computeASTs [testTreeDefine, testTreeDefine2]
diff --git a/src/AST.hs b/src/AST.hs
index 7d039cc..08354b5 100644
--- a/src/AST.hs
+++ b/src/AST.hs
@@ -23,3 +23,10 @@ data Tree = Node Symbol (Maybe Tree) (Maybe Tree) | Leaf Atom
 instance Show Atom where
     show (Number n) = show n
     show (Symbol s) = s
+
+--data Variable
+--data Function
+--data Env = Env {
+--    variables :: [Variable],
+--    functions :: [Function]
+--}
diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index ecc9f0b..4901262 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -7,41 +7,16 @@
 
 module ComputeAST
     (
-        computeAST
+        computeASTs
     ) where
 
 import AST
-
--- Define = <SYMBOL> <EXPRESSION>
-
-data Define = Define {
-    symbol :: String,
-    expression :: Atom
-} deriving (Show)
-
-type Defines = [Define]
-
--- Function to print Defines if needed (debugging)
-printDefines :: Defines -> IO ()
-printDefines [] = return ()
-printDefines (x:xs) = putStrLn output >> printDefines xs
-    where output =
-            ("Symbol: " ++ (symbol x) ++
-            " Expr: " ++ (show (expression x)))
-
--- Register a define in the Defines list
-registerDefine :: Defines -> Tree -> Defines
-registerDefine defines
-        (Node "define"
-        (Just (Leaf (Symbol defSymbol)))
-        (Just (Leaf defexpression)))
-        = defines ++ [Define defSymbol defexpression]
-registerDefine defines _ = defines
+import Defines
 
 -- Temporary function to compute defines only
--- Will be replaced by a function to compute the whole AST
-computeAST :: Tree -> IO ()
-computeAST tree = do
-    let defines = registerDefine [] tree
-    printDefines defines
-    return ()
+computeAST :: Env -> Tree -> Env
+computeAST env tree = registerDefine env tree
+
+-- Call computeAST on every tree in the list
+computeASTs :: [Tree] -> IO ()
+computeASTs tree = print (foldl computeAST (Env []) tree) >> return ()
diff --git a/src/Defines.hs b/src/Defines.hs
new file mode 100644
index 0000000..9cae72b
--- /dev/null
+++ b/src/Defines.hs
@@ -0,0 +1,35 @@
+{-
+-- EPITECH PROJECT, 2023
+-- Koaky
+-- File description:
+-- Defines
+-}
+
+module Defines
+    (
+        Define (Define),
+        Env (Env),
+        registerDefine,
+    ) where
+
+import AST
+ 
+-- Define = <SYMBOL> <EXPRESSION>
+
+data Define = Define {
+    symbol :: String,
+    expression :: Atom
+} deriving (Show)
+
+data Env = Env {
+    defines :: [Define]
+} deriving (Show)
+
+-- Register a define in the Defines list
+registerDefine :: Env -> Tree -> Env
+registerDefine env
+        (Node "define"
+        (Just (Leaf (Symbol defSymbol)))
+        (Just (Leaf defexpression)))
+        = env { defines = defines env ++ [Define defSymbol defexpression] }
+registerDefine env _ = env

From fb75ee5e1a5d351d85f8571f1a56c33d05b654fd Mon Sep 17 00:00:00 2001
From: tenshi <tenshii.tv@gmail.com>
Date: Tue, 5 Dec 2023 02:04:54 +0100
Subject: [PATCH 07/20] add working defines with basic operations (+-*)

---
 app/Main.hs       | 28 ++++++++++++++++++---
 src/ComputeAST.hs | 64 +++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 83 insertions(+), 9 deletions(-)

diff --git a/app/Main.hs b/app/Main.hs
index 5bb164e..9f7616b 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -9,12 +9,32 @@ import ComputeAST
 import AST
 import Defines
 
+-- Foo = 42
 testTreeDefine :: Tree
--- data Tree = Node Symbol (Maybe Tree) (Maybe Tree) | Leaf Atom
-testTreeDefine = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 21)))
+testTreeDefine = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
 
+-- Bar = 21
 testTreeDefine2 :: Tree
-testTreeDefine2 = Node "define" (Just (Leaf (Symbol "bar"))) (Just (Leaf (Number 42)))
+testTreeDefine2 = Node "define" (Just (Leaf (Symbol "bar"))) (Just (Leaf (Number 21)))
+
+-- 21 + 21 (result = 42)
+testTreeAddition :: Tree
+testTreeAddition = Node "+" (Just (Leaf (Number 21))) (Just (Leaf (Number 21)))
+
+-- Foo + 42 (result = 42 + 42 = 84)
+testTreeAdditiondefine :: Tree
+testTreeAdditiondefine = Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
+
+-- Foo + Bar (result = 42 + 21 = 63)
+testTreeAdditiondefine2 :: Tree
+testTreeAdditiondefine2 = Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Symbol "bar")))
 
 main :: IO ()
-main = computeASTs [testTreeDefine, testTreeDefine2]
+main = computeASTs (Env [])
+    [   
+        testTreeDefine,
+        testTreeDefine2,
+        testTreeAddition,
+        testTreeAdditiondefine,
+        testTreeAdditiondefine2
+    ]
diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index 4901262..34ebaf7 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -12,11 +12,65 @@ module ComputeAST
 
 import AST
 import Defines
+import Data.Int (Int64)
 
--- Temporary function to compute defines only
-computeAST :: Env -> Tree -> Env
-computeAST env tree = registerDefine env tree
+-- TODO: Handle case where the define is a string / not defined
+getSymbolValue :: Env -> String -> Int64
+getSymbolValue (Env []) _ = 0
+getSymbolValue (Env ((Define symbol value):rest)) symbolToFind
+    | symbol == symbolToFind = case value of
+        (Number number) -> number
+        (Symbol _) -> 0
+    | otherwise = getSymbolValue (Env rest) symbolToFind
+
+------------ ADD SUB MUL FUNCTIONS ------------
+
+-- Compute a "+" node, using defines if needed
+-- Todo: See for better error handling in last line
+additionTree :: Env -> Tree -> Int64
+additionTree _ (Node "+" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left + right
+additionTree env (Node "+" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left + getSymbolValue env right
+additionTree env (Node "+" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left + right
+additionTree env (Node "+" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left + getSymbolValue env right
+additionTree _ _ = 0
+
+-- Compute a "-" node, using defines if needed
+-- Todo: See for better error handling in last line
+substactionTree :: Env -> Tree -> Int64
+substactionTree _ (Node "-" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left - right
+substactionTree env (Node "-" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left - getSymbolValue env right
+substactionTree env (Node "-" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left - right
+substactionTree env (Node "-" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left - getSymbolValue env right
+substactionTree _ _ = 0
+
+-- Compute a "*" node, using defines if needed
+-- Todo: See for better error handling in last line
+multiplicationTree :: Env -> Tree -> Int64
+multiplicationTree _ (Node "*" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left * right
+multiplicationTree env (Node "*" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left * getSymbolValue env right
+multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left * right
+multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left * getSymbolValue env right
+multiplicationTree _ _ = 0
+
+------------ ComputeNode ------------
+
+computeNode :: Env -> Tree -> Int64
+computeNode env tree@(Node "+" _ _) = additionTree env tree
+computeNode env tree@(Node "-" _ _) = substactionTree env tree
+computeNode env tree@(Node "*" _ _) = multiplicationTree env tree
+-- TODO: Error handling
+computeNode _ _ = 0
+
+------------ COMPUTE TREE ------------
+
+-- Call appropriate function depending on the node
+computeAST :: Env -> Tree -> IO Env
+computeAST env tree@(Node "define" _ _) = return $ registerDefine env tree
+computeAST env tree = print (computeNode env tree) >> return env
 
 -- Call computeAST on every tree in the list
-computeASTs :: [Tree] -> IO ()
-computeASTs tree = print (foldl computeAST (Env []) tree) >> return ()
+computeASTs :: Env -> [Tree] -> IO ()
+computeASTs _ [] = return ()
+computeASTs env (tree:rest) = do
+    updatedEnv <- computeAST env tree
+    computeASTs updatedEnv rest

From 99a30cff04cafc492fb18274c3340dae4ffa27e2 Mon Sep 17 00:00:00 2001
From: tenshi <tenshii.tv@gmail.com>
Date: Tue, 5 Dec 2023 05:15:04 +0100
Subject: [PATCH 08/20] add deepestnode

---
 app/Main.hs       | 42 ++++++++++++++++++-----------
 koaky.cabal       | 69 -----------------------------------------------
 scripts/Build.ps1 | 11 --------
 src/AST.hs        |  7 -----
 src/ComputeAST.hs | 49 ++++++++++++++++++++++++++++-----
 5 files changed, 68 insertions(+), 110 deletions(-)
 delete mode 100644 koaky.cabal
 delete mode 100644 scripts/Build.ps1

diff --git a/app/Main.hs b/app/Main.hs
index 9f7616b..47e16f7 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -10,31 +10,41 @@ import AST
 import Defines
 
 -- Foo = 42
-testTreeDefine :: Tree
-testTreeDefine = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
+test1 :: Tree
+test1 = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
 
 -- Bar = 21
-testTreeDefine2 :: Tree
-testTreeDefine2 = Node "define" (Just (Leaf (Symbol "bar"))) (Just (Leaf (Number 21)))
+test2 :: Tree
+test2 = Node "define" (Just (Leaf (Symbol "bar"))) (Just (Leaf (Number 21)))
 
 -- 21 + 21 (result = 42)
-testTreeAddition :: Tree
-testTreeAddition = Node "+" (Just (Leaf (Number 21))) (Just (Leaf (Number 21)))
+test3 :: Tree
+test3 = Node "+" (Just (Leaf (Number 21))) (Just (Leaf (Number 21)))
 
 -- Foo + 42 (result = 42 + 42 = 84)
-testTreeAdditiondefine :: Tree
-testTreeAdditiondefine = Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
+test4 :: Tree
+test4 = Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
 
 -- Foo + Bar (result = 42 + 21 = 63)
-testTreeAdditiondefine2 :: Tree
-testTreeAdditiondefine2 = Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Symbol "bar")))
+test5 :: Tree
+test5 = Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Symbol "bar")))
+
+-- 2 + (5 * 2) (result = 12)
+test6 :: Tree
+test6 = Node "+" (Just (Leaf (Number 2))) (Just (Node "*" (Just (Leaf (Number 5))) (Just (Leaf (Number 2)))))
+
+-- 2 + (foo / 2) (result = 23)
+test7 :: Tree
+test7 = Node "+" (Just (Leaf (Number 2))) (Just (Node "/" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))
 
 main :: IO ()
-main = computeASTs (Env [])
+main = computeAllAST (Env [])
     [   
-        testTreeDefine,
-        testTreeDefine2,
-        testTreeAddition,
-        testTreeAdditiondefine,
-        testTreeAdditiondefine2
+        test1,
+        test2,
+        test3,
+        test4,
+        test5,
+        test6,
+        test7
     ]
diff --git a/koaky.cabal b/koaky.cabal
deleted file mode 100644
index 512296a..0000000
--- a/koaky.cabal
+++ /dev/null
@@ -1,69 +0,0 @@
-cabal-version: 2.2
-
--- This file has been generated from package.yaml by hpack version 0.36.0.
---
--- see: https://github.com/sol/hpack
-
-name:           koaky
-version:        0.1.0.0
-description:    Please see the README on GitHub at <https://github.com/githubuser/koaky#readme>
-homepage:       https://github.com/githubuser/koaky#readme
-bug-reports:    https://github.com/githubuser/koaky/issues
-author:         Author name here
-maintainer:     example@example.com
-copyright:      2023 Author name here
-license:        BSD-3-Clause
-license-file:   LICENSE
-build-type:     Simple
-extra-source-files:
-    README.md
-    CHANGELOG.md
-
-source-repository head
-  type: git
-  location: https://github.com/githubuser/koaky
-
-library
-  exposed-modules:
-      AST
-      ComputeAST
-      TextToAST
-  other-modules:
-      Paths_koaky
-  autogen-modules:
-      Paths_koaky
-  hs-source-dirs:
-      src
-  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints
-  build-depends:
-      base >=4.7 && <5
-  default-language: Haskell2010
-
-executable koaky-exe
-  main-is: Main.hs
-  other-modules:
-      Paths_koaky
-  autogen-modules:
-      Paths_koaky
-  hs-source-dirs:
-      app
-  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N
-  build-depends:
-      base >=4.7 && <5
-    , koaky
-  default-language: Haskell2010
-
-test-suite koaky-test
-  type: exitcode-stdio-1.0
-  main-is: Spec.hs
-  other-modules:
-      Paths_koaky
-  autogen-modules:
-      Paths_koaky
-  hs-source-dirs:
-      test
-  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N
-  build-depends:
-      base >=4.7 && <5
-    , koaky
-  default-language: Haskell2010
diff --git a/scripts/Build.ps1 b/scripts/Build.ps1
deleted file mode 100644
index 5a07d83..0000000
--- a/scripts/Build.ps1
+++ /dev/null
@@ -1,11 +0,0 @@
-if (Test-Path ".\koaky.exe")
-{
-    Remove-Item ".\koaky.exe"
-}
-
-stack build --copy-bins --local-bin-path .
-
-if (Test-Path ".\koaky-exe.exe")
-{
-    Rename-Item ".\koaky-exe.exe" "koaky.exe"
-}
diff --git a/src/AST.hs b/src/AST.hs
index 08354b5..7d039cc 100644
--- a/src/AST.hs
+++ b/src/AST.hs
@@ -23,10 +23,3 @@ data Tree = Node Symbol (Maybe Tree) (Maybe Tree) | Leaf Atom
 instance Show Atom where
     show (Number n) = show n
     show (Symbol s) = s
-
---data Variable
---data Function
---data Env = Env {
---    variables :: [Variable],
---    functions :: [Function]
---}
diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index 34ebaf7..895dce3 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -7,7 +7,7 @@
 
 module ComputeAST
     (
-        computeASTs
+        computeAllAST
     ) where
 
 import AST
@@ -52,25 +52,60 @@ multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Number
 multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left * getSymbolValue env right
 multiplicationTree _ _ = 0
 
+-- Compute a "/" node, using defines if needed
+-- Todo: See for better error handling in last line + division by 0
+divisionTree :: Env -> Tree -> Int64
+divisionTree _ (Node "/" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left `div` right
+divisionTree env (Node "/" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left `div` getSymbolValue env right
+divisionTree env (Node "/" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left `div` right
+divisionTree env (Node "/" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left `div` getSymbolValue env right
+divisionTree _ _ = 0
+
 ------------ ComputeNode ------------
 
 computeNode :: Env -> Tree -> Int64
 computeNode env tree@(Node "+" _ _) = additionTree env tree
 computeNode env tree@(Node "-" _ _) = substactionTree env tree
 computeNode env tree@(Node "*" _ _) = multiplicationTree env tree
+computeNode env tree@(Node "/" _ _) = divisionTree env tree
 -- TODO: Error handling
 computeNode _ _ = 0
 
------------- COMPUTE TREE ------------
+------------ Resolve deepest ------------
+
+-- Compute the deepest node of the tree, it is when right node is a leaf and not a node
+resolveDeepestNode :: Env -> Tree -> Tree
+resolveDeepestNode env (Node symbol left (Just (Leaf right))) = Leaf (Number (computeNode env (Node symbol left (Just (Leaf right)))))
+resolveDeepestNode env (Node symbol left (Just right)) = Node symbol left (Just $ resolveDeepestNode env right)
+-- TODO: Error handling
+resolveDeepestNode _ _ = Leaf (Number 0)
+
+------------ COMPUTE TREE ----------
+
+-- Call recursively resolveDeepestNode until the tree is fully resolved (node is a leaf)
+computeTree :: Env -> Tree -> IO Env
+-- One node remaining symbol
+computeTree env (Leaf (Symbol symbol)) = do
+    let result = getSymbolValue env symbol
+    putStrLn $ show result
+    return env
+-- One node remaining number
+computeTree env (Leaf (Number number)) = do
+    putStrLn $ show number
+    return env
+-- More than one node remaining, call resolveDeepestNode on the tree
+computeTree env tree = computeTree env (resolveDeepestNode env tree)
+
+------------ COMPUTE AST ------------
 
 -- Call appropriate function depending on the node
 computeAST :: Env -> Tree -> IO Env
 computeAST env tree@(Node "define" _ _) = return $ registerDefine env tree
-computeAST env tree = print (computeNode env tree) >> return env
+computeAST env tree = computeTree env tree
 
 -- Call computeAST on every tree in the list
-computeASTs :: Env -> [Tree] -> IO ()
-computeASTs _ [] = return ()
-computeASTs env (tree:rest) = do
+computeAllAST :: Env -> [Tree] -> IO ()
+computeAllAST _ [] = return ()
+computeAllAST env (tree:rest) = do
     updatedEnv <- computeAST env tree
-    computeASTs updatedEnv rest
+    computeAllAST updatedEnv rest

From 43746a8cde4d9efb09fd6e1d6e86a2f00b035f0d Mon Sep 17 00:00:00 2001
From: tenshi <tenshii.tv@gmail.com>
Date: Tue, 5 Dec 2023 05:22:31 +0100
Subject: [PATCH 09/20] add build script

---
 scripts/Build.ps1 | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 scripts/Build.ps1

diff --git a/scripts/Build.ps1 b/scripts/Build.ps1
new file mode 100644
index 0000000..5a07d83
--- /dev/null
+++ b/scripts/Build.ps1
@@ -0,0 +1,11 @@
+if (Test-Path ".\koaky.exe")
+{
+    Remove-Item ".\koaky.exe"
+}
+
+stack build --copy-bins --local-bin-path .
+
+if (Test-Path ".\koaky-exe.exe")
+{
+    Rename-Item ".\koaky-exe.exe" "koaky.exe"
+}

From c73322cfe7340b1b7e4c2b96a0ceda34699b7f4f Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Tue, 5 Dec 2023 13:07:03 +0100
Subject: [PATCH 10/20] Fix resolveDeepestNode

---
 app/Main.hs       | 12 +++++++++++-
 src/ComputeAST.hs | 10 ++++++----
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/app/Main.hs b/app/Main.hs
index 47e16f7..39f89cc 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -37,6 +37,14 @@ test6 = Node "+" (Just (Leaf (Number 2))) (Just (Node "*" (Just (Leaf (Number 5)
 test7 :: Tree
 test7 = Node "+" (Just (Leaf (Number 2))) (Just (Node "/" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))
 
+-- 2 + 2 + (5 * 2) (result = 14)
+test8 :: Tree
+test8 = Node "+" (Just (Leaf (Number 2))) (Just (Node "+" (Just (Leaf (Number 2))) (Just (Node "*" (Just (Leaf (Number 5))) (Just (Leaf (Number 2)))))))
+
+-- (2 * 5) + (foo / 2) (result = 10 + 21 = 31)
+test9 :: Tree
+test9 = Node "+" (Just (Node "*" (Just (Leaf (Number 2))) (Just (Leaf (Number 5))))) (Just (Node "/" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))
+
 main :: IO ()
 main = computeAllAST (Env [])
     [   
@@ -46,5 +54,7 @@ main = computeAllAST (Env [])
         test4,
         test5,
         test6,
-        test7
+        test7,
+        test8,
+        test9
     ]
diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index 895dce3..3e56e80 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -73,12 +73,14 @@ computeNode _ _ = 0
 
 ------------ Resolve deepest ------------
 
--- Compute the deepest node of the tree, it is when right node is a leaf and not a node
+-- Compute the deepest node of the tree, it is when right and left node are a leaf and not a node
 resolveDeepestNode :: Env -> Tree -> Tree
-resolveDeepestNode env (Node symbol left (Just (Leaf right))) = Leaf (Number (computeNode env (Node symbol left (Just (Leaf right)))))
-resolveDeepestNode env (Node symbol left (Just right)) = Node symbol left (Just $ resolveDeepestNode env right)
+resolveDeepestNode env (Node symbol (Just (Leaf left)) (Just (Leaf right))) = Leaf (Number (computeNode env (Node symbol (Just (Leaf left)) (Just (Leaf right)))))
+resolveDeepestNode env (Node symbol (Just (Leaf left)) (Just right)) = Node symbol (Just (Leaf left)) (Just $ resolveDeepestNode env right)
+resolveDeepestNode env (Node symbol (Just left) (Just (Leaf right))) = Node symbol (Just $ resolveDeepestNode env left) (Just (Leaf right))
+resolveDeepestNode env (Node symbol (Just left) (Just right)) = Node symbol (Just $ resolveDeepestNode env left) (Just $ resolveDeepestNode env right)
 -- TODO: Error handling
-resolveDeepestNode _ _ = Leaf (Number 0)
+resolveDeepestNode _ _ = (Leaf (Number 0))
 
 ------------ COMPUTE TREE ----------
 

From 84eab85f22db6d64c81163c5dee8bbc05e94c843 Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Tue, 5 Dec 2023 13:16:47 +0100
Subject: [PATCH 11/20] Fix header

---
 app/Main.hs | 4 ----
 koaky.cabal | 1 +
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/app/Main.hs b/app/Main.hs
index 58acc59..39f89cc 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -1,10 +1,6 @@
 {-
 -- EPITECH PROJECT, 2023
-<<<<<<< HEAD
 -- Koaky
-=======
--- Main
->>>>>>> main
 -- File description:
 -- Main
 -}
diff --git a/koaky.cabal b/koaky.cabal
index b9d8583..fad12e2 100644
--- a/koaky.cabal
+++ b/koaky.cabal
@@ -27,6 +27,7 @@ library
   exposed-modules:
       AST
       ComputeAST
+      Defines
       TextToAST
   other-modules:
       Paths_koaky

From 9c88c5ad35f5d1db146b1851e865fb71e24cfa6a Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Tue, 5 Dec 2023 16:04:59 +0100
Subject: [PATCH 12/20] Add unit tests for compute

---
 app/Main.hs       | 18 +++++-------------
 src/ComputeAST.hs | 30 ++++++++++--------------------
 test/Spec.hs      | 16 +++++++++++++++-
 3 files changed, 30 insertions(+), 34 deletions(-)

diff --git a/app/Main.hs b/app/Main.hs
index 39f89cc..716fc38 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -10,8 +10,11 @@ import AST
 import Defines
 
 -- Foo = 42
+test0 :: Tree
+test0 = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
+
 test1 :: Tree
-test1 = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
+test1 = Leaf (Symbol "foo")
 
 -- Bar = 21
 test2 :: Tree
@@ -46,15 +49,4 @@ test9 :: Tree
 test9 = Node "+" (Just (Node "*" (Just (Leaf (Number 2))) (Just (Leaf (Number 5))))) (Just (Node "/" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))
 
 main :: IO ()
-main = computeAllAST (Env [])
-    [   
-        test1,
-        test2,
-        test3,
-        test4,
-        test5,
-        test6,
-        test7,
-        test8,
-        test9
-    ]
+main = putStrLn $ show $ computeAllAST (Env []) [test0, test1, test2, test3, test4, test5, test6, test7, test8, test9]
diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index 3e56e80..020920a 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -84,30 +84,20 @@ resolveDeepestNode _ _ = (Leaf (Number 0))
 
 ------------ COMPUTE TREE ----------
 
--- Call recursively resolveDeepestNode until the tree is fully resolved (node is a leaf)
-computeTree :: Env -> Tree -> IO Env
--- One node remaining symbol
-computeTree env (Leaf (Symbol symbol)) = do
-    let result = getSymbolValue env symbol
-    putStrLn $ show result
-    return env
--- One node remaining number
-computeTree env (Leaf (Number number)) = do
-    putStrLn $ show number
-    return env
--- More than one node remaining, call resolveDeepestNode on the tree
+computeTree :: Env -> Tree -> Atom
+computeTree env (Leaf (Symbol symbol)) = Number (getSymbolValue env symbol)
+computeTree _ (Leaf (Number number)) = Number number
 computeTree env tree = computeTree env (resolveDeepestNode env tree)
 
 ------------ COMPUTE AST ------------
 
 -- Call appropriate function depending on the node
-computeAST :: Env -> Tree -> IO Env
-computeAST env tree@(Node "define" _ _) = return $ registerDefine env tree
-computeAST env tree = computeTree env tree
+computeAST :: Env -> [Atom] -> Tree -> (Env, [Atom])
+computeAST env atoms tree@(Node "define" _ _) = (registerDefine env tree, atoms)
+computeAST env atoms tree = (env, atoms ++ [computeTree env tree])
 
 -- Call computeAST on every tree in the list
-computeAllAST :: Env -> [Tree] -> IO ()
-computeAllAST _ [] = return ()
-computeAllAST env (tree:rest) = do
-    updatedEnv <- computeAST env tree
-    computeAllAST updatedEnv rest
+computeAllAST :: Env -> [Tree] -> [Atom]
+computeAllAST _ [] = []
+computeAllAST env (tree:rest) = atoms ++ computeAllAST newEnv rest
+    where (newEnv, atoms) = computeAST env [] tree
diff --git a/test/Spec.hs b/test/Spec.hs
index 48a0fce..05da02e 100644
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -4,12 +4,14 @@ import Test.Tasty.Runners.Html
 
 import AST
 import TextToAST
+import ComputeAST
+import Defines
 
 main :: IO ()
 main = defaultMainWithIngredients (htmlRunner : defaultIngredients) tests
 
 tests :: TestTree
-tests = testGroup "Tests" [unitTestsASTEqual, unitTestsASTParse]
+tests = testGroup "Tests" [unitTestsASTEqual, unitTestsASTParse, unitTestASTCompute]
 
 unitTestsASTEqual :: TestTree
 unitTestsASTEqual = testGroup "AST Equal Tests"
@@ -150,3 +152,15 @@ unitTestsASTParse = testGroup "AST Parse Tests"
         )
         (textToAST "(foo def )")
   ]
+
+unitTestASTCompute :: TestTree
+unitTestASTCompute = testGroup "AST compute Tests"
+    [ testCase "test1" $
+        assertEqual "number 21 + number 21 = 42"
+          [Number 42]
+          (computeAllAST (Env []) [Node "+" (Just (Leaf (Number 21))) (Just (Leaf (Number 21)))])
+    , testCase "test2" $
+        assertEqual "define foo 42 and tree with leaf foo"
+          [Number 42]
+          (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), (Leaf (Symbol "foo"))])
+    ]

From b390b67c5f35c9ec4764b14c8cc31bbfc0bf9f50 Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Tue, 5 Dec 2023 16:49:25 +0100
Subject: [PATCH 13/20] Add more tests

---
 app/Main.hs  | 45 +--------------------------------------------
 test/Spec.hs | 28 ++++++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 44 deletions(-)

diff --git a/app/Main.hs b/app/Main.hs
index 716fc38..6084e1e 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -5,48 +5,5 @@
 -- Main
 -}
 
-import ComputeAST
-import AST
-import Defines
-
--- Foo = 42
-test0 :: Tree
-test0 = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
-
-test1 :: Tree
-test1 = Leaf (Symbol "foo")
-
--- Bar = 21
-test2 :: Tree
-test2 = Node "define" (Just (Leaf (Symbol "bar"))) (Just (Leaf (Number 21)))
-
--- 21 + 21 (result = 42)
-test3 :: Tree
-test3 = Node "+" (Just (Leaf (Number 21))) (Just (Leaf (Number 21)))
-
--- Foo + 42 (result = 42 + 42 = 84)
-test4 :: Tree
-test4 = Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
-
--- Foo + Bar (result = 42 + 21 = 63)
-test5 :: Tree
-test5 = Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Symbol "bar")))
-
--- 2 + (5 * 2) (result = 12)
-test6 :: Tree
-test6 = Node "+" (Just (Leaf (Number 2))) (Just (Node "*" (Just (Leaf (Number 5))) (Just (Leaf (Number 2)))))
-
--- 2 + (foo / 2) (result = 23)
-test7 :: Tree
-test7 = Node "+" (Just (Leaf (Number 2))) (Just (Node "/" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))
-
--- 2 + 2 + (5 * 2) (result = 14)
-test8 :: Tree
-test8 = Node "+" (Just (Leaf (Number 2))) (Just (Node "+" (Just (Leaf (Number 2))) (Just (Node "*" (Just (Leaf (Number 5))) (Just (Leaf (Number 2)))))))
-
--- (2 * 5) + (foo / 2) (result = 10 + 21 = 31)
-test9 :: Tree
-test9 = Node "+" (Just (Node "*" (Just (Leaf (Number 2))) (Just (Leaf (Number 5))))) (Just (Node "/" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))
-
 main :: IO ()
-main = putStrLn $ show $ computeAllAST (Env []) [test0, test1, test2, test3, test4, test5, test6, test7, test8, test9]
+main = putStrLn "Test"
diff --git a/test/Spec.hs b/test/Spec.hs
index 05da02e..fefe0b7 100644
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -163,4 +163,32 @@ unitTestASTCompute = testGroup "AST compute Tests"
         assertEqual "define foo 42 and tree with leaf foo"
           [Number 42]
           (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), (Leaf (Symbol "foo"))])
+    , testCase "test3" $
+        assertEqual "define foo 42 and do foo + 42"
+          [Number 84]
+          (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), (Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42))))])
+    , testCase "test3" $
+        assertEqual "define foo 42 and do 42 + foo"
+          [Number 84]
+          (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), (Node "+" (Just (Leaf (Number 42))) (Just (Leaf (Symbol "foo"))))])
+    , testCase "test5" $
+        assertEqual "define foo 42 and do foo + foo"
+          [Number 84]
+          (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), (Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Symbol "foo"))))])
+    , testCase "test6" $
+        assertEqual "define foo 42 and bar 21 and do foo + bar"
+          [Number 63]
+          (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), (Node "define" (Just (Leaf (Symbol "bar"))) (Just (Leaf (Number 21)))), (Node "+" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Symbol "bar"))))])
+    , testCase "test7" $
+        assertEqual "2 + (5 * 2) (result = 12)"
+          [Number 12]
+          (computeAllAST (Env []) [(Node "+" (Just (Leaf (Number 2))) (Just (Node "*" (Just (Leaf (Number 5))) (Just (Leaf (Number 2))))))])
+    , testCase "test8" $
+        assertEqual "(2 * 5) + (foo / 2) (result = 10 + 21 = 31)"
+          [Number 31]
+          (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), Node "+" (Just (Node "*" (Just (Leaf (Number 2))) (Just (Leaf (Number 5))))) (Just (Node "/" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))])
+    , testCase "test9" $
+        assertEqual "2 + 2 + (5 * 2) (result = 14)"
+          [Number 14]
+          (computeAllAST (Env []) [(Node "+" (Just (Leaf (Number 2))) (Just (Node "+" (Just (Leaf (Number 2))) (Just (Node "*" (Just (Leaf (Number 5))) (Just (Leaf (Number 2))))))))])
     ]

From 32af3672248abacad6127475b1b47bdc1856ac92 Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Wed, 6 Dec 2023 02:45:07 +0100
Subject: [PATCH 14/20] add work in progress

---
 src/ComputeAST.hs | 13 ++++++++-----
 src/Defines.hs    |  4 ++++
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index 020920a..361a188 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -7,6 +7,7 @@
 
 module ComputeAST
     (
+        computeAST,
         computeAllAST
     ) where
 
@@ -92,12 +93,14 @@ computeTree env tree = computeTree env (resolveDeepestNode env tree)
 ------------ COMPUTE AST ------------
 
 -- Call appropriate function depending on the node
-computeAST :: Env -> [Atom] -> Tree -> (Env, [Atom])
-computeAST env atoms tree@(Node "define" _ _) = (registerDefine env tree, atoms)
-computeAST env atoms tree = (env, atoms ++ [computeTree env tree])
+computeAST :: Env -> Tree -> (Env, Maybe Atom)
+computeAST env tree@(Node "define" _ _) = (registerDefine env tree, Nothing)
+computeAST env tree = (env, Just (computeTree env tree))
 
 -- Call computeAST on every tree in the list
 computeAllAST :: Env -> [Tree] -> [Atom]
 computeAllAST _ [] = []
-computeAllAST env (tree:rest) = atoms ++ computeAllAST newEnv rest
-    where (newEnv, atoms) = computeAST env [] tree
+computeAllAST env (tree:rest) = case atom of
+    Just atom -> atom : computeAllAST newEnv rest
+    Nothing -> computeAllAST newEnv rest
+    where (newEnv, atom) = computeAST env tree
diff --git a/src/Defines.hs b/src/Defines.hs
index 9cae72b..9a6bae2 100644
--- a/src/Defines.hs
+++ b/src/Defines.hs
@@ -25,6 +25,10 @@ data Env = Env {
     defines :: [Define]
 } deriving (Show)
 
+instance Eq Env where
+    (Env []) == (Env []) = True
+    _ == _ = True
+
 -- Register a define in the Defines list
 registerDefine :: Env -> Tree -> Env
 registerDefine env

From 2dd3c0d35eb614b658b0a6ee2488651f9ca4f2b9 Mon Sep 17 00:00:00 2001
From: tenshi <tenshii.tv@gmail.com>
Date: Wed, 6 Dec 2023 03:10:04 +0100
Subject: [PATCH 15/20] Divide files

---
 app/Main.hs       | 22 ++++++++++++++++++-
 koaky.cabal       |  1 +
 src/ComputeAST.hs | 55 ++++-------------------------------------------
 src/Defines.hs    | 17 +++++++++++----
 src/Functions.hs  | 49 +++++++++++++++++++++++++++++++++++++++++
 5 files changed, 88 insertions(+), 56 deletions(-)
 create mode 100644 src/Functions.hs

diff --git a/app/Main.hs b/app/Main.hs
index 6084e1e..98f205e 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -5,5 +5,25 @@
 -- Main
 -}
 
+import ComputeAST
+import AST
+import Defines
+
+-- Foo = 42
+test1 :: Tree
+test1 = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
+
+-- 21 + 21 (result = 42)
+test2 :: Tree
+test2 = Node "+" (Just (Leaf (Number 21))) (Just (Leaf (Number 21)))
+
+-- bool = true
+test3 :: Tree
+test3 = Leaf (Boolean True)
+
+-- bool = false
+test4 :: Tree
+test4 = Leaf (Boolean False)
+
 main :: IO ()
-main = putStrLn "Test"
+main = print $ computeAllAST (Env []) [test1, test2, test3, test4]
diff --git a/koaky.cabal b/koaky.cabal
index fad12e2..6b57065 100644
--- a/koaky.cabal
+++ b/koaky.cabal
@@ -28,6 +28,7 @@ library
       AST
       ComputeAST
       Defines
+      Functions
       TextToAST
   other-modules:
       Paths_koaky
diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index 361a188..c58efaf 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -14,53 +14,7 @@ module ComputeAST
 import AST
 import Defines
 import Data.Int (Int64)
-
--- TODO: Handle case where the define is a string / not defined
-getSymbolValue :: Env -> String -> Int64
-getSymbolValue (Env []) _ = 0
-getSymbolValue (Env ((Define symbol value):rest)) symbolToFind
-    | symbol == symbolToFind = case value of
-        (Number number) -> number
-        (Symbol _) -> 0
-    | otherwise = getSymbolValue (Env rest) symbolToFind
-
------------- ADD SUB MUL FUNCTIONS ------------
-
--- Compute a "+" node, using defines if needed
--- Todo: See for better error handling in last line
-additionTree :: Env -> Tree -> Int64
-additionTree _ (Node "+" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left + right
-additionTree env (Node "+" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left + getSymbolValue env right
-additionTree env (Node "+" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left + right
-additionTree env (Node "+" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left + getSymbolValue env right
-additionTree _ _ = 0
-
--- Compute a "-" node, using defines if needed
--- Todo: See for better error handling in last line
-substactionTree :: Env -> Tree -> Int64
-substactionTree _ (Node "-" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left - right
-substactionTree env (Node "-" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left - getSymbolValue env right
-substactionTree env (Node "-" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left - right
-substactionTree env (Node "-" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left - getSymbolValue env right
-substactionTree _ _ = 0
-
--- Compute a "*" node, using defines if needed
--- Todo: See for better error handling in last line
-multiplicationTree :: Env -> Tree -> Int64
-multiplicationTree _ (Node "*" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left * right
-multiplicationTree env (Node "*" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left * getSymbolValue env right
-multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left * right
-multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left * getSymbolValue env right
-multiplicationTree _ _ = 0
-
--- Compute a "/" node, using defines if needed
--- Todo: See for better error handling in last line + division by 0
-divisionTree :: Env -> Tree -> Int64
-divisionTree _ (Node "/" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left `div` right
-divisionTree env (Node "/" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left `div` getSymbolValue env right
-divisionTree env (Node "/" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left `div` right
-divisionTree env (Node "/" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left `div` getSymbolValue env right
-divisionTree _ _ = 0
+import Functions
 
 ------------ ComputeNode ------------
 
@@ -74,7 +28,6 @@ computeNode _ _ = 0
 
 ------------ Resolve deepest ------------
 
--- Compute the deepest node of the tree, it is when right and left node are a leaf and not a node
 resolveDeepestNode :: Env -> Tree -> Tree
 resolveDeepestNode env (Node symbol (Just (Leaf left)) (Just (Leaf right))) = Leaf (Number (computeNode env (Node symbol (Just (Leaf left)) (Just (Leaf right)))))
 resolveDeepestNode env (Node symbol (Just (Leaf left)) (Just right)) = Node symbol (Just (Leaf left)) (Just $ resolveDeepestNode env right)
@@ -88,11 +41,11 @@ resolveDeepestNode _ _ = (Leaf (Number 0))
 computeTree :: Env -> Tree -> Atom
 computeTree env (Leaf (Symbol symbol)) = Number (getSymbolValue env symbol)
 computeTree _ (Leaf (Number number)) = Number number
+computeTree _ (Leaf (Boolean value)) = Boolean value
 computeTree env tree = computeTree env (resolveDeepestNode env tree)
 
 ------------ COMPUTE AST ------------
 
--- Call appropriate function depending on the node
 computeAST :: Env -> Tree -> (Env, Maybe Atom)
 computeAST env tree@(Node "define" _ _) = (registerDefine env tree, Nothing)
 computeAST env tree = (env, Just (computeTree env tree))
@@ -100,7 +53,7 @@ computeAST env tree = (env, Just (computeTree env tree))
 -- Call computeAST on every tree in the list
 computeAllAST :: Env -> [Tree] -> [Atom]
 computeAllAST _ [] = []
-computeAllAST env (tree:rest) = case atom of
+computeAllAST env (tree:rest) = case atom' of
     Just atom -> atom : computeAllAST newEnv rest
     Nothing -> computeAllAST newEnv rest
-    where (newEnv, atom) = computeAST env tree
+    where (newEnv, atom') = computeAST env tree
diff --git a/src/Defines.hs b/src/Defines.hs
index 9a6bae2..7fe80cd 100644
--- a/src/Defines.hs
+++ b/src/Defines.hs
@@ -10,24 +10,33 @@ module Defines
         Define (Define),
         Env (Env),
         registerDefine,
+        getSymbolValue
     ) where
 
 import AST
+import Data.Int (Int64)
  
 -- Define = <SYMBOL> <EXPRESSION>
-
 data Define = Define {
     symbol :: String,
     expression :: Atom
 } deriving (Show)
 
+-- used to store defines, and more in the future
 data Env = Env {
     defines :: [Define]
 } deriving (Show)
 
-instance Eq Env where
-    (Env []) == (Env []) = True
-    _ == _ = True
+-- TODO: Handle case where the define is a lambda / not defined
+getSymbolValue :: Env -> String -> Int64
+getSymbolValue (Env []) _ = 0
+getSymbolValue (Env ((Define symbl value):rest)) symbolToFind
+    | symbl == symbolToFind = case value of
+        (Number number) -> number
+        (Boolean True) -> 1
+        (Boolean False) -> 0
+        (Symbol _) -> 0
+    | otherwise = getSymbolValue (Env rest) symbolToFind
 
 -- Register a define in the Defines list
 registerDefine :: Env -> Tree -> Env
diff --git a/src/Functions.hs b/src/Functions.hs
new file mode 100644
index 0000000..513b20a
--- /dev/null
+++ b/src/Functions.hs
@@ -0,0 +1,49 @@
+{-
+-- EPITECH PROJECT, 2023
+-- Koaky
+-- File description:
+-- ComputeAST
+-}
+
+module Functions
+    (
+        additionTree,
+        substactionTree,
+        multiplicationTree,
+        divisionTree
+    ) where
+
+import AST
+import Defines
+import Data.Int (Int64)
+
+-- Compute a "+ - / *" node, using defines if needed
+-- Todo: See for an error handling and division by 0
+
+additionTree :: Env -> Tree -> Int64
+additionTree _ (Node "+" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left + right
+additionTree env (Node "+" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left + getSymbolValue env right
+additionTree env (Node "+" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left + right
+additionTree env (Node "+" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left + getSymbolValue env right
+additionTree _ _ = 0
+
+substactionTree :: Env -> Tree -> Int64
+substactionTree _ (Node "-" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left - right
+substactionTree env (Node "-" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left - getSymbolValue env right
+substactionTree env (Node "-" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left - right
+substactionTree env (Node "-" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left - getSymbolValue env right
+substactionTree _ _ = 0
+
+multiplicationTree :: Env -> Tree -> Int64
+multiplicationTree _ (Node "*" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left * right
+multiplicationTree env (Node "*" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left * getSymbolValue env right
+multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left * right
+multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left * getSymbolValue env right
+multiplicationTree _ _ = 0
+
+divisionTree :: Env -> Tree -> Int64
+divisionTree _ (Node "/" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left `div` right
+divisionTree env (Node "/" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left `div` getSymbolValue env right
+divisionTree env (Node "/" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left `div` right
+divisionTree env (Node "/" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left `div` getSymbolValue env right
+divisionTree _ _ = 0

From 960e364afc203a765a0e238625931dcffa9bd318 Mon Sep 17 00:00:00 2001
From: tenshi <tenshii.tv@gmail.com>
Date: Wed, 6 Dec 2023 03:15:34 +0100
Subject: [PATCH 16/20] Clean files

---
 app/Main.hs       | 22 +---------------------
 scripts/Build.ps1 | 11 -----------
 2 files changed, 1 insertion(+), 32 deletions(-)
 delete mode 100644 scripts/Build.ps1

diff --git a/app/Main.hs b/app/Main.hs
index 98f205e..fa4fbd5 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -5,25 +5,5 @@
 -- Main
 -}
 
-import ComputeAST
-import AST
-import Defines
-
--- Foo = 42
-test1 :: Tree
-test1 = Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))
-
--- 21 + 21 (result = 42)
-test2 :: Tree
-test2 = Node "+" (Just (Leaf (Number 21))) (Just (Leaf (Number 21)))
-
--- bool = true
-test3 :: Tree
-test3 = Leaf (Boolean True)
-
--- bool = false
-test4 :: Tree
-test4 = Leaf (Boolean False)
-
 main :: IO ()
-main = print $ computeAllAST (Env []) [test1, test2, test3, test4]
+main = print "Koaky koaky"
diff --git a/scripts/Build.ps1 b/scripts/Build.ps1
deleted file mode 100644
index 5a07d83..0000000
--- a/scripts/Build.ps1
+++ /dev/null
@@ -1,11 +0,0 @@
-if (Test-Path ".\koaky.exe")
-{
-    Remove-Item ".\koaky.exe"
-}
-
-stack build --copy-bins --local-bin-path .
-
-if (Test-Path ".\koaky-exe.exe")
-{
-    Rename-Item ".\koaky-exe.exe" "koaky.exe"
-}

From 284c0c530b415ebedfcc31c4954fa97b3ab4fc5f Mon Sep 17 00:00:00 2001
From: tenshi <tenshii.tv@gmail.com>
Date: Wed, 6 Dec 2023 03:23:30 +0100
Subject: [PATCH 17/20] fix coding style

---
 src/ComputeAST.hs | 18 ++++++++++++++----
 src/Functions.hs  | 48 +++++++++++++++++++++++++++++++----------------
 2 files changed, 46 insertions(+), 20 deletions(-)

diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index c58efaf..8e5872d 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -29,10 +29,20 @@ computeNode _ _ = 0
 ------------ Resolve deepest ------------
 
 resolveDeepestNode :: Env -> Tree -> Tree
-resolveDeepestNode env (Node symbol (Just (Leaf left)) (Just (Leaf right))) = Leaf (Number (computeNode env (Node symbol (Just (Leaf left)) (Just (Leaf right)))))
-resolveDeepestNode env (Node symbol (Just (Leaf left)) (Just right)) = Node symbol (Just (Leaf left)) (Just $ resolveDeepestNode env right)
-resolveDeepestNode env (Node symbol (Just left) (Just (Leaf right))) = Node symbol (Just $ resolveDeepestNode env left) (Just (Leaf right))
-resolveDeepestNode env (Node symbol (Just left) (Just right)) = Node symbol (Just $ resolveDeepestNode env left) (Just $ resolveDeepestNode env right)
+-- Node [Leaf] [Leaf]
+resolveDeepestNode env (Node symbol (Just (Leaf left)) (Just (Leaf right))) =
+    Leaf (Number (computeNode env
+        (Node symbol (Just (Leaf left)) (Just (Leaf right)))))
+-- Node [Leaf] [Node]
+resolveDeepestNode env (Node symbol (Just (Leaf left)) (Just right)) =
+    Node symbol (Just (Leaf left)) (Just $ resolveDeepestNode env right)
+-- Node [Node] [Leaf]
+resolveDeepestNode env (Node symbol (Just left) (Just (Leaf right))) =
+    Node symbol (Just $ resolveDeepestNode env left) (Just (Leaf right))
+-- Node [Node] [Node]
+resolveDeepestNode env (Node symbol (Just left) (Just right)) =
+    Node symbol (Just $ resolveDeepestNode env left)
+        (Just $ resolveDeepestNode env right)
 -- TODO: Error handling
 resolveDeepestNode _ _ = (Leaf (Number 0))
 
diff --git a/src/Functions.hs b/src/Functions.hs
index 513b20a..2d32f2c 100644
--- a/src/Functions.hs
+++ b/src/Functions.hs
@@ -21,29 +21,45 @@ import Data.Int (Int64)
 -- Todo: See for an error handling and division by 0
 
 additionTree :: Env -> Tree -> Int64
-additionTree _ (Node "+" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left + right
-additionTree env (Node "+" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left + getSymbolValue env right
-additionTree env (Node "+" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left + right
-additionTree env (Node "+" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left + getSymbolValue env right
+additionTree _ (Node "+" (Just (Leaf (Number left)))
+    (Just (Leaf (Number right)))) = left + right
+additionTree env (Node "+" (Just (Leaf (Number left)))
+    (Just (Leaf (Symbol right)))) = left + getSymbolValue env right
+additionTree env (Node "+" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Number right)))) = getSymbolValue env left + right
+additionTree env (Node "+" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Symbol right)))) = getSymbolValue env left + getSymbolValue env right
 additionTree _ _ = 0
 
 substactionTree :: Env -> Tree -> Int64
-substactionTree _ (Node "-" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left - right
-substactionTree env (Node "-" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left - getSymbolValue env right
-substactionTree env (Node "-" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left - right
-substactionTree env (Node "-" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left - getSymbolValue env right
+substactionTree _ (Node "-" (Just (Leaf (Number left)))
+    (Just (Leaf (Number right)))) = left - right
+substactionTree env (Node "-" (Just (Leaf (Number left)))
+    (Just (Leaf (Symbol right)))) = left - getSymbolValue env right
+substactionTree env (Node "-" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Number right)))) = getSymbolValue env left - right
+substactionTree env (Node "-" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Symbol right)))) = getSymbolValue env left - getSymbolValue env right
 substactionTree _ _ = 0
 
 multiplicationTree :: Env -> Tree -> Int64
-multiplicationTree _ (Node "*" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left * right
-multiplicationTree env (Node "*" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left * getSymbolValue env right
-multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left * right
-multiplicationTree env (Node "*" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left * getSymbolValue env right
+multiplicationTree _ (Node "*" (Just (Leaf (Number left)))
+    (Just (Leaf (Number right)))) = left * right
+multiplicationTree env (Node "*" (Just (Leaf (Number left)))
+    (Just (Leaf (Symbol right)))) = left * getSymbolValue env right
+multiplicationTree env (Node "*" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Number right)))) = getSymbolValue env left * right
+multiplicationTree env (Node "*" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Symbol right)))) = getSymbolValue env left * getSymbolValue env right
 multiplicationTree _ _ = 0
 
 divisionTree :: Env -> Tree -> Int64
-divisionTree _ (Node "/" (Just (Leaf (Number left))) (Just (Leaf (Number right)))) = left `div` right
-divisionTree env (Node "/" (Just (Leaf (Number left))) (Just (Leaf (Symbol right)))) = left `div` getSymbolValue env right
-divisionTree env (Node "/" (Just (Leaf (Symbol left))) (Just (Leaf (Number right)))) = getSymbolValue env left `div` right
-divisionTree env (Node "/" (Just (Leaf (Symbol left))) (Just (Leaf (Symbol right)))) = getSymbolValue env left `div` getSymbolValue env right
+divisionTree _ (Node "/" (Just (Leaf (Number left)))
+    (Just (Leaf (Number right)))) = left `div` right
+divisionTree env (Node "/" (Just (Leaf (Number left)))
+    (Just (Leaf (Symbol right)))) = left `div` getSymbolValue env right
+divisionTree env (Node "/" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Number right)))) = getSymbolValue env left `div` right
+divisionTree env (Node "/" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Symbol right)))) = getSymbolValue env left `div` getSymbolValue env right
 divisionTree _ _ = 0

From 78403eff11f32d540657c649da310642adf6a450 Mon Sep 17 00:00:00 2001
From: tenshi <tenshii.tv@gmail.com>
Date: Wed, 6 Dec 2023 03:27:22 +0100
Subject: [PATCH 18/20] Fix coding style

---
 src/Functions.hs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/Functions.hs b/src/Functions.hs
index 2d32f2c..d2c0b66 100644
--- a/src/Functions.hs
+++ b/src/Functions.hs
@@ -28,7 +28,8 @@ additionTree env (Node "+" (Just (Leaf (Number left)))
 additionTree env (Node "+" (Just (Leaf (Symbol left)))
     (Just (Leaf (Number right)))) = getSymbolValue env left + right
 additionTree env (Node "+" (Just (Leaf (Symbol left)))
-    (Just (Leaf (Symbol right)))) = getSymbolValue env left + getSymbolValue env right
+    (Just (Leaf (Symbol right)))) =
+        getSymbolValue env left + getSymbolValue env right
 additionTree _ _ = 0
 
 substactionTree :: Env -> Tree -> Int64
@@ -39,7 +40,8 @@ substactionTree env (Node "-" (Just (Leaf (Number left)))
 substactionTree env (Node "-" (Just (Leaf (Symbol left)))
     (Just (Leaf (Number right)))) = getSymbolValue env left - right
 substactionTree env (Node "-" (Just (Leaf (Symbol left)))
-    (Just (Leaf (Symbol right)))) = getSymbolValue env left - getSymbolValue env right
+    (Just (Leaf (Symbol right)))) =
+        getSymbolValue env left - getSymbolValue env right
 substactionTree _ _ = 0
 
 multiplicationTree :: Env -> Tree -> Int64
@@ -50,7 +52,8 @@ multiplicationTree env (Node "*" (Just (Leaf (Number left)))
 multiplicationTree env (Node "*" (Just (Leaf (Symbol left)))
     (Just (Leaf (Number right)))) = getSymbolValue env left * right
 multiplicationTree env (Node "*" (Just (Leaf (Symbol left)))
-    (Just (Leaf (Symbol right)))) = getSymbolValue env left * getSymbolValue env right
+    (Just (Leaf (Symbol right)))) =
+        getSymbolValue env left * getSymbolValue env right
 multiplicationTree _ _ = 0
 
 divisionTree :: Env -> Tree -> Int64
@@ -61,5 +64,6 @@ divisionTree env (Node "/" (Just (Leaf (Number left)))
 divisionTree env (Node "/" (Just (Leaf (Symbol left)))
     (Just (Leaf (Number right)))) = getSymbolValue env left `div` right
 divisionTree env (Node "/" (Just (Leaf (Symbol left)))
-    (Just (Leaf (Symbol right)))) = getSymbolValue env left `div` getSymbolValue env right
+    (Just (Leaf (Symbol right)))) =
+        getSymbolValue env left `div` getSymbolValue env right
 divisionTree _ _ = 0

From 012aa59034e27c3a3dce156b854a1ce60d181205 Mon Sep 17 00:00:00 2001
From: Tenshi <tenshii.tv@gmail.com>
Date: Wed, 6 Dec 2023 16:48:21 +0100
Subject: [PATCH 19/20] Add support of modulo MINOR

---
 src/ComputeAST.hs |  3 ++-
 src/Functions.hs  | 25 +++++++++++++++++++------
 test/Spec.hs      |  6 +++++-
 3 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/src/ComputeAST.hs b/src/ComputeAST.hs
index 8e5872d..1d163ab 100644
--- a/src/ComputeAST.hs
+++ b/src/ComputeAST.hs
@@ -22,7 +22,8 @@ computeNode :: Env -> Tree -> Int64
 computeNode env tree@(Node "+" _ _) = additionTree env tree
 computeNode env tree@(Node "-" _ _) = substactionTree env tree
 computeNode env tree@(Node "*" _ _) = multiplicationTree env tree
-computeNode env tree@(Node "/" _ _) = divisionTree env tree
+computeNode env tree@(Node "div" _ _) = divisionTree env tree
+computeNode env tree@(Node "mod" _ _) = moduloTree env tree
 -- TODO: Error handling
 computeNode _ _ = 0
 
diff --git a/src/Functions.hs b/src/Functions.hs
index d2c0b66..519f8b7 100644
--- a/src/Functions.hs
+++ b/src/Functions.hs
@@ -10,14 +10,15 @@ module Functions
         additionTree,
         substactionTree,
         multiplicationTree,
-        divisionTree
+        divisionTree,
+        moduloTree
     ) where
 
 import AST
 import Defines
 import Data.Int (Int64)
 
--- Compute a "+ - / *" node, using defines if needed
+-- Compute a "+ - div * mod" node, using defines if needed
 -- Todo: See for an error handling and division by 0
 
 additionTree :: Env -> Tree -> Int64
@@ -57,13 +58,25 @@ multiplicationTree env (Node "*" (Just (Leaf (Symbol left)))
 multiplicationTree _ _ = 0
 
 divisionTree :: Env -> Tree -> Int64
-divisionTree _ (Node "/" (Just (Leaf (Number left)))
+divisionTree _ (Node "div" (Just (Leaf (Number left)))
     (Just (Leaf (Number right)))) = left `div` right
-divisionTree env (Node "/" (Just (Leaf (Number left)))
+divisionTree env (Node "div" (Just (Leaf (Number left)))
     (Just (Leaf (Symbol right)))) = left `div` getSymbolValue env right
-divisionTree env (Node "/" (Just (Leaf (Symbol left)))
+divisionTree env (Node "div" (Just (Leaf (Symbol left)))
     (Just (Leaf (Number right)))) = getSymbolValue env left `div` right
-divisionTree env (Node "/" (Just (Leaf (Symbol left)))
+divisionTree env (Node "div" (Just (Leaf (Symbol left)))
     (Just (Leaf (Symbol right)))) =
         getSymbolValue env left `div` getSymbolValue env right
 divisionTree _ _ = 0
+
+moduloTree :: Env -> Tree -> Int64
+moduloTree _ (Node "mod" (Just (Leaf (Number left)))
+    (Just (Leaf (Number right)))) = left `mod` right
+moduloTree env (Node "mod" (Just (Leaf (Number left)))
+    (Just (Leaf (Symbol right)))) = left `mod` getSymbolValue env right
+moduloTree env (Node "mod" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Number right)))) = getSymbolValue env left `mod` right
+moduloTree env (Node "mod" (Just (Leaf (Symbol left)))
+    (Just (Leaf (Symbol right)))) =
+        getSymbolValue env left `mod` getSymbolValue env right
+moduloTree _ _ = 0
diff --git a/test/Spec.hs b/test/Spec.hs
index fefe0b7..189bc7f 100644
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -186,9 +186,13 @@ unitTestASTCompute = testGroup "AST compute Tests"
     , testCase "test8" $
         assertEqual "(2 * 5) + (foo / 2) (result = 10 + 21 = 31)"
           [Number 31]
-          (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), Node "+" (Just (Node "*" (Just (Leaf (Number 2))) (Just (Leaf (Number 5))))) (Just (Node "/" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))])
+          (computeAllAST (Env []) [(Node "define" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 42)))), Node "+" (Just (Node "*" (Just (Leaf (Number 2))) (Just (Leaf (Number 5))))) (Just (Node "div" (Just (Leaf (Symbol "foo"))) (Just (Leaf (Number 2)))))])
     , testCase "test9" $
         assertEqual "2 + 2 + (5 * 2) (result = 14)"
           [Number 14]
           (computeAllAST (Env []) [(Node "+" (Just (Leaf (Number 2))) (Just (Node "+" (Just (Leaf (Number 2))) (Just (Node "*" (Just (Leaf (Number 5))) (Just (Leaf (Number 2))))))))])
+    , testCase "test10" $
+        assertEqual "14 mod 5 (result = 4)"
+          [Number 4]
+          (computeAllAST (Env []) [(Node "mod" (Just (Leaf (Number 14))) (Just (Leaf (Number 5))))])
     ]

From c8c5584c9ff41016a3748f397b44e6f1a98fab4a Mon Sep 17 00:00:00 2001
From: Xavier Mitault <xavier.mitault@epitech.eu>
Date: Wed, 6 Dec 2023 17:38:49 +0000
Subject: [PATCH 20/20] Fix compil

PATCH
---
 app/Main.hs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/app/Main.hs b/app/Main.hs
index e50dec0..47297c3 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -5,5 +5,8 @@
 -- Main
 -}
 
+import AST
+import TextToAST
+
 main :: IO ()
 main = putStrLn (showMaybeTree (textToAST "(fst 1 (scd 2 3 4) 12)"))