翻譯哈斯克爾秒差距到FParsec

Question

如何翻譯這個Haskell代碼：

import Text.ParserCombinators.Parsec((<|>), unexpected, lookAhead, noneOf, char) 
import Control.Monad(when) 

data BracketElement = BEChar Char | BEChars String | BEColl String | BEEquiv String | BEClass String 

p_set_elem_char = do 
    c <- noneOf "]" 
    when (c == '-') $ do 
    atEnd <- (lookAhead (char ']') >> return True) <|> (return False) 
    when (not atEnd) (unexpected "A dash is in the wrong place in a bracket") 
    return (BEChar c) 

到FParsec？優選的方式是沒有一元語法來提供良好的性能。

在此先感謝，亞歷山大。

對不起，有點誤導。我稍微糾正問題，使Haskell代碼編譯：

import Text.ParserCombinators.Parsec((<|>), (<?>), unexpected, lookAhead, noneOf, char) 
import Control.Monad(when) 
import Data.Functor.Identity 
import qualified Text.Parsec.Prim as PR 

-- | BracketElement is internal to this module 
data BracketElement = BEChar Char | BEChars String | BEColl String | BEEquiv String | BEClass String 
        deriving Show 

p_set_elem_char :: PR.ParsecT [Char] u Identity BracketElement 
p_set_elem_char = do 
    c <- noneOf "]" 
    when (c == '-') $ do 
    atEnd <- (lookAhead (char ']') >> return True) <|> (return False) 
    when (not atEnd) (unexpected "A dash is in the wrong place in a bracket") 
    return (BEChar c) 

現在可以重現* p_set_elem_char *計算。

我真誠地感謝所有幫助過我的人。

我做我自己的逼近，但遺憾的是並非如此功能，因爲它可以：

type BracketElement = BEChar of char 
        | BEChars of string 
        | BEColl of string 
        | BEEquiv of string 
        | BEClass of string 

let p_set_elem_char : Parser<BracketElement, _> = 
    fun stream -> 
     let stateTag = stream.StateTag 
     let reply = (noneOf "]") stream 
     let chr = reply.Result 
     let mutable reply2 = Reply(BEChar chr) 
     if reply.Status = Error && stateTag = stream.StateTag then 
      reply2.Status <- Error 
      reply2.Error <- reply.Error 
     else if chr = '-' && stream.Peek() <> ']' then 
      reply2.Status <- Error 
      reply2.Error <- messageError ("A dash is in the wrong place in a bracket") 
     reply2 

Answer 1

我不知道很多FParsec，但這裏是一個天真的嘗試，修正基礎上，有點性能評論：

type BracketElement = 
    | BEChar of char 
    | BEChars of string 
    | BEColl of string 
    | BEEquiv of string 
    | BEClass of string 

let parseBEChar : Parser<BracketElement,unit> = 
    let okChars = noneOf "]" 
    let endTest = 
     (lookAhead (skipChar ']') >>. parse.Return(true)) 
     <|> parse.Return(false) 
    let failure = fail "A dash is in the wrong place in a bracket" 
    parse { 
     let! c = okChars 
     if c = '-' then 
      let! atEnd = endTest 
      if not atEnd then 
       return! failure 
      else 
       return BEChar c 
     else 
      return BEChar c 
    } 

Answer 2

使用toyvo的答案BracketElement類型，你可以不喜歡

let pBEChar : Parser<_, unit> = 
    let c = 
    pchar '-' .>> followedByL (pchar ']') "A dash is in the wrong place in a bracket" 
    <|> noneOf "-]" 
    c |>> BEChar 

Answer 3

什麼丹尼爾提出類似，您可以編寫一個解析器

let pSetElementChar : Parser<_,unit> = 
    satisfy (function '-' | ']' -> false | _ -> true) 
    <|> (pchar '-' .>> followedByString "]") 
    |>> BEChar 

如果你想添加自定義消息的錯誤，你可以在丹尼爾的回答使用followedByL像，或者你可以使用fail添加消息原始

let pSetElementChar2 : Parser<_,unit> = 
    satisfy (function '-' | ']' -> false | _ -> true) 
    <|> (pchar '-' .>> (followedByString "]" 
         <|> fail "A dash is in the wrong place in a bracket")) 
    |>> BEChar 

一個低級別的實現可以簡單到

let pSetElementChar3 : Parser<_,unit> = 
    fun stream -> 
    let c = stream.ReadCharOrNewline() 
    if c <> EOS then 
     if c <> '-' || stream.Peek() = ']' then Reply(BEChar c) 
     else Reply(Error, messageError "A dash is in the wrong place in a bracket") 
    else 
     Reply(Error, unexpected "end of input")