Question

我正在为基于lambda演算的编程语言创建一个解析器。我添加了一个中缀运算符和它们的优先级，但是解析器崩溃了一个关于负优先级的错误。我能够手动解析操作符，但似乎我无法获得正确的优先级。所以我想我也可以学习使用OperatorPrecedenceParser。

我会展示代码，因为我不知道为什么会崩溃，因为我没有任何负面优先权。

语言AST

module MiniML
type Exp =
            | C of Cst 
            | Id of Id 
            | Lam of Id * Exp 
            | App of Exp * Exp 
            | Let of Id * Exp * Exp
            | Pair of Exp * Exp
            | If of Exp * Exp * Exp
and Cst  = I of int | B of bool | Unit | Nil
and Id   = string;;

let op = ["+"; 
      "-";
      "*"; 
      "/"; 
      "="; 
      "<"; 
      ">"; 
      "@"; 
      "and"; 
      "or"; 
      ","; 
      "::"
    ]

这是解析器本身。这是我第一次使用解析器组合器（和解析器），所以如果有一些非常错误的话，我想知道。否则，只知道崩溃的原因就足够了。

open MiniML
open FParsec

let ws = spaces

let operator : Parser<MiniML.Id,unit> = op |> List.map pstring |> choice

let keyword : Parser<string,unit> = ["false";"true";"let";"end";"in";"if";"then";"else";"lam"] |> List.map pstring |> choice

let fstId = asciiLetter <|> pchar '_'

let restId = fstId <|> digit <|> pchar '''

let betweenPar p = between (pchar '(' .>> ws) (pchar ')' .>> ws) p

let cstB = (stringReturn "true"  (B true)) <|> (stringReturn "false" (B false))

let cstI = puint32 |>> (int >> I)

let cstU = stringReturn "()" Unit

let cstN = stringReturn "[]" Nil

let expC : Parser<Exp,unit> = cstB <|> cstI <|> cstU <|> cstN  |>> C

let expIdStr = notFollowedByL keyword "Cannot use keyword as variable" >>. 
                    notFollowedByL operator "Cannot use operator as variable" >>. 
                        many1CharsTill2 fstId restId (notFollowedBy restId)

let expId  : Parser<Exp,unit> = expIdStr |>> (MiniML.Exp.Id)

let exp, expRef = createParserForwardedToRef<Exp, unit>()

let expApp, expAppRef = createParserForwardedToRef<Exp, unit>()

let expLam : Parser<Exp,unit> = (pstring "lam" >>. ws >>. expIdStr .>> ws .>> pchar '.') .>> ws .>>. exp |>> Lam

let expLet = tuple3 (pstring "let" >>. ws >>. expIdStr .>> ws .>> pchar '=' .>> ws) (exp .>> ws .>> pstring "in" .>> ws) (exp .>> ws .>> pstring "end") |>> Let

let expIf = tuple3 (pstring "if" >>. ws >>. exp .>> ws) (pstring "then" >>. ws >>. exp .>> ws) (pstring "else" >>. ws >>. exp) |>> If

let closeEXP, closeEXPRef = createParserForwardedToRef<Exp, unit>()

let expBang = (pstring "!" >>% MiniML.Id "!") .>>. closeEXP |>> App

let buildList (el,ef)  = 
    let rec go l = match l with 
                       | (e::es) -> App(MiniML.Id "cons", Pair(e,go es))
                       | [] -> C Nil
    go (el @ [ef])

let expList = between (pchar '[' .>> ws) (pchar ']') (many (exp .>>? (ws .>> pchar ';' .>> ws)) .>>. exp .>> ws 
                |>> buildList )

do closeEXPRef := choice [expC ; expId ; expBang ; betweenPar exp ; expList]  .>> ws

do expAppRef := many1 closeEXP |>> (function (x::xs) -> List.fold (fun x y -> App(x,y)) x xs | [] -> failwith "Impossible")

let opOpp : InfixOperator<Exp,unit,unit> list = 
        [
          InfixOperator("*", ws, 6, Associativity.Left, fun x y -> App(MiniML.Id "*",Pair(x,y))); 
          InfixOperator("/", ws, 6, Associativity.Left, fun x y -> App(MiniML.Id "/",Pair(x,y)));
          InfixOperator("+", ws, 5, Associativity.Left, fun x y -> App(MiniML.Id "+",Pair(x,y))); 
          InfixOperator("-", ws, 5, Associativity.Left, fun x y -> App(MiniML.Id "-",Pair(x,y)));
          InfixOperator("::", ws,4, Associativity.Right, fun x y -> App(MiniML.Id "cons",Pair(x,y)));
          InfixOperator("=", ws, 3, Associativity.Left, fun x y -> App(MiniML.Id "=",Pair(x,y)));  
          InfixOperator("<", ws, 3, Associativity.Left, fun x y -> App(MiniML.Id "<",Pair(x,y)));  
          InfixOperator(">", ws, 3, Associativity.Left, fun x y -> App(MiniML.Id ">",Pair(x,y)));  
          InfixOperator("and", ws, 2, Associativity.Right, fun x y -> App(MiniML.Id "and",Pair(x,y))); 
          InfixOperator("or", ws, 1, Associativity.Right, fun x y -> App(MiniML.Id "or",Pair(x,y))); 
          InfixOperator(",", ws,0, Associativity.None, fun x y -> Pair(x,y) )
        ]

let opp = new OperatorPrecedenceParser<Exp,unit,unit>()
let expr = opp.ExpressionParser
let term = exp <|> betweenPar expr
opp.TermParser <- term
List.iter (fun x -> opp.AddOperator(x)) opOpp

do expRef := [expLam;expIf;expLet;expApp] |>  choice |> (fun p -> p .>>. opt (expOp operator) |>> binOp )

let mainExp = expr .>> eof

Answer 1

您的示例代码似乎并不完整，因为未包含expOp和binOp。当我在没有最后两行的情况下运行你的代码时，OPP抛出一个ArgumentOutOfRangeException的消息＆＃34;运算符优先级必须大于0。＆＃34;添加逗号运算符时。问题是您指定0作为逗号运算符的优先级。

当您使用具有完全集成的调试器（如Visual Studio）的IDE时，此类问题更容易诊断。

OperatorPrecedenceParser抛出关于负优先级的异常，这是我没有的

1 个答案: