Можно ли принудительно отозвать все варианты?

Question

Мне нужно разобрать этот синтаксис для объявления функции

foo x = 1 
Func "foo" (Ident "x") = 1

foo (x = 1) = 1 
Func "foo" (Label "x" 1) = 1

foo x = y = 1 
Func "foo" (Ident "x") = (Label "y" 1)

Я написал этот парсер

module SimpleParser where
import Text.Parsec.String (Parser)
import Text.Parsec.Language (emptyDef)
import Text.Parsec
import qualified Text.Parsec.Token as Tok
import Text.Parsec.Char
import Prelude

lexer :: Tok.TokenParser ()
lexer = Tok.makeTokenParser style
  where
    style = emptyDef {
              Tok.identLetter    = alphaNum
             }

parens :: Parser a -> Parser a
parens = Tok.parens lexer

commaSep :: Parser a -> Parser [a]
commaSep = Tok.commaSep1 lexer

commaSep1 :: Parser a -> Parser [a]
commaSep1 = Tok.commaSep1 lexer


identifier :: Parser String
identifier = Tok.identifier lexer

reservedOp :: String -> Parser ()
reservedOp = Tok.reservedOp lexer

data Expr = IntLit Int | Ident String | Label String Expr | Func String Expr Expr | ExprList [Expr] deriving (Eq, Ord, Show)


integer :: Parser Integer
integer = Tok.integer lexer

litInt :: Parser Expr
litInt = do
  n <- integer
  return $ IntLit (fromInteger n)

ident :: Parser Expr
ident = Ident <$> identifier

paramLabelItem = litInt <|> paramLabel

paramLabel :: Parser Expr
paramLabel = do
  lbl <- try (identifier <* reservedOp "=")
  body <- paramLabelItem
  return $ Label lbl body

paramItem :: Parser Expr
paramItem = parens paramRecord <|> litInt <|> try paramLabel <|> ident

paramRecord :: Parser Expr
paramRecord = ExprList <$> commaSep1 paramItem

func :: Parser Expr
func = do
  name <- identifier
  params <- paramRecord
  reservedOp "="
  body <- paramRecord
  return $ (Func name params body)


parseExpr :: String -> Either ParseError Expr
parseExpr s = parse func "" s

Я могу разобрать foo (x) = 1 но я не могу разобрать foo x = 1

parseExpr "foo x = 1"
Left (line 1, column 10):
unexpected end of input
expecting digit, "," or "="

Я понимаю, что пытается разобрать этот код как Func "foo" (Label "x" 1) и терпит неудачу. Но после неудачи, почему он не может попытаться разобрать его как Func "foo" (Ident "x") = 1

Есть ли способ сделать это?

Также я попытался обменяться ident а также paramLabel

paramItem = parens paramRecord <|> litInt <|> try paramLabel <|> ident
paramItem = parens paramRecord <|> litInt <|> try ident <|> paramLabel

В этом случае я могу разобрать foo x = 1 но я не могу разобрать foo (x = 1) = 2

parseExpr "foo (x = 1) = 2"
Left (line 1, column 8):
unexpected "="
expecting "," or ")"

Answer 1

Вот как я понимаю, как Parsec работает (и не работает):

В:

(try a <|> try b <|> c)

если a выходит из строя, b будет судить, и если b впоследствии терпит неудачу c будет судим

Однако в:

(try a <|> try b <|> c) >> d

если a успешно, но d не удается, Parsec не возвращается и пытается b, однажды a успешно Parsec рассматривает весь выбор как проанализированный и переходит к d, Он никогда не вернется, чтобы попробовать b или же c,

Это не работает либо по той же причине:

(try (try a <|> try b <|> c)) >> d

однажды a или же b успех, весь выбор успешен, и поэтому внешний try преуспевает. Разбор затем переходит к d,

Решение состоит в том, чтобы распространять d с точностью до выбора:

try (a >> d) <|> try (b >> d) <|> (c >> d)

Сейчас если a успешно, но d выходит из строя, b >> d будет судим