Looksee

A simple text parser with decent errors

Documentation

newtype Label

A parser label (for error reporting)

Constructors

Label

Fields

• unLabel :: Text

Instances

IsString Label

Defined in Looksee

Methods

fromString :: String -> Label

Show Label

Defined in Looksee

Methods

showsPrec :: Int -> Label -> ShowS

show :: Label -> String

showList :: [Label] -> ShowS

Eq Label

Defined in Looksee

Methods

(==) :: Label -> Label -> Bool

(/=) :: Label -> Label -> Bool

Ord Label

Defined in Looksee

Methods

compare :: Label -> Label -> Ordering

(<) :: Label -> Label -> Bool

(<=) :: Label -> Label -> Bool

(>) :: Label -> Label -> Bool

(>=) :: Label -> Label -> Bool

max :: Label -> Label -> Label

min :: Label -> Label -> Label

data Range

Range in text character offset

Constructors

Range

Fields

• rangeStart :: !Int
• rangeEnd :: !Int

Instances

Show Range

Defined in Looksee

Methods

showsPrec :: Int -> Range -> ShowS

show :: Range -> String

showList :: [Range] -> ShowS

Eq Range

Defined in Looksee

Methods

(==) :: Range -> Range -> Bool

(/=) :: Range -> Range -> Bool

Ord Range

Defined in Looksee

Methods

compare :: Range -> Range -> Ordering

(<) :: Range -> Range -> Bool

(<=) :: Range -> Range -> Bool

(>) :: Range -> Range -> Bool

(>=) :: Range -> Range -> Bool

max :: Range -> Range -> Range

min :: Range -> Range -> Range

range :: Text -> Range

Create a range from the given text

data SplitComp

Constructors

SplitCompEQ

SplitCompGE

SplitCompGT

Instances

Bounded SplitComp

Defined in Looksee

Methods

minBound :: SplitComp

maxBound :: SplitComp

Enum SplitComp

Defined in Looksee

Methods

succ :: SplitComp -> SplitComp

pred :: SplitComp -> SplitComp

toEnum :: Int -> SplitComp

fromEnum :: SplitComp -> Int

enumFrom :: SplitComp -> [SplitComp]

enumFromThen :: SplitComp -> SplitComp -> [SplitComp]

enumFromTo :: SplitComp -> SplitComp -> [SplitComp]

enumFromThenTo :: SplitComp -> SplitComp -> SplitComp -> [SplitComp]

Show SplitComp

Defined in Looksee

Methods

showsPrec :: Int -> SplitComp -> ShowS

show :: SplitComp -> String

showList :: [SplitComp] -> ShowS

Eq SplitComp

Defined in Looksee

Methods

(==) :: SplitComp -> SplitComp -> Bool

(/=) :: SplitComp -> SplitComp -> Bool

Ord SplitComp

Defined in Looksee

Methods

compare :: SplitComp -> SplitComp -> Ordering

(<) :: SplitComp -> SplitComp -> Bool

(<=) :: SplitComp -> SplitComp -> Bool

(>) :: SplitComp -> SplitComp -> Bool

(>=) :: SplitComp -> SplitComp -> Bool

max :: SplitComp -> SplitComp -> SplitComp

min :: SplitComp -> SplitComp -> SplitComp

data Reason e r

Reason for parse failure

Constructors

ReasonCustom !e

ReasonSplitComp !SplitComp !Int !Text !Int

ReasonExpect !Text !Text

ReasonDemand !Int !Int

ReasonLeftover !Int

ReasonAlt !(Seq (AltPhase, r))

ReasonInfix !(Seq (Int, InfixPhase, r))

ReasonFail !Text

ReasonLabelled !Label r

ReasonLook r

ReasonTakeNone

ReasonEmpty

Instances

Bifoldable Reason

Defined in Looksee

Methods

bifold :: Monoid m => Reason m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Reason a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Reason a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Reason a b -> c

Bifunctor Reason

Defined in Looksee

Methods

bimap :: (a -> b) -> (c -> d) -> Reason a c -> Reason b d

first :: (a -> b) -> Reason a c -> Reason b c

second :: (b -> c) -> Reason a b -> Reason a c

Bitraversable Reason

Defined in Looksee

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Reason a b -> f (Reason c d)

