parsec

import Text.ParserCombinators.Parsec delimiter :: Parser () delimiter = do char '|' return () <?> "delimiter" eol :: Parser () eol = do oneOf "\n\r" return () <?> "end of line" item :: Parser String item = do entry <- manyTill anyChar (try eol <|> try delimiter <|> eof) return entry items :: Parser [String] items = do result <- many item return result When I run parseTest items "a|b|c" with the code above I get the following error: *** Exception: Text.ParserCombinators.Parsec.Prim.many: combinator 'many' is applied to a parser that accepts an empty string. I believe it has something to do with

Lets see the code snippet: pSegmentBegin p i = pIndentExact i *> ((:) <$> p i <*> ((pEOL *> pSegment p i) <|> pure [])) if I change this code in my parser to: pSegmentBegin p i = do pIndentExact i ((:) <$> p i <*> ((pEOL *> pSegment p i) <|> pure [])) I've got an error: canot compute minmal length of a parser due to occurrence of a moadic bind, use addLength to override I thought the above parser should behave the same way. Why this error can occur? EDIT The above example is very simple (to simplify the question) and as noted below it is not necessary to use do notation here, but the real case

I'm attempting to write a parser in Haskell using Parsec. Currently I have a program that can parse test x [1,2,3] end The code that does this is given as follows testParser = do { reserved "test"; v <- identifier; symbol "["; l <- sepBy natural commaSep; symbol "]"; p <- pParser; return $ Test v (List l) p } <?> "end" where commaSep is defined as commaSep = skipMany1 (space <|> char ',') Now is there some way for me to parse a similar statement, specifically: test x [1...3] end Being new to Haskell, and Parsec for that matter, I'm sure there's some nice concise way of doing this that I'm just

I would like to use Parsec's makeTokenParser to build my parser, but I want to use my own definition of whiteSpace . Doing the following replaces whiteSpace with my definition, but all the lexeme parsers still use the old definition (e.g. P.identifier lexer will use the old whiteSpace). ... lexer :: P.TokenParser () lexer = l { P.whiteSpace = myWhiteSpace } where l = P.makeTokenParser myLanguageDef ... Looking at the code for makeTokenParser I think I understand why it works this way. I want to know if there are any workarounds to avoid completely duplicating the code for makeTokenParser ?

What does the constraint (Stream s Identity t) mean in the following type declaration? parse :: (Stream s Identity t) => Parsec s () a -> SourceName -> s -> Either ParseError a What is Stream in the following class declaration, what does it mean. I'm totally lost. class Monad m => Stream s m t | s -> t where When I use Parsec, I get into a jam with the type-signatures ( xxx :: yyy ) all the time. I always skip the signatures, load the src into ghci, and then copy the type-signature back to my .hs file. It works, but I still don't understand what all these signatures are. EDIT: more about the

I'm trying to get this trivial parsec code to compile import Text.Parsec simple = letter but I keep getting this error No instance for (Stream s0 m0 Char) arising from a use of `letter' Possible fix: add an instance declaration for (Stream s0 m0 Char) In the expression: letter In an equation for `simple': simple = letter fuz I think you have ran against the monomorphism restriction . This restriction means: If a variable is declared with no explicit arguments, its type has to be monomorphic. This forces the typechecker to pick a particular instance of Stream , but it can't decide. There are

I understand the Parsec modules' parse function, which takes a rule argument, an error message, and an input string: parse rule text = Parsec.parse rule "(source)" text However, I don't understand the meaning of Parsec.Parsec , or how it's different from Parsec.ParsecT . Why do type signatures of custom parsers use this name? For example, in the following code snippet taken from this blogpost , myParser :: Parsec.Parsec String () (String,String) myParser = do letters <- Parsec.many1 Parsec.letter Parsec.spaces digits <- Parsec.many1 Parsec.digit return (letters,digits) what does Parsec.Parsec

I am currently trying to use the Full CSV Parser presented in Real World Haskell . In order to I tried to modify the code to use ByteString instead of String , but there is a string combinator which just works with String . Is there a Parsec combinator similar to string that works with ByteString , without having to do conversions back and forth? I've seen there is an alternative parser that handles ByteString : attoparsec , but I would prefer to stick with Parsec, since I'm just learning how to use it. I'm assuming you're starting with something like import Prelude hiding (getContents,