Text.Parsing.Simple

type ParseError = String

newtype Parser s a

Instances

• Semigroup (Parser s a)
• Monoid (Parser s a)
• Lazy (Parser s a)
• Functor (Parser s)
• Alt (Parser s)
• Plus (Parser s)
• Apply (Parser s)
• Applicative (Parser s)
• Bind (Parser s)
• Monad (Parser s)
• Alternative (Parser s)
• MonadZero (Parser s)
• MonadPlus (Parser s)

parse :: forall a s. Parser s a -> s -> Either ParseError a

Run a parser against an input, either getting an error or a value.

unparser :: forall a s. Parser s a -> s -> { consumed :: Either ParseError a, remaining :: s }

Get the result of a parse, plus the unparsed input remainder.

modify :: forall a s. (s -> s) -> Parser s a -> Parser s a

Change the input to a parser.

modifyM :: forall a s. (s -> Maybe s) -> Parser s a -> Parser s a

Change the input to a parser, using Nothing to signal failure.

modifyE :: forall a err s. Show err => (s -> Either err s) -> Parser s a -> Parser s a

Change the input to a parser, using Left to signal failure.

pureP :: forall a s. a -> Parser s a

A pure that doesn't require passing the typeclass dictionary for Applicative.

mapP :: forall b a s. (a -> b) -> Parser s a -> Parser s b

A map that doesn't require passing the typeclass dictionary for Functor.

Operator alias for Text.Parsing.Simple.mapP (left-associative / precedence 4)

applyP :: forall b a s. Parser s (a -> b) -> Parser s a -> Parser s b

An apply that doesn't require passing the typeclass dictionary for Apply.

Operator alias for Text.Parsing.Simple.applyP (left-associative / precedence 4)

bindP :: forall b a s. Parser s a -> (a -> Parser s b) -> Parser s b

A bind that doesn't require passing the typeclass dictionary for Bind.

Operator alias for Text.Parsing.Simple.bindP (left-associative / precedence 1)

flippedBindP :: forall b a s. (a -> Parser s b) -> Parser s a -> Parser s b

Operator alias for Text.Parsing.Simple.flippedBindP (right-associative / precedence 1)

composeKleisliParser :: forall c b a s. (b -> Parser s c) -> (a -> Parser s b) -> (a -> Parser s c)

Operator alias for Text.Parsing.Simple.composeKleisliParser (right-associative / precedence 1)

parserKleisliCompose :: forall c b a s. (a -> Parser s b) -> (b -> Parser s c) -> (a -> Parser s c)

Operator alias for Text.Parsing.Simple.parserKleisliCompose (right-associative / precedence 1)

altL :: forall a s. Parser s a -> Parser s a -> Parser s a

Operator alias for Text.Parsing.Simple.altL (left-associative / precedence 3)

altR :: forall a s. Parser s a -> Parser s a -> Parser s a

Operator alias for Text.Parsing.Simple.altR (right-associative / precedence 3)

applyL :: forall b a s. Parser s a -> Parser s b -> Parser s a

Equivalent to (<*) but faster since it doesn't require passing typeclass dictionaries.

Operator alias for Text.Parsing.Simple.applyL (left-associative / precedence 4)

applyR :: forall b a s. Parser s a -> Parser s b -> Parser s b

Equivalent to (*>) but faster since it doesn't require passing typeclass dictionaries.

Operator alias for Text.Parsing.Simple.applyR (left-associative / precedence 4)

fromCharList :: forall f. Foldable f => f Char -> String

none :: forall a s. Parser s a

Always fail.

fail :: forall a s. ParseError -> Parser s a

Fail with a message

orFailWith :: forall a s. Parser s a -> ParseError -> Parser s a

Operator alias for Text.Parsing.Simple.orFailWith (non-associative / precedence 0)

try :: forall a s. Parser s a -> Parser s a

If the given parser fails, backtrack to the point of failure.

many :: forall a s. Parser s a -> Parser s (List a)

Attempt a parse as many times as possible, putting all successes into a list. WARNING: Applying this to a parser which never fails and never consumes input will result in a bottom, i.e. a nonterminating program.

some :: forall a s. Parser s a -> Parser s (List a)

Attempt a parse one or more times.