Foldable (Reason e)

Defined in Looksee

Methods

fold :: Monoid m => Reason e m -> m

foldMap :: Monoid m => (a -> m) -> Reason e a -> m

foldMap' :: Monoid m => (a -> m) -> Reason e a -> m

foldr :: (a -> b -> b) -> b -> Reason e a -> b

foldr' :: (a -> b -> b) -> b -> Reason e a -> b

foldl :: (b -> a -> b) -> b -> Reason e a -> b

foldl' :: (b -> a -> b) -> b -> Reason e a -> b

foldr1 :: (a -> a -> a) -> Reason e a -> a

foldl1 :: (a -> a -> a) -> Reason e a -> a

toList :: Reason e a -> [a]

null :: Reason e a -> Bool

length :: Reason e a -> Int

elem :: Eq a => a -> Reason e a -> Bool

maximum :: Ord a => Reason e a -> a

minimum :: Ord a => Reason e a -> a

sum :: Num a => Reason e a -> a

product :: Num a => Reason e a -> a

Traversable (Reason e)

Defined in Looksee

Methods

traverse :: Applicative f => (a -> f b) -> Reason e a -> f (Reason e b)

sequenceA :: Applicative f => Reason e (f a) -> f (Reason e a)

mapM :: Monad m => (a -> m b) -> Reason e a -> m (Reason e b)

sequence :: Monad m => Reason e (m a) -> m (Reason e a)

Functor (Reason e)

Defined in Looksee

Methods

fmap :: (a -> b) -> Reason e a -> Reason e b

(<$) :: a -> Reason e b -> Reason e a

(Show e, Show r) => Show (Reason e r)

Defined in Looksee

Methods

showsPrec :: Int -> Reason e r -> ShowS

show :: Reason e r -> String

showList :: [Reason e r] -> ShowS

(Eq e, Eq r) => Eq (Reason e r)

Defined in Looksee

Methods

(==) :: Reason e r -> Reason e r -> Bool

(/=) :: Reason e r -> Reason e r -> Bool

(Ord e, Ord r) => Ord (Reason e r)

Defined in Looksee

Methods

compare :: Reason e r -> Reason e r -> Ordering

(<) :: Reason e r -> Reason e r -> Bool

(<=) :: Reason e r -> Reason e r -> Bool

(>) :: Reason e r -> Reason e r -> Bool

(>=) :: Reason e r -> Reason e r -> Bool

max :: Reason e r -> Reason e r -> Reason e r

min :: Reason e r -> Reason e r -> Reason e r

data ErrF e r

Base functor for Err containing the range and reason for the error

Constructors

ErrF

Fields

• efRange :: !Range
• efReason :: !(Reason e r)

Instances

Bifoldable ErrF

Defined in Looksee

Methods

bifold :: Monoid m => ErrF m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> ErrF a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> ErrF a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> ErrF a b -> c

Bifunctor ErrF

Defined in Looksee

Methods

bimap :: (a -> b) -> (c -> d) -> ErrF a c -> ErrF b d

first :: (a -> b) -> ErrF a c -> ErrF b c

second :: (b -> c) -> ErrF a b -> ErrF a c

Bitraversable ErrF

Defined in Looksee

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> ErrF a b -> f (ErrF c d)

Foldable (ErrF e)

Defined in Looksee

Methods

fold :: Monoid m => ErrF e m -> m

foldMap :: Monoid m => (a -> m) -> ErrF e a -> m

foldMap' :: Monoid m => (a -> m) -> ErrF e a -> m

foldr :: (a -> b -> b) -> b -> ErrF e a -> b

foldr' :: (a -> b -> b) -> b -> ErrF e a -> b

foldl :: (b -> a -> b) -> b -> ErrF e a -> b

foldl' :: (b -> a -> b) -> b -> ErrF e a -> b

foldr1 :: (a -> a -> a) -> ErrF e a -> a

foldl1 :: (a -> a -> a) -> ErrF e a -> a

toList :: ErrF e a -> [a]

null :: ErrF e a -> Bool

length :: ErrF e a -> Int

elem :: Eq a => a -> ErrF e a -> Bool

maximum :: Ord a => ErrF e a -> a

minimum :: Ord a => ErrF e a -> a

