Portability portable provisional derek.a.elkins@gmail.com

Text.ParserCombinators.Parsec.Prim

Description

Parsec compatibility module

Synopsis

# Documentation

(<?>) :: ParsecT s u m a -> String -> ParsecT s u m aSource

The parser `p ? msg` behaves as parser `p`, but whenever the parser `p` fails without consuming any input, it replaces expect error messages with the expect error message `msg`.

This is normally used at the end of a set alternatives where we want to return an error message in terms of a higher level construct rather than returning all possible characters. For example, if the `expr` parser from the `try` example would fail, the error message is: '...: expecting expression'. Without the `(<?>)` combinator, the message would be like '...: expecting "let" or letter', which is less friendly.

(<|>) :: ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m aSource

This combinator implements choice. The parser `p <|> q` first applies `p`. If it succeeds, the value of `p` is returned. If `p` fails without consuming any input, parser `q` is tried. This combinator is defined equal to the `mplus` member of the `MonadPlus` class and the (`Control.Applicative.<|>`) member of `Control.Applicative.Alternative`.

The parser is called predictive since `q` is only tried when parser `p` didn't consume any input (i.e.. the look ahead is 1). This non-backtracking behaviour allows for both an efficient implementation of the parser combinators and the generation of good error messages.

type GenParser tok st = Parsec [tok] stSource

runParser :: GenParser tok st a -> st -> SourceName -> [tok] -> Either ParseError aSource

parse :: Stream s Identity t => Parsec s () a -> SourceName -> s -> Either ParseError aSource

`parse p filePath input` runs a parser `p` over Identity without user state. The `filePath` is only used in error messages and may be the empty string. Returns either a `ParseError` (`Left`) or a value of type `a` (`Right`).

```  main    = case (parse numbers "" "11, 2, 43") of
Left err  -> print err
Right xs  -> print (sum xs)

numbers = commaSep integer
```

`parseFromFile p filePath` runs a string parser `p` on the input read from `filePath` using `readFile`. Returns either a `ParseError` (`Left`) or a value of type `a` (`Right`).

```  main    = do{ result <- parseFromFile numbers "digits.txt"
; case result of
Left err  -> print err
Right xs  -> print (sum xs)
}
```

parseTest :: (Stream s Identity t, Show a) => Parsec s () a -> s -> IO ()Source

The expression `parseTest p input` applies a parser `p` against input `input` and prints the result to stdout. Used for testing parsers.

Arguments

 :: Stream s Identity t => (t -> String) Token pretty-printing function. -> (t -> SourcePos) Computes the position of a token. -> (t -> Maybe a) Matching function for the token to parse. -> Parsec s u a

The parser `token showTok posFromTok testTok` accepts a token `t` with result `x` when the function `testTok t` returns `Just x`. The source position of the `t` should be returned by `posFromTok t` and the token can be shown using `showTok t`.

This combinator is expressed in terms of `tokenPrim`. It is used to accept user defined token streams. For example, suppose that we have a stream of basic tokens tupled with source positions. We can than define a parser that accepts single tokens as:

```  mytoken x
= token showTok posFromTok testTok
where
showTok (pos,t)     = show t
posFromTok (pos,t)  = pos
testTok (pos,t)     = if x == t then Just t else Nothing
```

tokens :: (Stream s m t, Eq t) => ([t] -> String) -> (SourcePos -> [t] -> SourcePos) -> [t] -> ParsecT s u m [t]Source

Arguments

 :: Stream s m t => (t -> String) Token pretty-printing function. -> (SourcePos -> t -> s -> SourcePos) Next position calculating function. -> (t -> Maybe a) Matching function for the token to parse. -> ParsecT s u m a

The parser `token showTok nextPos testTok` accepts a token `t` with result `x` when the function `testTok t` returns `Just x`. The token can be shown using `showTok t`. The position of the next token should be returned when `nextPos` is called with the current source position `pos`, the current token `t` and the rest of the tokens `toks`, `nextPos pos t toks`.

This is the most primitive combinator for accepting tokens. For example, the `Text.Parsec.Char.char` parser could be implemented as:

