SimpleParser.Result

Documentation

data RawError chunk token

Constructors

RawErrorMatchEnd !token

RawErrorAnyToken

RawErrorAnyChunk

RawErrorSatisfyToken !(Maybe token)

RawErrorMatchToken !token !(Maybe token)

RawErrorMatchChunk !chunk !(Maybe chunk)

RawErrorTakeTokensWhile1 !(Maybe token)

RawErrorDropTokensWhile1 !(Maybe token)

Instances

(Eq token, Eq chunk) => Eq (RawError chunk token)

Defined in SimpleParser.Result

Methods

(==) :: RawError chunk token -> RawError chunk token -> Bool

(/=) :: RawError chunk token -> RawError chunk token -> Bool

(Show token, Show chunk) => Show (RawError chunk token)

Defined in SimpleParser.Result

Methods

showsPrec :: Int -> RawError chunk token -> ShowS

show :: RawError chunk token -> String

showList :: [RawError chunk token] -> ShowS

newtype StreamError s

RawStreamError specialized to Stream types - newtyped to allow GHC to derive eq/show in the absense of type families.

Constructors

StreamError

Fields

• unStreamError :: RawError (Chunk s) (Token s)

Instances

(Eq (Token s), Eq (Chunk s)) => Eq (StreamError s)

Defined in SimpleParser.Result

Methods

(==) :: StreamError s -> StreamError s -> Bool

(/=) :: StreamError s -> StreamError s -> Bool

(Show (Token s), Show (Chunk s)) => Show (StreamError s)

Defined in SimpleParser.Result

Methods

showsPrec :: Int -> StreamError s -> ShowS

show :: StreamError s -> String

showList :: [StreamError s] -> ShowS

(Token s ~ Char, TextualChunked (Chunk s)) => ExplainError (StreamError s)

Defined in SimpleParser.Explain

Methods

explainError :: StreamError s -> ErrorExplanation

coerceStreamError :: (Chunk s ~ Chunk t, Token s ~ Token t) => StreamError s -> StreamError t

data CompoundError s e

Constructors

CompoundErrorStream !(StreamError s)

CompoundErrorFail !Text

CompoundErrorCustom !e

Instances

Functor (CompoundError s)

Defined in SimpleParser.Result

Methods

fmap :: (a -> b) -> CompoundError s a -> CompoundError s b

(<$) :: a -> CompoundError s b -> CompoundError s a

Foldable (CompoundError s)

Defined in SimpleParser.Result

Methods

fold :: Monoid m => CompoundError s m -> m

foldMap :: Monoid m => (a -> m) -> CompoundError s a -> m

foldMap' :: Monoid m => (a -> m) -> CompoundError s a -> m

foldr :: (a -> b -> b) -> b -> CompoundError s a -> b

foldr' :: (a -> b -> b) -> b -> CompoundError s a -> b

foldl :: (b -> a -> b) -> b -> CompoundError s a -> b

foldl' :: (b -> a -> b) -> b -> CompoundError s a -> b

foldr1 :: (a -> a -> a) -> CompoundError s a -> a

foldl1 :: (a -> a -> a) -> CompoundError s a -> a

toList :: CompoundError s a -> [a]

null :: CompoundError s a -> Bool

length :: CompoundError s a -> Int

elem :: Eq a => a -> CompoundError s a -> Bool

maximum :: Ord a => CompoundError s a -> a

minimum :: Ord a => CompoundError s a -> a

sum :: Num a => CompoundError s a -> a

product :: Num a => CompoundError s a -> a

Traversable (CompoundError s)

Defined in SimpleParser.Result

Methods

traverse :: Applicative f => (a -> f b) -> CompoundError s a -> f (CompoundError s b)

sequenceA :: Applicative f => CompoundError s (f a) -> f (CompoundError s a)

mapM :: Monad m => (a -> m b) -> CompoundError s a -> m (CompoundError s b)

sequence :: Monad m => CompoundError s (m a) -> m (CompoundError s a)

(Eq (Token s), Eq (Chunk s), Eq e) => Eq (CompoundError s e)

Defined in SimpleParser.Result

Methods

(==) :: CompoundError s e -> CompoundError s e -> Bool

(/=) :: CompoundError s e -> CompoundError s e -> Bool

(Show (Token s), Show (Chunk s), Show e) => Show (CompoundError s e)

Defined in SimpleParser.Result

Methods

showsPrec :: Int -> CompoundError s e -> ShowS

show :: CompoundError s e -> String

showList :: [CompoundError s e] -> ShowS

(Token s ~ Char, TextualChunked (Chunk s), ExplainError e) => ExplainError (CompoundError s e)

Defined in SimpleParser.Explain

Methods

explainError :: CompoundError s e -> ErrorExplanation

data Mark l s

Constructors

Mark

Fields

• markLabel :: !(Maybe l)
• markState :: !s