fix :: forall a s. (Parser s a -> Parser s a) -> Parser s a

Find a function's least fixed point using the Z combinator.

lookahead :: forall a s. Parser s a -> Parser s a

Parse without consuming input.

isn't :: forall a s. Parser s a -> Parser s Unit

isn't p succeeds iff p fails, though it will always consume the same amount of input that p does.

notFollowedBy :: forall a s. Parser s a -> Parser s Unit

Differs from isn't in that this never consumes input.

skip :: forall a s. Parser s a -> Parser s Unit

Discard the result of a parse.

suchThat :: forall a s. Parser s a -> (a -> Boolean) -> Parser s a

Attempt a parse subject to a predicate. If the parse succeeds but the predicate does not hold, the resulting parse fails without backtracking. If the parse fails, it will backtrack.

Operator alias for Text.Parsing.Simple.suchThat (left-associative / precedence 5)

sepBy :: forall b a s. Parser s a -> Parser s b -> Parser s (List a)

sepBy1 :: forall b a s. Parser s a -> Parser s b -> Parser s (List a)

tail :: Parser String String

Matches the unparsed portion of the input.

item :: Parser String Char

Parse a single Char.

first :: forall a s. (s -> Maybe { head :: a, tail :: s }) -> Parser s a

A generalized item for arbitrary streams that can be unconsed.

sat :: (Char -> Boolean) -> Parser String Char

Backtracking combinators

Create a parser from a Characteristic function.

isn'tAnyF :: forall f. Foldable f => f Char -> Parser String Char

Match any character not in the foldable container.

isn'tAny :: String -> Parser String Char

Match any character not in the string. Equivalent to isn'tAnyF <<< toCharArray.

anyOfF :: forall f. Foldable f => f Char -> Parser String Char

Match any character in the foldable container.

anyOf :: String -> Parser String Char

Match any character in the string. Equivalent to anyOfF <<< toCharArray.

char :: Char -> Parser String Char

string :: String -> Parser String String

digit :: Parser String Char

lower :: Parser String Char

Parse a lowercase character.

upper :: Parser String Char

Parse an uppercase character.

letter :: Parser String Char

alphanum :: Parser String Char

Parse a letter or a digit.

space :: Parser String Char

tab :: Parser String Char

newline :: Parser String Char

cr :: Parser String Char

Parse a carriage return.

whitespace :: Parser String Char

sat' :: (Char -> Boolean) -> Parser String Char

Non-backtracking combinators

isn'tAnyF' :: forall f. Foldable f => f Char -> Parser String Char

isn'tAny' :: String -> Parser String Char

anyOfF' :: forall f. Foldable f => f Char -> Parser String Char

anyOf' :: String -> Parser String Char

char' :: Char -> Parser String Char

string' :: String -> Parser String String

digit' :: Parser String Char

lower' :: Parser String Char

upper' :: Parser String Char

letter' :: Parser String Char

alphanum' :: Parser String Char

space' :: Parser String Char

tab' :: Parser String Char

newline' :: Parser String Char

cr' :: Parser String Char

whitespace' :: Parser String Char

whitespaces :: Parser String (List Char)

Higher-order combinators

skipSpaces :: Parser String Unit

manyChar :: Parser String Char -> Parser String String

Parse a natural number amount of a given Char parser, resulting in a String.

someChar :: Parser String Char -> Parser String String

Parse a positive integral amount of a given Char parser, resulting in a String.

word :: Parser String String

Contiguous strings with no tabs, spaces, carriage returns or newlines.

eof :: Parser String Unit

Parse the end of a file, returning Unit to indicate success.

integral :: Parser String String

Parse an integer value as a String. Useful if needing to parse integers that are outside of Int's bounds. You could then combine this with, e.g. purescript-hugenum's Data.HugeInt.fromString.

int :: Parser String Int

Parse an Int. Note that this parser will fail if the candidate would be outside the range of allowable Ints.

number :: Parser String Number

Parse a Number. The string must have digits surrounding a decimal point.

boolean :: Parser String Boolean

parens :: forall a. Parser String a -> Parser String a

braces :: forall a. Parser String a -> Parser String a

brackets :: forall a. Parser String a -> Parser String a