sum :: Num a => ErrF e a -> a

product :: Num a => ErrF e a -> a

Traversable (ErrF e)

Defined in Looksee

Methods

traverse :: Applicative f => (a -> f b) -> ErrF e a -> f (ErrF e b)

sequenceA :: Applicative f => ErrF e (f a) -> f (ErrF e a)

mapM :: Monad m => (a -> m b) -> ErrF e a -> m (ErrF e b)

sequence :: Monad m => ErrF e (m a) -> m (ErrF e a)

Functor (ErrF e)

Defined in Looksee

Methods

fmap :: (a -> b) -> ErrF e a -> ErrF e b

(<$) :: a -> ErrF e b -> ErrF e a

(Show e, Show r) => Show (ErrF e r)

Defined in Looksee

Methods

showsPrec :: Int -> ErrF e r -> ShowS

show :: ErrF e r -> String

showList :: [ErrF e r] -> ShowS

(Eq e, Eq r) => Eq (ErrF e r)

Defined in Looksee

Methods

(==) :: ErrF e r -> ErrF e r -> Bool

(/=) :: ErrF e r -> ErrF e r -> Bool

(Ord e, Ord r) => Ord (ErrF e r)

Defined in Looksee

Methods

compare :: ErrF e r -> ErrF e r -> Ordering

(<) :: ErrF e r -> ErrF e r -> Bool

(<=) :: ErrF e r -> ErrF e r -> Bool

(>) :: ErrF e r -> ErrF e r -> Bool

(>=) :: ErrF e r -> ErrF e r -> Bool

max :: ErrF e r -> ErrF e r -> ErrF e r

min :: ErrF e r -> ErrF e r -> ErrF e r

newtype Err e

A parse error, which may contain multiple sub-errors

Constructors

Err

Fields

• unErr :: ErrF e (Err e)

Instances

Foldable Err

Defined in Looksee

Methods

fold :: Monoid m => Err m -> m

foldMap :: Monoid m => (a -> m) -> Err a -> m

foldMap' :: Monoid m => (a -> m) -> Err a -> m

foldr :: (a -> b -> b) -> b -> Err a -> b

foldr' :: (a -> b -> b) -> b -> Err a -> b

foldl :: (b -> a -> b) -> b -> Err a -> b

foldl' :: (b -> a -> b) -> b -> Err a -> b

foldr1 :: (a -> a -> a) -> Err a -> a

foldl1 :: (a -> a -> a) -> Err a -> a

toList :: Err a -> [a]

null :: Err a -> Bool

length :: Err a -> Int

elem :: Eq a => a -> Err a -> Bool

maximum :: Ord a => Err a -> a

minimum :: Ord a => Err a -> a

sum :: Num a => Err a -> a

product :: Num a => Err a -> a

Traversable Err

Defined in Looksee

Methods

traverse :: Applicative f => (a -> f b) -> Err a -> f (Err b)

sequenceA :: Applicative f => Err (f a) -> f (Err a)

mapM :: Monad m => (a -> m b) -> Err a -> m (Err b)

sequence :: Monad m => Err (m a) -> m (Err a)

Functor Err

Defined in Looksee

Methods

fmap :: (a -> b) -> Err a -> Err b

(<$) :: a -> Err b -> Err a

(Typeable e, Show e) => Exception (Err e)

Defined in Looksee

Methods

toException :: Err e -> SomeException

fromException :: SomeException -> Maybe (Err e)

displayException :: Err e -> String

Show e => Show (Err e)

Defined in Looksee

Methods

showsPrec :: Int -> Err e -> ShowS

show :: Err e -> String

showList :: [Err e] -> ShowS

Eq e => Eq (Err e)

Defined in Looksee

Methods

(==) :: Err e -> Err e -> Bool

(/=) :: Err e -> Err e -> Bool

Ord e => Ord (Err e)

Defined in Looksee

Methods

compare :: Err e -> Err e -> Ordering

(<) :: Err e -> Err e -> Bool

(<=) :: Err e -> Err e -> Bool

(>) :: Err e -> Err e -> Bool

(>=) :: Err e -> Err e -> Bool

max :: Err e -> Err e -> Err e

min :: Err e -> Err e -> Err e

HasErrMessage e => HasErrMessage (Err e)

Defined in Looksee

