Text.Appar.LazyByteString

Parser synonym for strict ByteString.

Parses a letter or digit (a character between '0' and '9'). Returns the parsed character.

This parser succeeds for any character. Returns the parsed character.

char c parses a single character c. Returns the parsed character.

choice ps tries to apply the parsers in the list ps in order, until one of them succeeds. Returns the value of the succeeding parser.

Parses a digit. Returns the parsed character.

Parses a hexadecimal digit (a digit or a letter between 'a' and 'f' or 'A' and 'F'). Returns the parsed character.

manyTill p end applies parser p zero or more times until parser end succeeds. Returns the list of values returned by p.

As the dual of oneOf, noneOf cs succeeds if the current character not in the supplied list of characters cs. Returns the parsed character.

oneOf cs succeeds if the current character is in the supplied list of characters cs. Returns the parsed character.

option x p tries to apply parser p. If p fails without consuming input, it returns the value x, otherwise the value returned by p.

Run a parser.

The parser satisfy f succeeds for any character for which the supplied function f returns True. Returns the character that is actually parsed.

sepBy1 p sep parses one or more occurrences of p, separated by sep. Returns a list of values returned by p.

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

skipSome p applies the parser p one or more times, skipping its result.

Parses a white space character (any character which satisfies isSpace) Returns the parsed character.

string s parses a sequence of characters given by s. Returns the parsed string

The parser try p behaves like parser p, except that it pretends that it hasn't consumed any input when an error occurs.

A variant of <*> with the types of the arguments reversed. It differs from flip (<*>) in that the effects are resolved in the order the arguments are presented.

Examples

>>> (<**>) (print 1) (id <$ print 2)12

>>> flip (<*>) (print 1) (id <$ print 2)21

>>> ZipList [4, 5, 6] <**> ZipList [(+1), (*2), (/3)]ZipList {getZipList = [5.0,10.0,2.0]}

An infix synonym for fmap.

The name of this operator is an allusion to Prelude.$. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas Prelude.$ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> NothingNothing

>>> show <$> Just 3Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17Left 17

>>> show <$> Right 17Right "17"

Double each element of a list:

>>> (*2) <$> [1,2,3][2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)(2,True)

The class for parser input.

An associative binary operation

Zero or more.

Examples

>>> many (putStr "la")lalalalalalalalala... * goes on forever *

>>> many NothingJust []

>>> take 5 <$> many (Just 1)* hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case many parser will attempt to parse parser zero or more times until it fails.

One or more.

Examples

>>> some (putStr "la")lalalalalalalalala... * goes on forever *

>>> some Nothingnothing

>>> take 5 <$> some (Just 1)* hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case some parser will attempt to parse parser one or more times until it fails.

Sequence actions, discarding the value of the first argument.

Examples

If used in conjunction with the Applicative instance for Maybe, you can chain Maybe computations, with a possible "early return" in case of Nothing.

>>> Just 2 *> Just 3Just 3

>>> Nothing *> Just 3Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

>>> import Data.Char>>> import GHC.Internal.Text.ParserCombinators.ReadP>>> let p = string "my name is " *> munch1 isAlpha <* eof>>> readP_to_S p "my name is Simon"[("Simon","")]

Sequence actions, discarding the value of the second argument.

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Example

Used in combination with (Data.Functor.<$>), (<*>) can be used to build a record.

>>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

>>> produceFoo :: Applicative f => f Foo>>> produceBar :: Applicative f => f Bar>>> produceBaz :: Applicative f => f Baz

>>> mkState :: Applicative f => f MyState>>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

Lift a value into the Structure.

Examples

>>> pure 1 :: Maybe IntJust 1

>>> pure 'z' :: [Char]"z"

>>> pure (pure ":D") :: Maybe [String]Just [":D"]

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Examples

Perform a computation with Maybe and replace the result with a constant value if it is Just:

>>> 'a' <$ Just 2Just 'a'>>> 'a' <$ NothingNothing