My code results in parse error because of my use of guards

Question

I have the following code:

parseExpr :: [String] -> (Ast,[String])
parseExpr [] = error "Incorrect"
parseExpr (s:ss) | all isDigit s = (Tall (read s),ss)
              | s == "-" = let (e,ss') = parseExpr ss in (Min e,ss')
              | s == "+" = (Sum e e',ss'') where
                           (e,ss') = parseExpr ss
                           (e',ss'') = parseExpr ss'
              | s == "*" = (Mult e e',ss'') where
                           (e,ss') = parseExpr ss
                           (e',ss'') = parseExpr ss'

When I try to run it, I get an error saying "parse error on input '|'. The line it's talking about is this one:

...
                           (e',ss'') = parseExpr ss'
->            | s == "*" = (Mult e e',ss'') where
                           (e,ss') = parseExpr ss
...

I think I understand why. I would think it's because I have two lines above that are not shielded by guards, and that haskell then get's confused when there suddenly appears another guard below. But how can I then add additional guards after these cases?

I've tried using semicolons to separate new lines, but I'm very new with Haskell and therefore don't know much about its syntax.

I think Thomas is right. The parse error probably happens because after parsing the first `where` the code will think your function is over. — lzbernardo, Oct 10 '19 at 15:39
Even ignoring the parse error, using a single `where` in this instance will cut down on a fair amount of duplicate code. — Khuldraeseth na'Barya, Oct 10 '19 at 17:20

Ignat Insarov · Accepted Answer · 2019-10-10T18:26:46.130

There is no need to use braces (although of course you could). But you do need to be careful with indentation. It is not as hard as it may at first seem.

That being said, it is true that you cannot use where inside a guarded expression. You have to use let in such case, like this:

parseExpr :: [String] -> (Ast,[String])
parseExpr [] = error "Incorrect"
parseExpr (s:ss) | all isDigit s = (Tall (read s),ss)
              | s == "-" = let (e,ss') = parseExpr ss in (Min e,ss')
              | s == "+" = let (e,ss') = parseExpr ss
                               (e',ss'') = parseExpr ss'
                           in (Sum e e',ss'')
              | s == "*" = let (e,ss') = parseExpr ss
                               (e',ss'') = parseExpr ss'
                           in (Mult e e',ss'')

However, in your case here, the guard expressions are so simple they can be replaced with pattern matches. (And it is advisable to use the opportunity. Pattern matching is your best friend in Haskell.) In that case you use where.

parseExpr :: [String] -> (Ast,[String])
parseExpr [] = error "Incorrect"
parseExpr (s:ss) | all isDigit s = (Tall (read s),ss)
parseExpr ("-":ss) = (Min e,ss') where (e,ss') = parseExpr ss
parseExpr ("+":ss) = (Sum  e e',ss'') where (e, ss' ) = parseExpr ss
                                            (e',ss'') = parseExpr ss'

parseExpr ("*":ss) = (Mult e e',ss'') where (e, ss' ) = parseExpr ss
                                            (e',ss'') = parseExpr ss'

Thank you! I can see now that I need to learn more about pattern matching. Excellent answer. — Sigurd Setså, Oct 10 '19 at 18:36

My code results in parse error because of my use of guards

1 Answers1