Methods

getErrMessage :: Err e -> [Text]

Corecursive (Err e)

Defined in Looksee

Methods

embed :: Base (Err e) (Err e) -> Err e

ana :: (a -> Base (Err e) a) -> a -> Err e

apo :: (a -> Base (Err e) (Either (Err e) a)) -> a -> Err e

postpro :: Recursive (Err e) => (forall b. Base (Err e) b -> Base (Err e) b) -> (a -> Base (Err e) a) -> a -> Err e

gpostpro :: (Recursive (Err e), Monad m) => (forall b. m (Base (Err e) b) -> Base (Err e) (m b)) -> (forall c. Base (Err e) c -> Base (Err e) c) -> (a -> Base (Err e) (m a)) -> a -> Err e

Recursive (Err e)

Defined in Looksee

Methods

project :: Err e -> Base (Err e) (Err e)

cata :: (Base (Err e) a -> a) -> Err e -> a

para :: (Base (Err e) (Err e, a) -> a) -> Err e -> a

gpara :: (Corecursive (Err e), Comonad w) => (forall b. Base (Err e) (w b) -> w (Base (Err e) b)) -> (Base (Err e) (EnvT (Err e) w a) -> a) -> Err e -> a

prepro :: Corecursive (Err e) => (forall b. Base (Err e) b -> Base (Err e) b) -> (Base (Err e) a -> a) -> Err e -> a

gprepro :: (Corecursive (Err e), Comonad w) => (forall b. Base (Err e) (w b) -> w (Base (Err e) b)) -> (forall c. Base (Err e) c -> Base (Err e) c) -> (Base (Err e) (w a) -> a) -> Err e -> a

type Base (Err e)

Defined in Looksee

type Base (Err e) = ErrF e

errRange :: Err e -> Range

Range of a parse error

errReason :: Err e -> Reason e (Err e)

Reason for a parse error

data AltPhase

Phase of alternative parsing (for error reporting)

Constructors

AltPhaseBranch

AltPhaseCont

Instances

Bounded AltPhase

Defined in Looksee

Methods

minBound :: AltPhase

maxBound :: AltPhase

Enum AltPhase

Defined in Looksee

Methods

succ :: AltPhase -> AltPhase

pred :: AltPhase -> AltPhase

toEnum :: Int -> AltPhase

fromEnum :: AltPhase -> Int

enumFrom :: AltPhase -> [AltPhase]

enumFromThen :: AltPhase -> AltPhase -> [AltPhase]

enumFromTo :: AltPhase -> AltPhase -> [AltPhase]

enumFromThenTo :: AltPhase -> AltPhase -> AltPhase -> [AltPhase]

Show AltPhase

Defined in Looksee

Methods

showsPrec :: Int -> AltPhase -> ShowS

show :: AltPhase -> String

showList :: [AltPhase] -> ShowS

Eq AltPhase

Defined in Looksee

Methods

(==) :: AltPhase -> AltPhase -> Bool

(/=) :: AltPhase -> AltPhase -> Bool

Ord AltPhase

Defined in Looksee

Methods

compare :: AltPhase -> AltPhase -> Ordering

(<) :: AltPhase -> AltPhase -> Bool

(<=) :: AltPhase -> AltPhase -> Bool

(>) :: AltPhase -> AltPhase -> Bool

(>=) :: AltPhase -> AltPhase -> Bool

max :: AltPhase -> AltPhase -> AltPhase

min :: AltPhase -> AltPhase -> AltPhase

data InfixPhase

Phase of infix/split parsing (for error reporting)

Constructors

InfixPhaseLeft

InfixPhaseRight

InfixPhaseCont

Instances

Bounded InfixPhase

Defined in Looksee

Methods

minBound :: InfixPhase

maxBound :: InfixPhase

Enum InfixPhase

Defined in Looksee

Methods

succ :: InfixPhase -> InfixPhase

pred :: InfixPhase -> InfixPhase

toEnum :: Int -> InfixPhase

fromEnum :: InfixPhase -> Int

enumFrom :: InfixPhase -> [InfixPhase]

enumFromThen :: InfixPhase -> InfixPhase -> [InfixPhase]

enumFromTo :: InfixPhase -> InfixPhase -> [InfixPhase]

