Parsing Haskell/Trifecta：解析完全可选的分号而不污染AST 我重写了这个问题，因为它最初是用一个更简洁的代码示例发布的：

考虑一种完全可选的分号几乎完全为sugar的语言，即：

• ；；傅；酒吧是有效的

• foobar foobar

  有效

• if（+1）；foo

  在语义上不同于if（+1）foo，因此

  不能被视为空白

下面是一个示例解析器：

{-# LANGUAGE OverloadedStrings #-}

import Text.Trifecta
import Text.Trifecta.Delta
import Text.PrettyPrint.ANSI.Leijen (putDoc, (<>), linebreak)
import Control.Monad.Trans.State.Strict
import Control.Applicative

type TestParser a = StateT Int Parser a

data AST a = Foo a | Bar a deriving (Show)

pFoo :: TestParser (AST (Delta, Int))
pFoo = curry Foo <$ string "foo" <*> position <* modify (+1) <*> get

pBar :: TestParser (AST (Delta, Int))
pBar = curry Bar <$ string "bar" <*> position <*> get

pStmt :: TestParser (AST (Delta, Int))
pStmt = semi *> pStmt <|> pFoo <|> pBar <?> "statement"

pTest :: TestParser [AST (Delta, Int)]
pTest = some pStmt

main :: IO ()
main
 = do   let res = parseByteString (evalStateT pTest 0)
                    (Directed "(test)" 0 0 0 0) ";;foo;bar;\nfoo;; foobarbar;;"
        case res of
            Success ast
             -> print ast
            Failure errdoc
             -> putDoc (errdoc <> linebreak)

这是因为它需要一个语句（在

semi*>pStmt

中），但是因为堆叠的分号可以在表达式的开头和结尾加糖，所以我不能确定我是否真的希望在已经需要一个语句之前先需要/解析一个语句

我开发的一个hack是在AST中使用

Nop

作为构造函数，但我真的不想这样做——这感觉像是一个hack，而且在一些文档中使用分号会大大增加内存使用

我正在寻找解决方案/建议

---

尝试使用所需语法的EBNF形式：

expr = "foo" | "bar"
expr with sugar = expr | ";"
program = { [white space], expr with sugar, [white space] }

好的，给你：

pStmt = pFoo <|> pBar

pWhiteStmt = do
    many whitespace
    p <- pStmt
    many whitespace
    return p

pTest = do
    many semi
    pS <- sepEndBy pWhiteStm (some semi)
    eof
    return pS

如果我们希望有一个有效的

“foobbarr；”

，那么我们需要将

pWhiteStmt

解析器更改为下一个：

pWhiteStmt = do
    many whitespace
    p <- some pStmt
    many whitespace
    return p

最后，如果我们仍然希望使用有效的

“foo bar baz；”

，那么我们还需要将

pTest

函数更改为next：

pTest = do
    many semi
    pS <- sepEndBy (some pWhiteStm) (some semi)
    eof
    return pS

---

如果我们有许多括号，则需要将

pWhiteStmt

中的

return p

替换为

return（concat p）

，您的解析器似乎希望在分号后出现一条语句。因此，只要纯空白不是有效的语句，那么解析器抱怨末尾有分号就不足为奇了。如果希望分号终止语句，为什么要在开始时解析它们；；如果那么{}是完全有效的，没有理由。好吧，两件事：

pStmt=semi*>many semi*>pStmt…

和

pTest=do{pS
pTest=do{many semi；pS哦！需要在最后添加解析EOF，像这样：
pTest=do{many semi；pS
pWhiteStmt = do
    many whitespace
    p <- some pStmt
    many whitespace
    return p

> parse pTest "" ";;foo;bar;\nfoo;; foobarbar;;"
Right [["foo"],["bar"],["foo"],["foo","bar","bar"]]

pTest = do
    many semi
    pS <- sepEndBy (some pWhiteStm) (some semi)
    eof
    return pS

> parse pTest "" ";;foo;bar;\nfoo;; foo bar bar;;"
Right [[["foo"]],[["bar"]],[["foo"]],[["foo"],["bar"],["bar"]]]