Parser

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import Parsing

expr                          :: Parser Int
expr                          =  do t <- term
                                    do symbol "+"               
                                       e <- expr
                                       return (t+e)
				      +++ do symbol "-"
					     e <- expr
					     return (t-e)
				      +++ return t
term                          :: Parser Int
term                          =  do f <- factor
                                    do symbol "*"
                                       t <- term
                                       return (f * t)
				      +++ do symbol "/"
					     t <- term
					     return (f-t)
				      +++ return f
factor                        :: Parser Int
factor                        =  do symbol "("
                                    e <- expr
                                    symbol ")"
                                    return e
                                  +++ natural
eval                          :: String -> Int
eval xs                       =  case (parse expr xs) of
                                    [(n,[])]  -> n
                                    [(_,out)] -> error ("unused input " ++ out)
                                    []        -> error "invalid input"


p :: [String] -> Int

p [] = []

p (x:xs) = eval x
28:34: Warning: Redundant bracket
Found:
case (parse expr xs) of
[(n, [])] -> n
[(_, out)] -> error ("unused input " ++ out)
[] -> error "invalid input"
Why not:
case parse expr xs of
[(n, [])] -> n
[(_, out)] -> error ("unused input " ++ out)
[] -> error "invalid input"

Parser (annotation)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import Parsing

expr :: Parser Int
expr =  do t <- term
           do symbol "+"               
              e <- expr
              return (t+e)
             +++ do symbol "-"
                    e <- expr
                    return (t-e)
             +++ return t

term :: Parser Int
term =  do f <- factor
           do symbol "*"
              t <- term
              return (f * t)
             +++ do symbol "/"
                    t <- term
                    return (f-t)
             +++ return f

factor :: Parser Int
factor =  do symbol "("
             e <- expr
             symbol ")"
             return e
          +++ natural

eval :: String -> Int
eval xs =  case parse expr xs of
  [(n,[])]  -> n
  [(_,out)] -> error ("unused input " ++ out)
  []        -> error "invalid input"


p :: [String] -> Int
p [] = []
p (x:xs) = eval x

Parser (annotation) (edit)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import Parsing

expr :: Parser Int
expr =  do t <- term
           do symbol "+"               
              e <- expr
              return (t+e)
             +++ do symbol "-"
                    e <- expr
                    return (t-e)
             +++ return t

term :: Parser Int
term =  do f <- factor
           do symbol "*"
              t <- term
              return (f * t)
             +++ do symbol "/"
                    t <- term
                    return (f-t)
             +++ return f

factor :: Parser Int
factor =  do symbol "("
             e <- expr
             symbol ")"
             return e
          +++ natural

eval :: String -> Int
eval xs =  case parse expr xs of
  [(n,[])]  -> n
  [(_,out)] -> error ("unused input " ++ out)
  []        -> error "invalid input"


p :: [String] -> Int
p [] = 0
p (x:xs) = eval x