enumFromThenTo :: InfixPhase -> InfixPhase -> InfixPhase -> [InfixPhase]

Show InfixPhase

Defined in Looksee

Methods

showsPrec :: Int -> InfixPhase -> ShowS

show :: InfixPhase -> String

showList :: [InfixPhase] -> ShowS

Eq InfixPhase

Defined in Looksee

Methods

(==) :: InfixPhase -> InfixPhase -> Bool

(/=) :: InfixPhase -> InfixPhase -> Bool

Ord InfixPhase

Defined in Looksee

Methods

compare :: InfixPhase -> InfixPhase -> Ordering

(<) :: InfixPhase -> InfixPhase -> Bool

(<=) :: InfixPhase -> InfixPhase -> Bool

(>) :: InfixPhase -> InfixPhase -> Bool

(>=) :: InfixPhase -> InfixPhase -> Bool

max :: InfixPhase -> InfixPhase -> InfixPhase

min :: InfixPhase -> InfixPhase -> InfixPhase

data ParserT e m a

The parser monad transformer

Instances

MonadReader r m => MonadReader r (ParserT e m)

Defined in Looksee

Methods

ask :: ParserT e m r

local :: (r -> r) -> ParserT e m a -> ParserT e m a

reader :: (r -> a) -> ParserT e m a

MonadState s m => MonadState s (ParserT e m)

Defined in Looksee

Methods

get :: ParserT e m s

put :: s -> ParserT e m ()

state :: (s -> (a, s)) -> ParserT e m a

MonadTrans (ParserT e)

Defined in Looksee

Methods

lift :: Monad m => m a -> ParserT e m a

Monad m => MonadFail (ParserT e m)

Defined in Looksee

Methods

fail :: String -> ParserT e m a

MonadIO m => MonadIO (ParserT e m)

Defined in Looksee

Methods

liftIO :: IO a -> ParserT e m a

Monad m => Alternative (ParserT e m)

Defined in Looksee

Methods

empty :: ParserT e m a

(<|>) :: ParserT e m a -> ParserT e m a -> ParserT e m a

some :: ParserT e m a -> ParserT e m [a]

many :: ParserT e m a -> ParserT e m [a]

Applicative (ParserT e m)

Defined in Looksee

Methods

pure :: a -> ParserT e m a

(<*>) :: ParserT e m (a -> b) -> ParserT e m a -> ParserT e m b

liftA2 :: (a -> b -> c) -> ParserT e m a -> ParserT e m b -> ParserT e m c

(*>) :: ParserT e m a -> ParserT e m b -> ParserT e m b

(<*) :: ParserT e m a -> ParserT e m b -> ParserT e m a

Functor (ParserT e m)

Defined in Looksee

Methods

fmap :: (a -> b) -> ParserT e m a -> ParserT e m b

(<$) :: a -> ParserT e m b -> ParserT e m a

Monad (ParserT e m)

Defined in Looksee

Methods

(>>=) :: ParserT e m a -> (a -> ParserT e m b) -> ParserT e m b

(>>) :: ParserT e m a -> ParserT e m b -> ParserT e m b

return :: a -> ParserT e m a

Monoid a => Monoid (ParserT e m a)

Defined in Looksee

Methods

mempty :: ParserT e m a

mappend :: ParserT e m a -> ParserT e m a -> ParserT e m a

mconcat :: [ParserT e m a] -> ParserT e m a

Semigroup a => Semigroup (ParserT e m a)

Defined in Looksee

Methods

(<>) :: ParserT e m a -> ParserT e m a -> ParserT e m a

sconcat :: NonEmpty (ParserT e m a) -> ParserT e m a

stimes :: Integral b => b -> ParserT e m a -> ParserT e m a

type Parser e = ParserT e Identity

The parser monad

parseT :: Monad m => ParserT e m a -> Text -> m (Either (Err e) a)

Run a parser transformer. You must consume all input or this will error! If you really don't care about the rest of the input, you can always discard it with dropAllP.

parse :: Parser e a -> Text -> Either (Err e) a

Run a parser (see parseT)

parseI :: HasErrMessage e => Parser e a -> Text -> IO (Either (Err e) a)

Run a parser and print any errors that occur

throwP :: Monad m => e -> ParserT e m a

Throw a custom parse error

