ALP Práctica 1

-- EJERCICIO 1
sepBy toma una cadena e intenta aplicar el parser p. En caso de que pueda, aplica el parser sep y repite el proceso mientras pueda. El resultado final es una lista de las partes del string parseables por p que estaban separadas por cadenas parseables por sep entre sí.
symbol toma una cadena como argumento. Elimina todos los espacios del principio de la cadena, revisa que luego la cadena argumento figure y elimina espacios que estén inmediatamente después.


-- EJERCICIO 2
expr :: Parser Int
expr = do t <- term
          (do char '+'
              e <- expr
              return (t + e)
           <|> (do char '-'
                   e <- expr
                   return (t - e)
               <|> return t))

term :: Parser Int
term = do f <- factor
          (do char '*'
              t <- term
              return (f * t)
           <|> (do char '/'
                   t <- term
                   return (div f t)
                <|> return f))


factor :: Parser Int
factor = (do d <- digit
             return (digitToInt d))
          <|> do char '('
                 e <- expr
                 char ')'
                 return e


-- EJERCICIO 3
parentesis :: Parser a -> Parser a
parentesis p = p
               <|> do char '('
                      res <- parentesis p
                      char ')'
                      return res


-- EJERCICIO 4
data Expr = Num Int | BinOp Op Expr Expr deriving Show
data Op = Add | Mul | Min | Div deriving Show

expr :: Parser Expr
expr = do t <- term
          (do char '+'
              e <- expr
              return (BinOp Add t e)
           <|> (do char '-'
                   e <- expr
                   return (BinOp Min t e)
               <|> return t))

term :: Parser Expr
term = do f <- factor
          (do char '*'
              t <- term
              return (BinOp Mul f t)
           <|> (do char '/'
                   t <- term
                   return (BinOp Div f t)
                <|> return f))


factor :: Parser Expr
factor = (do d <- digit
             return (Num (digitToInt d)))
          <|> do char '('
                 e <- expr
                 char ')'
                 return e


-- EJERCICIO 5
data IntOrChar = Num Int | Car Char deriving Show

pAux :: Parser IntOrChar
pAux = do i <- int
          return (Num i)
       <|> do char '\''
              c <- item
              char '\''
              return (Car c)


intchar :: Parser [IntOrChar]
intchar = do char '['
             xs <- sepBy pAux (char ',')
             char ']'
             return xs


-- EJERCICIO 6
pAux :: Parser Basetype
pAux = do i <- string "Int"
          return DInt
          <|> do c <- string "Char"
                 return DChar
          <|> do f <- string "Float"
                 return DFloat


hasktype :: Parser [Basetype]
hasktype = sepBy pAux (string " -> ")


-- EJERCICIO 7
data Hasktype = DInt | DChar | Fun Hasktype Hasktype deriving Show

pAux :: Parser Hasktype
pAux = do i <- string "Int"
          return DInt
          <|> do c <- string "Char"
                 return DChar


hasktype :: Parser Hasktype
hasktype = do p <- pAux
              (do string " -> "
                  ps <- hasktype
                  return (Fun p ps))
               <|> return p


-- EJERCICIO 8
expr -> term exprAux
exprAux -> ε | '+' term exprAux | '-' term exprAux
term -> factor termAux
termAux -> ε | '*' factor termAux | '/' factor termAux
factor -> digit | '(' expr ')'
digit -> '0' | ... | '9'

data Expr = Num Int | BinOp Op Expr Expr deriving Show
data Op = Add | Mul | Min | Div deriving Show

expr :: Parser Expr
expr = do t <- term
          exprAux t

exprAux :: Expr -> Parser Expr
exprAux exp1 = do char '+'
                  t <- term
                  exprAux (BinOp Add exp1 t)
               <|> do char '-'
                      t <- term
                      exprAux (BinOp Min exp1 t)
               <|> return exp1

term :: Parser Expr
term = do f <- factor
          termAux f

termAux :: Expr -> Parser Expr
termAux exp1 = do char '*'
                  f <- factor
                  termAux (BinOp Mul exp1 f)
               <|> do char '/'
                      f <- factor
                      termAux (BinOp Div exp1 f)
               <|> return exp1

factor :: Parser Expr
factor = (do d <- digit
             return (Num (digitToInt d)))
          <|> do char '('
                 e <- expr
                 char ')'
                 return e



-- EJERCICIO 9
data BasicType = BInt | BChar | BFloat deriving Show
data VarType = Variable BasicType DecType deriving Show
data DecType = Pointer DecType | DD DirDecType deriving Show
data DirDecType = Basic String | Array DirDecType Int deriving Show


declaration :: Parser VarType
declaration = do t <- type_specifier
                 d <- declarator
                 char ';'
                 return (Variable t d)


type_specifier :: Parser BasicType
type_specifier = do string "int "
                    return BInt
                    <|> do string "char "
                           return BChar
                    <|> do string "float "
                           return BFloat


declarator :: Parser DecType
declarator = do char '*'
                d <- declarator
                return (Pointer d)
                <|> do dd <- direct_declarator
                       return (DD dd)


direct_declarator :: Parser DirDecType
direct_declarator = do s <- (do char '('
                                s_aux <- direct_declarator
                                char ')'
                                return s_aux
                             <|> do s_aux <-ident
                                    return (Basic s_aux))
                       dda <- direct_declarator_aux
                       return (dda s)



direct_declarator_aux :: Parser (DirDecType -> DirDecType)
direct_declarator_aux =  do char '['
                            n <- nat
                            char ']'
                            arr <- direct_declarator_aux
                            return (\x -> arr (Array x n))
                         <|> return (\x -> x)