Parser b i a is a parser that consumes a stream of i tokens and as a result yields a value of type a, while operating under the b non-determinism monad.

For most purposes, the non-determinism monad b should be a MonadPlus. Useful examples include [] or Logic if you want backtracking, and Maybe if you want no backtracking.

Use StateT s [] if you want to maintain a state s that is automatically reverted when backtracking via [].

hoistFreeT can be used to change the backtracking monad.

FreeT provides instances for Functor, Applicative, Monad, Alternative and MonadPlus.

Recurse over a parser.

Tears down the free monad transformer over the '(->) i' functor using iteration: recurse next parser = next parser (parser' -> next parser' (parser'' -> next parser'' (parser''' -> next parser''' (...))))

token is trivial parser that consumes a single token i and yields it.

Other parsers can be derived from this one using methods of the Functor, Applicative, Monad, Alternative, and MonadPlus typeclasses and the parser combinators in this module.

satisfy p is a simple parser that consumes a single token i and yields it if and only if p i evaluates to True. Otherwise, the parser fails.

is i is a simple parser that consumes a single token and yields it if and only if it is equal to i. Otherwise, the parser fails.

isNot i is a simple parser that consumes a single token and yields it if and only if it is not equal to i. If the token is equal to i, the parser fails.

Stateful scanner.

>>> :{
  f s a | "ell" `isInfixOf` (s ++ [a]) = Nothing
        | otherwise                    = Just (s ++ [a])
:}

>>> head $ parseString @[] (scan f "" token) "hello 123"
("hel","lo 123")

atMost n p applies the parser p at most n times and returns every parsing result. If parsing of p succeeds less the n times, repeatP n p succeeds as well.

>>> head $ parseString @[] (atMost 2 (isToken 'a')) "aaaaaab"
("aa","aaaab")

eitherP p p' combines the two alternatives p and p'.

void p applies the parser p and discards its result.

combine p p' merges the results of p and p' using the Semigroup instance.

combines ps merges the results of the parsers ps using the Monoid instance.

isString s is a simple parser that consumes Char tokens and yields them if and only if they assemble the String s. Otherwise, the parser fails.

string matches any string

>>> parseString @[] string "a string"
[("a string",""),("a strin","g"),("a stri","ng"),("a str","ing"),("a st","ring"),("a s","tring"),("a ","string"),("a"," string"),("","a string")]

• - >>> p = string @[] >>= s -> (guard ("dog" isInfixOf s) >> pure s)
• - >>> head $ parseString p "this is a string with a dog"
• - ("this is a string with a dog","")
• - >>> p = string @[] >>= s -> (guard (not $ "dog" isInfixOf s) >> pure s)
• - >>> head $ parseString p "this is also string with a dog"
• - ("this is also string with a do","g")