altP :: (Monad m, Foldable f) => f (ParserT e m a) -> ParserT e m a

Parse with many possible branches

emptyP :: Monad m => ParserT e m a

Fail with no results

endP :: Monad m => ParserT e m ()

Succeed if this is the end of input

optP :: Monad m => ParserT e m a -> ParserT e m (Maybe a)

Makes parse success optional

greedyP :: Monad m => ParserT e m a -> ParserT e m (Seq a)

Parse repeatedly until the parser fails

greedy1P :: Monad m => ParserT e m a -> ParserT e m (Seq a)

Same as greedyP but ensure at least one result

lookP :: Monad m => ParserT e m a -> ParserT e m a

Lookahead - rewinds state if the parser succeeds, otherwise throws error

labelP :: Monad m => Label -> ParserT e m a -> ParserT e m a

Labels parse errors

textP :: Monad m => Text -> ParserT e m Text

Expect the given text at the start of the range

textP_ :: Monad m => Text -> ParserT e m ()

Saves you from importing void

charP :: Monad m => Char -> ParserT e m Char

Expect the given character at the start of the range

charP_ :: Monad m => Char -> ParserT e m ()

Saves you from importing void

breakP :: Monad m => Text -> ParserT e m a -> ParserT e m a

Split once on the delimiter (first argument), parsing everything before it with a narrowed range. Chooses first split from START to END of range (see infixRP).

someBreakP :: Monad m => Text -> ParserT e m a -> ParserT e m a

Split once on the delimiter (first argument), parsing everything before it with a narrowed range. Chooses splits from START to END of range (see someInfixRP).

splitP :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a, Bool)

Split on the delimiter, parsing segments with a narrowed range, until parsing fails. Returns the sequence of successes with state at the delimiter preceding the failure (or end of input), and True if there are no more delimiters in the tail.

splitCompP :: Monad m => SplitComp -> Int -> Text -> ParserT e m a -> ParserT e m (Seq a, Bool)

split1P :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a, Bool)

Like splitP but ensures the sequence is at least length 1

infixRP :: Monad m => Text -> ParserT e m a -> ParserT e m b -> ParserT e m (a, b)

Right-associative infix parsing. Searches for the operator from START to END of range, trying only the first break point.

someInfixRP :: Monad m => Text -> ParserT e m a -> ParserT e m b -> ParserT e m (a, b)

Right-associative infix parsing. Searches for the operator from START to END of range, trying subsequent break points until success.

takeP :: Monad m => Int -> ParserT e m Text

Take the given number of characters from the start of the range, or fewer if empty

dropP :: Monad m => Int -> ParserT e m Int

Drop the given number of characters from the start of the range, or fewer if empty

takeExactP :: Monad m => Int -> ParserT e m Text

Take exactly the given number of characters from the start of the range, or error

dropExactP :: Monad m => Int -> ParserT e m ()

Drop exactly the given number of characters from the start of the range, or error

takeWhileP :: Monad m => (Char -> Bool) -> ParserT e m Text

Take characters from the start of the range satisfying the predicate

dropWhileP :: Monad m => (Char -> Bool) -> ParserT e m Int

Drop characters from the start of the range satisfying the predicate

takeWhile1P :: Monad m => (Char -> Bool) -> ParserT e m Text

Like takeWhileP but ensures at least 1 character has been taken

dropWhile1P :: Monad m => (Char -> Bool) -> ParserT e m Int

Like dropWhileP but ensures at least 1 character has been dropped

takeAllP :: Monad m => ParserT e m Text

Take the remaining range, leaving it empty

dropAllP :: Monad m => ParserT e m Int

Drop the remaining range, leaving it empty

takeAll1P :: Monad m => ParserT e m Text

Like takeAllP but ensures at least 1 character has been taken

dropAll1P :: Monad m => ParserT e m Int

Like dropAllP but ensures at least 1 character has been dropped

betweenP :: ParserT e m x -> ParserT e m y -> ParserT e m a -> ParserT e m a

Parse between an opening delimiter (first parser) and a closing delimited (second parser)

sepByP :: Monad m => ParserT e m x -> ParserT e m a -> ParserT e m (Seq a)

Parse a sequence of items delimited by the first parser

spaceP :: Monad m => ParserT e m ()