Instances

(Eq l, Eq s) => Eq (Mark l s)

Defined in SimpleParser.Result

Methods

(==) :: Mark l s -> Mark l s -> Bool

(/=) :: Mark l s -> Mark l s -> Bool

(Show l, Show s) => Show (Mark l s)

Defined in SimpleParser.Result

Methods

showsPrec :: Int -> Mark l s -> ShowS

show :: Mark l s -> String

showList :: [Mark l s] -> ShowS

data ParseError l s e

Constructors

ParseError

Fields

• peMarkStack :: !(MarkStack l s)
• peEndState :: !s
• peError :: !(CompoundError s e)

Instances

(Eq l, Eq s, Eq (Token s), Eq (Chunk s), Eq e) => Eq (ParseError l s e)

Defined in SimpleParser.Result

Methods

(==) :: ParseError l s e -> ParseError l s e -> Bool

(/=) :: ParseError l s e -> ParseError l s e -> Bool

(Show l, Show s, Show (Token s), Show (Chunk s), Show e) => Show (ParseError l s e)

Defined in SimpleParser.Result

Methods

showsPrec :: Int -> ParseError l s e -> ShowS

show :: ParseError l s e -> String

showList :: [ParseError l s e] -> ShowS

(Typeable l, Typeable s, Typeable (Token s), Typeable (Chunk s), Typeable e, Show l, Show s, Show (Token s), Show (Chunk s), Show e) => Exception (ParseError l s e)

Defined in SimpleParser.Result

Methods

toException :: ParseError l s e -> SomeException

fromException :: SomeException -> Maybe (ParseError l s e)

displayException :: ParseError l s e -> String

parseErrorResume :: ParseError l s e -> s

Returns the resumption point of the ParseError. If it has been marked, we use that, otherwise we assume it starts at the exact error point.

parseErrorLabels :: ParseError l s e -> Seq l

Returns the sequence of ALL labels from coarsest to finest.

markParseError :: Mark l s -> ParseError l s e -> ParseError l s e

Updates a ParseError with a resumption point.

unmarkParseError :: ParseError l s e -> ParseError l s e

Clears marks from a ParseError.

parseErrorEnclosingLabels :: ParseError l s e -> Seq l

Returns labels enclosing the narrowest span, from coarsest to finest Does NOT include the label for the narrowest span (if any).

parseErrorNarrowestSpan :: PosStream s => ParseError l s e -> (Maybe l, Span (Pos s))

Returns the narrowest span

newtype ParseErrorBundle l s e

Constructors

ParseErrorBundle

Fields

• unParseErrorBundle :: NESeq (ParseError l s e)

Instances

(Eq l, Eq s, Eq (Token s), Eq (Chunk s), Eq e) => Eq (ParseErrorBundle l s e)

Defined in SimpleParser.Result

Methods

(==) :: ParseErrorBundle l s e -> ParseErrorBundle l s e -> Bool

(/=) :: ParseErrorBundle l s e -> ParseErrorBundle l s e -> Bool

(Show l, Show s, Show (Token s), Show (Chunk s), Show e) => Show (ParseErrorBundle l s e)

Defined in SimpleParser.Result

Methods

showsPrec :: Int -> ParseErrorBundle l s e -> ShowS

show :: ParseErrorBundle l s e -> String

showList :: [ParseErrorBundle l s e] -> ShowS

(Typeable l, Typeable s, Typeable (Token s), Typeable (Chunk s), Typeable e, Show l, Show s, Show (Token s), Show (Chunk s), Show e) => Exception (ParseErrorBundle l s e)

Defined in SimpleParser.Result

Methods

toException :: ParseErrorBundle l s e -> SomeException

fromException :: SomeException -> Maybe (ParseErrorBundle l s e)

displayException :: ParseErrorBundle l s e -> String

listParseErrors :: ParseErrorBundle l s e -> [ParseError l s e]

Lists all errors in the bundle.

matchSoleParseError :: ParseErrorBundle l s e -> Maybe (ParseError l s e)

If there is only one parse error in the bundle, return it, otherwise return nothing. Errors can accumulate if you use unrestricted branching (with orParser or Alternative <|>) or manual Parser constructor application. However, if you always branch with lookAheadMatch then you will have singleton parse errors, and this will always return Just.

data ParseSuccess s a

Constructors

ParseSuccess

Fields

• psEndState :: !s
• psValue :: !a

Instances

Functor (ParseSuccess s)

Defined in SimpleParser.Result

Methods

fmap :: (a -> b) -> ParseSuccess s a -> ParseSuccess s b

(<$) :: a -> ParseSuccess s b -> ParseSuccess s a

Foldable (ParseSuccess s)

Defined in SimpleParser.Result

Methods

fold :: Monoid m => ParseSuccess s m -> m

foldMap :: Monoid m => (a -> m) -> ParseSuccess s a -> m

