From 9d1a80bf2bfaf85e1f7de77d4b70b5fd78051cf5 Mon Sep 17 00:00:00 2001
From: Laborratte5 <laborratte5@gmail.com>
Date: Wed, 17 Jul 2024 21:21:28 +0200
Subject: [PATCH] Implement Parsing for Tokens of AST

---
 app/Lexer.hs  |  2 +-
 app/Parser.hs | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/app/Lexer.hs b/app/Lexer.hs
index 8164f48..e85d2e8 100644
--- a/app/Lexer.hs
+++ b/app/Lexer.hs
@@ -7,7 +7,7 @@ data Token = Plus
            | Integer Int
            | LBrace
            | RBrace
-           deriving Show
+           deriving (Eq, Show)
 
 lex :: String -> [Token]
 lex source = reverse (lex' source [] (length source))
diff --git a/app/Parser.hs b/app/Parser.hs
index 5f8f718..d6faf95 100644
--- a/app/Parser.hs
+++ b/app/Parser.hs
@@ -2,6 +2,7 @@ module Parser where
 
 import qualified Lexer as L
 import Control.Applicative as Applicative
+import Data.Void as Void
 
 type AST = Expr
 
@@ -43,3 +44,52 @@ instance Alternative Parser where
     (<|>) (Parser p1) (Parser p2) = Parser $ \input -> case p1 input of
         Nothing -> p2 input
         result -> result
+
+
+parseAdd :: Parser Expr
+parseAdd = liftA2 Add (parseTerm <* expect L.Plus) parseExpression
+
+parseSub :: Parser Expr
+parseSub = liftA2 Sub (parseTerm <* expect L.Hyphen) parseExpression
+
+parseETerm :: Parser Expr
+parseETerm = ETerm <$> parseTerm
+
+parseExpression :: Parser Expr
+parseExpression = parseAdd <|> parseSub <|> parseETerm
+
+
+parseMult :: Parser Term
+parseMult = liftA2 Mult (parseFactor <* expect L.Asterisk) parseTerm
+
+parseDiv :: Parser Term
+parseDiv = liftA2 Div (parseFactor <* expect L.ForwardSlash) parseTerm
+
+parseTFactor :: Parser Term
+parseTFactor = TFactor <$> parseFactor
+
+parseTerm :: Parser Term
+parseTerm = parseMult <|> parseDiv <|> parseTFactor
+
+
+parseFactor :: Parser Factor
+parseFactor = parseInt <|> parseParatheses <|> parseNegFactor
+
+parseInt :: Parser Factor
+parseInt = Parser $ \(token:rest) -> case token of
+    L.Integer i -> Just (rest, Integer i)
+    _ -> Nothing
+
+parseNegFactor :: Parser Factor
+parseNegFactor = NegFactor <$> (expect L.Hyphen *> parseFactor)
+
+parseParatheses :: Parser Factor
+parseParatheses = Parantheses <$> (expect L.LBrace *> parseExpression <* expect L.RBrace)
+
+
+expect :: L.Token -> Parser (Maybe Void)
+expect token = Parser $ \stream -> case stream of
+    (t:rest) -> if t == token
+                then Just (rest, Nothing)
+                else Nothing
+    _ -> Nothing