module Lecture20 where

-- E    -> F - F | F
-- F    -> (E) | Int
-- Int  -> any integer token

data Token  = LPar
            | RPar 
            | Minus
            | LitInt Int
              deriving Show

data AST  = Node AST AST 
          | Leaf Int 
            deriving Show

parseInt :: [Token] -> Maybe (AST , [Token])
parseInt (LitInt i : ts)  = Just (Leaf i , ts)
parseInt _                = Nothing

parseF :: [Token] -> Maybe (AST , [Token])
parseF (LPar : ts)  =  case parseE ts of
                         Just (a,RPar : ts')  -> Just (a , ts')
                         _                    -> Nothing
parseF ts           =  parseInt ts

parseE :: [Token] -> Maybe (AST , [Token])
parseE ts =  case parseF ts of
                Nothing             ->  Nothing
                Just (l,Minus:ts')  ->  case parseF ts' of
                                          Nothing        -> Nothing
                                          Just (r,ts'')  -> Just (Node l r , ts'')
                Just ats            ->  Just ats