Consumes many spaces at the start of the range

stripP :: Monad m => ParserT e m a -> ParserT e m a

Strips spaces before and after parsing

stripStartP :: Monad m => ParserT e m a -> ParserT e m a

Strips spaces before parsing

stripEndP :: Monad m => ParserT e m a -> ParserT e m a

Strips spaces after parsing

measureP :: Monad m => ParserT e m a -> ParserT e m (a, Int)

Parses and returns the length of the consumed input along with the result

unconsP :: Monad m => ParserT e m (Maybe Char)

Takes exactly 1 character from the start of the range, returning Nothing if at end of input

headP :: Monad m => ParserT e m Char

Takes exactly 1 character from the start of the range, throwing error if at end of input

signedWithP :: Monad m => (a -> a) -> ParserT e m a -> ParserT e m a

Add signed-ness to any parser with a negate function

signedP :: (Monad m, Num a) => ParserT e m a -> ParserT e m a

Add signed-ness to any numeric parser

intP :: Monad m => ParserT e m Integer

Parse an signed integer

uintP :: Monad m => ParserT e m Integer

Parse an unsigned integer

decP :: Monad m => ParserT e m Rational

Parse a signed decimal

udecP :: Monad m => ParserT e m Rational

Parse an unsigned decimal

sciP :: Monad m => ParserT e m Scientific

Parse a signed scientific number

usciP :: Monad m => ParserT e m Scientific

Parse an unsigned scientific number

numP :: Monad m => ParserT e m (Either Integer Scientific)

Parse a signed integer/scientific number, defaulting to integer if possible.

unumP :: Monad m => ParserT e m (Either Integer Scientific)

Parse an unsigned integer/scientific number, defaulting to integer if possible.

repeatP :: Monad m => ParserT e m a -> ParserT e m (Seq a)

Repeat a parser until it fails, collecting the results.

repeat1P :: Monad m => ParserT e m a -> ParserT e m (Seq a)

Like repeatP but ensures at least 1

space1P :: Monad m => ParserT e m ()

Like spaceP but ensures at least 1 space removed

strip1P :: Monad m => ParserT e m a -> ParserT e m a

Like stripP but ensures at least 1 space removed

stripStart1P :: Monad m => ParserT e m a -> ParserT e m a

Like stripStartP but ensures at least 1 space removed

stripEnd1P :: Monad m => ParserT e m a -> ParserT e m a

Like stripEndP but ensures at least 1 space removed

sepBy1P :: Monad m => ParserT e m x -> ParserT e m a -> ParserT e m (Seq a)

Like sepByP but ensures at least 1 element

sepBy2P :: Monad m => ParserT e m x -> ParserT e m a -> ParserT e m (Seq a)

Like sepBy1P but ensures at least 2 elements (i.e. there was a delimiter)

transP :: (MonadTrans t, Monad m) => (forall a. t m a -> m a) -> ParserT e (t m) b -> ParserT e m b

Unwrap a monad transformer layer (see scopeP for use)

scopeP :: Monad m => s -> ParserT e (StateT s m) a -> ParserT e m a

Parse with some local state

iterP :: ParserT e m (Maybe a) -> ParserT e m a

Repeats the parser until it returns a Just value

strP :: Monad m => Char -> ParserT e m Text

Parse a string with a custom quote character. Supports backslash-escaping.

doubleStrP :: Monad m => ParserT e m Text

Parse a double-quoted string

singleStrP :: Monad m => ParserT e m Text

Parse a single-quoted string

class HasErrMessage e where

Implement this to format custom errors. The list will be joined with unlines.

Methods

getErrMessage :: e -> [Text]

Instances

HasErrMessage Void

Defined in Looksee

Methods

getErrMessage :: Void -> [Text]

HasErrMessage e => HasErrMessage (Err e)

Defined in Looksee

Methods

getErrMessage :: Err e -> [Text]

errataE :: HasErrMessage e => FilePath -> (Int -> (Line, Column)) -> Err e -> [Errata]

Create Errata formatting a parse error

renderE :: HasErrMessage e => FilePath -> Text -> Err e -> Text

Render a formatted error to text

printE :: HasErrMessage e => FilePath -> Text -> Err e -> IO ()

Print a formatted error to stderr