foldMap' :: Monoid m => (a -> m) -> ParseSuccess s a -> m

foldr :: (a -> b -> b) -> b -> ParseSuccess s a -> b

foldr' :: (a -> b -> b) -> b -> ParseSuccess s a -> b

foldl :: (b -> a -> b) -> b -> ParseSuccess s a -> b

foldl' :: (b -> a -> b) -> b -> ParseSuccess s a -> b

foldr1 :: (a -> a -> a) -> ParseSuccess s a -> a

foldl1 :: (a -> a -> a) -> ParseSuccess s a -> a

toList :: ParseSuccess s a -> [a]

null :: ParseSuccess s a -> Bool

length :: ParseSuccess s a -> Int

elem :: Eq a => a -> ParseSuccess s a -> Bool

maximum :: Ord a => ParseSuccess s a -> a

minimum :: Ord a => ParseSuccess s a -> a

sum :: Num a => ParseSuccess s a -> a

product :: Num a => ParseSuccess s a -> a

Traversable (ParseSuccess s)

Defined in SimpleParser.Result

Methods

traverse :: Applicative f => (a -> f b) -> ParseSuccess s a -> f (ParseSuccess s b)

sequenceA :: Applicative f => ParseSuccess s (f a) -> f (ParseSuccess s a)

mapM :: Monad m => (a -> m b) -> ParseSuccess s a -> m (ParseSuccess s b)

sequence :: Monad m => ParseSuccess s (m a) -> m (ParseSuccess s a)

(Eq s, Eq a) => Eq (ParseSuccess s a)

Defined in SimpleParser.Result

Methods

(==) :: ParseSuccess s a -> ParseSuccess s a -> Bool

(/=) :: ParseSuccess s a -> ParseSuccess s a -> Bool

(Show s, Show a) => Show (ParseSuccess s a)

Defined in SimpleParser.Result

Methods

showsPrec :: Int -> ParseSuccess s a -> ShowS

show :: ParseSuccess s a -> String

showList :: [ParseSuccess s a] -> ShowS

data ParseResult l s e a

Constructors

ParseResultError !(ParseErrorBundle l s e)

ParseResultSuccess !(ParseSuccess s a)

Instances

Functor (ParseResult l s e)

Defined in SimpleParser.Result

Methods

fmap :: (a -> b) -> ParseResult l s e a -> ParseResult l s e b

(<$) :: a -> ParseResult l s e b -> ParseResult l s e a

Foldable (ParseResult l s e)

Defined in SimpleParser.Result

Methods

fold :: Monoid m => ParseResult l s e m -> m

foldMap :: Monoid m => (a -> m) -> ParseResult l s e a -> m

foldMap' :: Monoid m => (a -> m) -> ParseResult l s e a -> m

foldr :: (a -> b -> b) -> b -> ParseResult l s e a -> b

foldr' :: (a -> b -> b) -> b -> ParseResult l s e a -> b

foldl :: (b -> a -> b) -> b -> ParseResult l s e a -> b

foldl' :: (b -> a -> b) -> b -> ParseResult l s e a -> b

foldr1 :: (a -> a -> a) -> ParseResult l s e a -> a

foldl1 :: (a -> a -> a) -> ParseResult l s e a -> a

toList :: ParseResult l s e a -> [a]

null :: ParseResult l s e a -> Bool

length :: ParseResult l s e a -> Int

elem :: Eq a => a -> ParseResult l s e a -> Bool

maximum :: Ord a => ParseResult l s e a -> a

minimum :: Ord a => ParseResult l s e a -> a

sum :: Num a => ParseResult l s e a -> a

product :: Num a => ParseResult l s e a -> a

Traversable (ParseResult l s e)

Defined in SimpleParser.Result

Methods

traverse :: Applicative f => (a -> f b) -> ParseResult l s e a -> f (ParseResult l s e b)

sequenceA :: Applicative f => ParseResult l s e (f a) -> f (ParseResult l s e a)

mapM :: Monad m => (a -> m b) -> ParseResult l s e a -> m (ParseResult l s e b)

sequence :: Monad m => ParseResult l s e (m a) -> m (ParseResult l s e a)

(Eq l, Eq s, Eq (Token s), Eq (Chunk s), Eq e, Eq a) => Eq (ParseResult l s e a)

Defined in SimpleParser.Result

Methods

(==) :: ParseResult l s e a -> ParseResult l s e a -> Bool

(/=) :: ParseResult l s e a -> ParseResult l s e a -> Bool

(Show l, Show s, Show (Token s), Show (Chunk s), Show e, Show a) => Show (ParseResult l s e a)

Defined in SimpleParser.Result

Methods

showsPrec :: Int -> ParseResult l s e a -> ShowS

show :: ParseResult l s e a -> String

showList :: [ParseResult l s e a] -> ShowS