```  char c
= tokenPrim showChar nextPos testChar
where
showChar x        = "'" ++ x ++ "'"
testChar x        = if x == c then Just x else Nothing
nextPos pos x xs  = updatePosChar pos x
```

tokenPrimEx :: Stream s m t => (t -> String) -> (SourcePos -> t -> s -> SourcePos) -> Maybe (SourcePos -> t -> s -> u -> u) -> (t -> Maybe a) -> ParsecT s u m aSource

try :: GenParser tok st a -> GenParser tok st aSource

label :: ParsecT s u m a -> String -> ParsecT s u m aSource

labels :: ParsecT s u m a -> [String] -> ParsecT s u m aSource

unexpected :: Stream s m t => String -> ParsecT s u m aSource

The parser `unexpected msg` always fails with an unexpected error message `msg` without consuming any input.

The parsers `fail`, (`<?>`) and `unexpected` are the three parsers used to generate error messages. Of these, only (`<?>`) is commonly used. For an example of the use of `unexpected`, see the definition of `Text.Parsec.Combinator.notFollowedBy`.

many :: ParsecT s u m a -> ParsecT s u m [a]Source

`many p` applies the parser `p` zero or more times. Returns a list of the returned values of `p`.

```  identifier  = do{ c  <- letter
; cs <- many (alphaNum <|> char '_')
; return (c:cs)
}
```

skipMany :: ParsecT s u m a -> ParsecT s u m ()Source

`skipMany p` applies the parser `p` zero or more times, skipping its result.

```  spaces  = skipMany space
```

getState :: Monad m => ParsecT s u m uSource

Returns the current user state.

setState :: Monad m => u -> ParsecT s u m ()Source

An alias for putState for backwards compatibility.

updateState :: Monad m => (u -> u) -> ParsecT s u m ()Source

An alias for modifyState for backwards compatibility.

getPosition :: Monad m => ParsecT s u m SourcePosSource

Returns the current source position. See also `SourcePos`.

setPosition :: Monad m => SourcePos -> ParsecT s u m ()Source

`setPosition pos` sets the current source position to `pos`.

getInput :: Monad m => ParsecT s u m sSource

Returns the current input

setInput :: Monad m => s -> ParsecT s u m ()Source

`setInput input` continues parsing with `input`. The `getInput` and `setInput` functions can for example be used to deal with #include files.

data State s u Source

Constructors

 State FieldsstateInput :: s statePos :: !SourcePos stateUser :: !u

getParserState :: Monad m => ParsecT s u m (State s u)Source

Returns the full parser state as a `State` record.

setParserState :: Monad m => State s u -> ParsecT s u m (State s u)Source

`setParserState st` set the full parser state to `st`.
{"ft_lang_label":"__label__en","ft_lang_prob":0.59336174,"math_prob":0.73989004,"size":7952,"snap":"2022-27-2022-33","text_gpt3_token_len":2258,"char_repetition_ratio":0.19363362,"word_repetition_ratio":0.3831004,"special_character_ratio":0.30218813,"punctuation_ratio":0.13731931,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9686076,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2022-06-28T10:05:14Z\",\"WARC-Record-ID\":\"<urn:uuid:64db3d4d-b6c2-4b7d-a580-6b638b7f31b0>\",\"Content-Length\":\"34993\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:b76ae0ab-8f43-4ffc-9b34-565f581be30d>\",\"WARC-Concurrent-To\":\"<urn:uuid:60864a5d-9197-479e-9d24-4447cbf450c8>\",\"WARC-IP-Address\":\"146.75.36.68\",\"WARC-Target-URI\":\"https://hackage.haskell.org/package/parsec-3.1.0/docs/Text-ParserCombinators-Parsec-Prim.html\",\"WARC-Payload-Digest\":\"sha1:5M5TIV6VV6VASSJGNWUBVGOWWSMBQWZY\",\"WARC-Block-Digest\":\"sha1:XGVK75XEIAVQ56Z2H7OHTMGXWFBRASVD\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2022/CC-MAIN-2022-27/CC-MAIN-2022-27_segments_1656103360935.27_warc_CC-MAIN-20220628081102-20220628111102-00093.warc.gz\"}"}