Translate Haskell parsec to FParsec - haskell

Question

how to translate this Haskell code:
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)
to FParsec ? Preferable way is without monadic syntax to provide good performance.
Thanks in advance, Alexander.
Sorry for little misleading. I slightly corrected problem to make Haskell code compilable:
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)
Now it is possible to reproduce *p_set_elem_char* computation.
I sincerely thank all of which who helped me.
I made my own approximation, but unfortunately not so functional as it could be:
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

Using the BracketElement type in toyvo's answer, you could do something like
let pBEChar : Parser<_, unit> =
let c =
pchar '-' .>> followedByL (pchar ']') "A dash is in the wrong place in a bracket"
<|> noneOf "-]"
c |>> BEChar

Answer 2

I don't know much FParsec, but here is a naive attempt, corrected a bit for performance based on the comments:
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 3

Similar to what Daniel proposed, you could write that parser as
let pSetElementChar : Parser<_,unit> =
satisfy (function '-' | ']' -> false | _ -> true)
<|> (pchar '-' .>> followedByString "]")
|>> BEChar
If you want to add your custom message to the error, you could use followedByL like in Daniel's answer or you could add the message using the fail primitive
let pSetElementChar2 : Parser<_,unit> =
satisfy (function '-' | ']' -> false | _ -> true)
<|> (pchar '-' .>> (followedByString "]"
<|> fail "A dash is in the wrong place in a bracket"))
|>> BEChar
A low-level implementation can be as simple as
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")