将 BNF 转换为 Parsec 程序有什么技巧吗？答案

【问题标题】：Is there any trick about translating BNF to Parsec program?将 BNF 转换为 Parsec 程序有什么技巧吗？
【发布时间】：2015-03-03 09:47:48
【问题描述】：

匹配函数调用链的BNF（如x(y)(z)...）：

expr = term T
T    = (expr) T
      | EMPTY
term = (expr)
      | VAR

把它翻译成看起来很棘手的 Parsec 程序。

term :: Parser Term
term = parens expr <|> var

expr :: Parser Term
expr = do whiteSpace
          e <- term
          maybeAddSuffix e
  where addSuffix e0 = do e1 <- parens expr
                          maybeAddSuffix $ TermApp e0 e1
        maybeAddSuffix e = addSuffix e
                           <|> return e

您能否列出所有关于将 BNF 转换为 Parsec 程序的设计模式？

【问题讨论】：

这并不能回答你的问题，但你可能对 Happy 感兴趣：haskell.org/happy 这是一个读取 BNF 规范并生成 Haskell 解析器的程序。跨度>
您的一个问题是 BNF 语法通常是为语言标记描述的，但是您有一个基于 Char 的解析器，这意味着您必须进行标记化（解析标记）并解析您的实际语言对一步感兴趣。

标签： parsing haskell compiler-construction grammar parsec

【解决方案1】：

如果你的语法相当大，你可以做的最简单的想法就是使用 Alex/Happy 组合。它使用起来相当简单，直接接受 BNF 格式——不需要人工翻译——也许最重要的是，它可以产生非常快速的解析器/词法分析器。

如果您一心想要使用 parsec（或者您将其作为学习练习），我发现通常分两个阶段进行操作会更容易；首先词法分析，然后解析。 Parsec 两者都可以！

先写合适的类型：

{-# LANGUAGE LambdaCase #-}

import Text.Parsec 
import Text.Parsec.Combinator 
import Text.Parsec.Prim
import Text.Parsec.Pos
import Text.ParserCombinators.Parsec.Char 
import Control.Applicative hiding ((<|>))
import Control.Monad 

data Term = App Term Term | Var String deriving (Show, Eq)

data Token = LParen | RParen | Str String deriving (Show, Eq)

type Lexer = Parsec [Char] ()   -- A lexer accepts a stream of Char
type Parser = Parsec [Token] () -- A parser accepts a stream of Token

解析单个标记很简单。为简单起见，变量是 1 个或多个字母。您当然可以随意更改。

oneToken :: Lexer Token
oneToken = (char '(' >> return LParen) <|> 
           (char ')' >> return RParen) <|>
           (Str <$> many1 letter)

解析整个令牌流只是多次解析单个令牌，可能用空格分隔：

lexer :: Lexer [Token]
lexer = spaces >> many1 (oneToken <* spaces)

注意spaces 的位置：这样，在字符串的开头和结尾处接受空格。

由于Parser 使用自定义令牌类型，您必须使用自定义satisfy 函数。幸运的是，这与现有的满足几乎相同。

satisfy' :: (Token -> Bool) -> Parser Token
satisfy' f = tokenPrim show 
                       (\src _ _ -> incSourceColumn src 1) 
                       (\x -> if f x then Just x else Nothing)

然后我们可以为每个原始标记编写解析器。

lparen = satisfy' $ \case { LParen -> True ; _ -> False } 
rparen = satisfy' $ \case { RParen -> True ; _ -> False } 
strTok = (\(Str s) -> s) <$> (satisfy' $ \case { Str {} -> True ; _ -> False })

正如您想象的那样，parens 对我们的目的很有用。写起来非常简单。

parens :: Parser a -> Parser a 
parens = between lparen rparen

现在是有趣的部分。

term, expr, var :: Parser Term

term = parens expr <|> var

var = Var <$> strTok

这两个对你来说应该是相当明显的。

Parec 包含组合器 option 和 optionMaybe，当您需要“也许做某事”时它们很有用。

expr = do 
  e0 <- term 
  option e0 (parens expr >>= \e1 -> return (App e0 e1))

最后一行的意思是 - 尝试应用给 option 的解析器 - 如果失败，则返回 e0。

对于测试，您可以这样做：

tokAndParse = runParser (lexer <* eof) () "" >=> runParser (expr <* eof) () ""

附加到每个解析器的eof 是为了确保消耗整个输入；如果有额外的尾随字符，则字符串不能是语法的成员。注意 - 您的示例 x(y)(z) 实际上不在您的语法中！

>tokAndParse "x(y)(z)"
Left (line 1, column 5):
unexpected LParen
expecting end of input

但下面是

>tokAndParse "(x(y))(z)"
Right (App (App (Var "x") (Var "y")) (Var "z"))

【讨论】：