{-# LANGUAGE UndecidableInstances #-}
module SimpleParser.Result
( RawError (..)
, StreamError (..)
, coerceStreamError
, CompoundError (..)
, Mark (..)
, MarkStack
, ParseError (..)
, parseErrorResume
, parseErrorLabels
, markParseError
, unmarkParseError
, parseErrorEnclosingLabels
, parseErrorNarrowestSpan
, ParseErrorBundle (..)
, listParseErrors
, matchSoleParseError
, ParseSuccess (..)
, ParseResult (..)
) where
import Control.Exception (Exception)
import Data.Foldable (toList)
import Data.Sequence (Seq (..))
import qualified Data.Sequence as Seq
import Data.Sequence.NonEmpty (NESeq (..))
import Data.Text (Text)
import Data.Typeable (Typeable)
import SimpleParser.Stack (Stack (..), bottomStack, bottomUpStack, emptyStack, pushStack, topStack)
import SimpleParser.Stream (PosStream (..), Span (..), Stream (..))
data RawError chunk token =
RawErrorMatchEnd !token
| RawErrorAnyToken
| RawErrorAnyChunk
| RawErrorSatisfyToken !(Maybe token)
| RawErrorMatchToken !token !(Maybe token)
| RawErrorMatchChunk !chunk !(Maybe chunk)
| RawErrorTakeTokensWhile1 !(Maybe token)
| RawErrorDropTokensWhile1 !(Maybe token)
deriving (RawError chunk token -> RawError chunk token -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall chunk token.
(Eq token, Eq chunk) =>
RawError chunk token -> RawError chunk token -> Bool
/= :: RawError chunk token -> RawError chunk token -> Bool
$c/= :: forall chunk token.
(Eq token, Eq chunk) =>
RawError chunk token -> RawError chunk token -> Bool
== :: RawError chunk token -> RawError chunk token -> Bool
$c== :: forall chunk token.
(Eq token, Eq chunk) =>
RawError chunk token -> RawError chunk token -> Bool
Eq, Int -> RawError chunk token -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall chunk token.
(Show token, Show chunk) =>
Int -> RawError chunk token -> ShowS
forall chunk token.
(Show token, Show chunk) =>
[RawError chunk token] -> ShowS
forall chunk token.
(Show token, Show chunk) =>
RawError chunk token -> String
showList :: [RawError chunk token] -> ShowS
$cshowList :: forall chunk token.
(Show token, Show chunk) =>
[RawError chunk token] -> ShowS
show :: RawError chunk token -> String
$cshow :: forall chunk token.
(Show token, Show chunk) =>
RawError chunk token -> String
showsPrec :: Int -> RawError chunk token -> ShowS
$cshowsPrec :: forall chunk token.
(Show token, Show chunk) =>
Int -> RawError chunk token -> ShowS
Show)
newtype StreamError s = StreamError
{ forall s. StreamError s -> RawError (Chunk s) (Token s)
unStreamError :: RawError (Chunk s) (Token s)
}
deriving instance (Eq (Token s), Eq (Chunk s)) => Eq (StreamError s)
deriving instance (Show (Token s), Show (Chunk s)) => Show (StreamError s)
coerceStreamError :: (Chunk s ~ Chunk t, Token s ~ Token t) => StreamError s -> StreamError t
coerceStreamError :: forall s t.
(Chunk s ~ Chunk t, Token s ~ Token t) =>
StreamError s -> StreamError t
coerceStreamError = forall s. RawError (Chunk s) (Token s) -> StreamError s
StreamError forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s. StreamError s -> RawError (Chunk s) (Token s)
unStreamError
data CompoundError s e =
CompoundErrorStream !(StreamError s)
| CompoundErrorFail !Text
| CompoundErrorCustom !e
deriving (forall a b. a -> CompoundError s b -> CompoundError s a
forall a b. (a -> b) -> CompoundError s a -> CompoundError s b
forall s a b. a -> CompoundError s b -> CompoundError s a
forall s a b. (a -> b) -> CompoundError s a -> CompoundError s b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> CompoundError s b -> CompoundError s a
$c<$ :: forall s a b. a -> CompoundError s b -> CompoundError s a
fmap :: forall a b. (a -> b) -> CompoundError s a -> CompoundError s b
$cfmap :: forall s a b. (a -> b) -> CompoundError s a -> CompoundError s b
Functor, forall a. CompoundError s a -> Bool
forall s a. Eq a => a -> CompoundError s a -> Bool
forall s a. Num a => CompoundError s a -> a
forall s a. Ord a => CompoundError s a -> a
forall m a. Monoid m => (a -> m) -> CompoundError s a -> m
forall s m. Monoid m => CompoundError s m -> m
forall s a. CompoundError s a -> Bool
forall s a. CompoundError s a -> Int
forall s a. CompoundError s a -> [a]
forall a b. (a -> b -> b) -> b -> CompoundError s a -> b
forall s a. (a -> a -> a) -> CompoundError s a -> a
forall s m a. Monoid m => (a -> m) -> CompoundError s a -> m
forall s b a. (b -> a -> b) -> b -> CompoundError s a -> b
forall s a b. (a -> b -> b) -> b -> CompoundError s a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => CompoundError s a -> a
$cproduct :: forall s a. Num a => CompoundError s a -> a
sum :: forall a. Num a => CompoundError s a -> a
$csum :: forall s a. Num a => CompoundError s a -> a
minimum :: forall a. Ord a => CompoundError s a -> a
$cminimum :: forall s a. Ord a => CompoundError s a -> a
maximum :: forall a. Ord a => CompoundError s a -> a
$cmaximum :: forall s a. Ord a => CompoundError s a -> a
elem :: forall a. Eq a => a -> CompoundError s a -> Bool
$celem :: forall s a. Eq a => a -> CompoundError s a -> Bool
length :: forall a. CompoundError s a -> Int
$clength :: forall s a. CompoundError s a -> Int
null :: forall a. CompoundError s a -> Bool
$cnull :: forall s a. CompoundError s a -> Bool
toList :: forall a. CompoundError s a -> [a]
$ctoList :: forall s a. CompoundError s a -> [a]
foldl1 :: forall a. (a -> a -> a) -> CompoundError s a -> a
$cfoldl1 :: forall s a. (a -> a -> a) -> CompoundError s a -> a
foldr1 :: forall a. (a -> a -> a) -> CompoundError s a -> a
$cfoldr1 :: forall s a. (a -> a -> a) -> CompoundError s a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> CompoundError s a -> b
$cfoldl' :: forall s b a. (b -> a -> b) -> b -> CompoundError s a -> b
foldl :: forall b a. (b -> a -> b) -> b -> CompoundError s a -> b
$cfoldl :: forall s b a. (b -> a -> b) -> b -> CompoundError s a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> CompoundError s a -> b
$cfoldr' :: forall s a b. (a -> b -> b) -> b -> CompoundError s a -> b
foldr :: forall a b. (a -> b -> b) -> b -> CompoundError s a -> b
$cfoldr :: forall s a b. (a -> b -> b) -> b -> CompoundError s a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> CompoundError s a -> m
$cfoldMap' :: forall s m a. Monoid m => (a -> m) -> CompoundError s a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> CompoundError s a -> m
$cfoldMap :: forall s m a. Monoid m => (a -> m) -> CompoundError s a -> m
fold :: forall m. Monoid m => CompoundError s m -> m
$cfold :: forall s m. Monoid m => CompoundError s m -> m
Foldable, forall s. Functor (CompoundError s)
forall s. Foldable (CompoundError s)
forall s (m :: * -> *) a.
Monad m =>
CompoundError s (m a) -> m (CompoundError s a)
forall s (f :: * -> *) a.
Applicative f =>
CompoundError s (f a) -> f (CompoundError s a)
forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CompoundError s a -> m (CompoundError s b)
forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CompoundError s a -> f (CompoundError s b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CompoundError s a -> f (CompoundError s b)
sequence :: forall (m :: * -> *) a.
Monad m =>
CompoundError s (m a) -> m (CompoundError s a)
$csequence :: forall s (m :: * -> *) a.
Monad m =>
CompoundError s (m a) -> m (CompoundError s a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CompoundError s a -> m (CompoundError s b)
$cmapM :: forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CompoundError s a -> m (CompoundError s b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
CompoundError s (f a) -> f (CompoundError s a)
$csequenceA :: forall s (f :: * -> *) a.
Applicative f =>
CompoundError s (f a) -> f (CompoundError s a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CompoundError s a -> f (CompoundError s b)
$ctraverse :: forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CompoundError s a -> f (CompoundError s b)
Traversable)
deriving instance (Eq (Token s), Eq (Chunk s), Eq e) => Eq (CompoundError s e)
deriving instance (Show (Token s), Show (Chunk s), Show e) => Show (CompoundError s e)
data Mark l s = Mark
{ forall l s. Mark l s -> Maybe l
markLabel :: !(Maybe l)
, forall l s. Mark l s -> s
markState :: !s
} deriving (Mark l s -> Mark l s -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall l s. (Eq l, Eq s) => Mark l s -> Mark l s -> Bool
/= :: Mark l s -> Mark l s -> Bool
$c/= :: forall l s. (Eq l, Eq s) => Mark l s -> Mark l s -> Bool
== :: Mark l s -> Mark l s -> Bool
$c== :: forall l s. (Eq l, Eq s) => Mark l s -> Mark l s -> Bool
Eq, Int -> Mark l s -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall l s. (Show l, Show s) => Int -> Mark l s -> ShowS
forall l s. (Show l, Show s) => [Mark l s] -> ShowS
forall l s. (Show l, Show s) => Mark l s -> String
showList :: [Mark l s] -> ShowS
$cshowList :: forall l s. (Show l, Show s) => [Mark l s] -> ShowS
show :: Mark l s -> String
$cshow :: forall l s. (Show l, Show s) => Mark l s -> String
showsPrec :: Int -> Mark l s -> ShowS
$cshowsPrec :: forall l s. (Show l, Show s) => Int -> Mark l s -> ShowS
Show)
type MarkStack l s = Stack (Mark l s)
markStackLabels :: MarkStack l s -> Seq l
markStackLabels :: forall l s. MarkStack l s -> Seq l
markStackLabels = forall a b. (a -> Maybe b) -> Stack a -> Seq b
bottomUpStack forall l s. Mark l s -> Maybe l
markLabel
data ParseError l s e = ParseError
{ forall l s e. ParseError l s e -> MarkStack l s
peMarkStack :: !(MarkStack l s)
, forall l s e. ParseError l s e -> s
peEndState :: !s
, forall l s e. ParseError l s e -> CompoundError s e
peError :: !(CompoundError s e)
}
deriving instance (Eq l, Eq s, Eq (Token s), Eq (Chunk s), Eq e) => Eq (ParseError l s e)
deriving instance (Show l, Show s, Show (Token s), Show (Chunk s), Show e) => Show (ParseError l s e)
instance (
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)
parseErrorResume :: ParseError l s e -> s
parseErrorResume :: forall l s e. ParseError l s e -> s
parseErrorResume ParseError l s e
pe = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall l s e. ParseError l s e -> s
peEndState ParseError l s e
pe) forall l s. Mark l s -> s
markState (forall a. Stack a -> Maybe a
topStack (forall l s e. ParseError l s e -> MarkStack l s
peMarkStack ParseError l s e
pe))
parseErrorLabels :: ParseError l s e -> Seq l
parseErrorLabels :: forall l s e. ParseError l s e -> Seq l
parseErrorLabels = forall l s. MarkStack l s -> Seq l
markStackLabels forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l s e. ParseError l s e -> MarkStack l s
peMarkStack
markParseError :: Mark l s -> ParseError l s e -> ParseError l s e
markParseError :: forall l s e. Mark l s -> ParseError l s e -> ParseError l s e
markParseError Mark l s
s ParseError l s e
pe = ParseError l s e
pe { peMarkStack :: MarkStack l s
peMarkStack = forall a. a -> Stack a -> Stack a
pushStack Mark l s
s (forall l s e. ParseError l s e -> MarkStack l s
peMarkStack ParseError l s e
pe) }
unmarkParseError :: ParseError l s e -> ParseError l s e
unmarkParseError :: forall l s e. ParseError l s e -> ParseError l s e
unmarkParseError ParseError l s e
pe = ParseError l s e
pe { peMarkStack :: MarkStack l s
peMarkStack = forall a. Stack a
emptyStack }
parseErrorNarrowestSpan :: PosStream s => ParseError l s e -> (Maybe l, Span (Pos s))
parseErrorNarrowestSpan :: forall s l e.
PosStream s =>
ParseError l s e -> (Maybe l, Span (Pos s))
parseErrorNarrowestSpan ParseError l s e
pe = (Maybe l
ml, forall p. p -> p -> Span p
Span Pos s
startPos Pos s
endPos) where
endPos :: Pos s
endPos = forall s. PosStream s => s -> Pos s
streamViewPos (forall l s e. ParseError l s e -> s
peEndState ParseError l s e
pe)
(Maybe l
ml, Pos s
startPos) = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a. Maybe a
Nothing, Pos s
endPos) (\(Mark Maybe l
mx s
s) -> (Maybe l
mx, forall s. PosStream s => s -> Pos s
streamViewPos s
s)) (forall a. Stack a -> Maybe a
bottomStack (forall l s e. ParseError l s e -> MarkStack l s
peMarkStack ParseError l s e
pe))
parseErrorEnclosingLabels :: ParseError l s e -> Seq l
parseErrorEnclosingLabels :: forall l s e. ParseError l s e -> Seq l
parseErrorEnclosingLabels ParseError l s e
pe =
case forall a. Stack a -> Seq a
unStack (forall l s e. ParseError l s e -> MarkStack l s
peMarkStack ParseError l s e
pe) of
Seq (Mark l s)
Empty -> forall a. Seq a
Empty
Mark l s
_ :<| Seq (Mark l s)
s -> Seq (Mark l s)
s forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(Mark Maybe l
ml s
_) -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Seq a
Seq.empty forall a. a -> Seq a
Seq.singleton Maybe l
ml
data ParseSuccess s a = ParseSuccess
{ forall s a. ParseSuccess s a -> s
psEndState :: !s
, forall s a. ParseSuccess s a -> a
psValue :: !a
} deriving (ParseSuccess s a -> ParseSuccess s a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall s a.
(Eq s, Eq a) =>
ParseSuccess s a -> ParseSuccess s a -> Bool
/= :: ParseSuccess s a -> ParseSuccess s a -> Bool
$c/= :: forall s a.
(Eq s, Eq a) =>
ParseSuccess s a -> ParseSuccess s a -> Bool
== :: ParseSuccess s a -> ParseSuccess s a -> Bool
$c== :: forall s a.
(Eq s, Eq a) =>
ParseSuccess s a -> ParseSuccess s a -> Bool
Eq, Int -> ParseSuccess s a -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall s a. (Show s, Show a) => Int -> ParseSuccess s a -> ShowS
forall s a. (Show s, Show a) => [ParseSuccess s a] -> ShowS
forall s a. (Show s, Show a) => ParseSuccess s a -> String
showList :: [ParseSuccess s a] -> ShowS
$cshowList :: forall s a. (Show s, Show a) => [ParseSuccess s a] -> ShowS
show :: ParseSuccess s a -> String
$cshow :: forall s a. (Show s, Show a) => ParseSuccess s a -> String
showsPrec :: Int -> ParseSuccess s a -> ShowS
$cshowsPrec :: forall s a. (Show s, Show a) => Int -> ParseSuccess s a -> ShowS
Show, forall a b. a -> ParseSuccess s b -> ParseSuccess s a
forall a b. (a -> b) -> ParseSuccess s a -> ParseSuccess s b
forall s a b. a -> ParseSuccess s b -> ParseSuccess s a
forall s a b. (a -> b) -> ParseSuccess s a -> ParseSuccess s b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ParseSuccess s b -> ParseSuccess s a
$c<$ :: forall s a b. a -> ParseSuccess s b -> ParseSuccess s a
fmap :: forall a b. (a -> b) -> ParseSuccess s a -> ParseSuccess s b
$cfmap :: forall s a b. (a -> b) -> ParseSuccess s a -> ParseSuccess s b
Functor, forall a. ParseSuccess s a -> Bool
forall s a. Eq a => a -> ParseSuccess s a -> Bool
forall s a. Num a => ParseSuccess s a -> a
forall s a. Ord a => ParseSuccess s a -> a
forall m a. Monoid m => (a -> m) -> ParseSuccess s a -> m
forall s m. Monoid m => ParseSuccess s m -> m
forall s a. ParseSuccess s a -> Bool
forall s a. ParseSuccess s a -> Int
forall s a. ParseSuccess s a -> [a]
forall a b. (a -> b -> b) -> b -> ParseSuccess s a -> b
forall s a. (a -> a -> a) -> ParseSuccess s a -> a
forall s m a. Monoid m => (a -> m) -> ParseSuccess s a -> m
forall s b a. (b -> a -> b) -> b -> ParseSuccess s a -> b
forall s a b. (a -> b -> b) -> b -> ParseSuccess s a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => ParseSuccess s a -> a
$cproduct :: forall s a. Num a => ParseSuccess s a -> a
sum :: forall a. Num a => ParseSuccess s a -> a
$csum :: forall s a. Num a => ParseSuccess s a -> a
minimum :: forall a. Ord a => ParseSuccess s a -> a
$cminimum :: forall s a. Ord a => ParseSuccess s a -> a
maximum :: forall a. Ord a => ParseSuccess s a -> a
$cmaximum :: forall s a. Ord a => ParseSuccess s a -> a
elem :: forall a. Eq a => a -> ParseSuccess s a -> Bool
$celem :: forall s a. Eq a => a -> ParseSuccess s a -> Bool
length :: forall a. ParseSuccess s a -> Int
$clength :: forall s a. ParseSuccess s a -> Int
null :: forall a. ParseSuccess s a -> Bool
$cnull :: forall s a. ParseSuccess s a -> Bool
toList :: forall a. ParseSuccess s a -> [a]
$ctoList :: forall s a. ParseSuccess s a -> [a]
foldl1 :: forall a. (a -> a -> a) -> ParseSuccess s a -> a
$cfoldl1 :: forall s a. (a -> a -> a) -> ParseSuccess s a -> a
foldr1 :: forall a. (a -> a -> a) -> ParseSuccess s a -> a
$cfoldr1 :: forall s a. (a -> a -> a) -> ParseSuccess s a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> ParseSuccess s a -> b
$cfoldl' :: forall s b a. (b -> a -> b) -> b -> ParseSuccess s a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ParseSuccess s a -> b
$cfoldl :: forall s b a. (b -> a -> b) -> b -> ParseSuccess s a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ParseSuccess s a -> b
$cfoldr' :: forall s a b. (a -> b -> b) -> b -> ParseSuccess s a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ParseSuccess s a -> b
$cfoldr :: forall s a b. (a -> b -> b) -> b -> ParseSuccess s a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> ParseSuccess s a -> m
$cfoldMap' :: forall s m a. Monoid m => (a -> m) -> ParseSuccess s a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ParseSuccess s a -> m
$cfoldMap :: forall s m a. Monoid m => (a -> m) -> ParseSuccess s a -> m
fold :: forall m. Monoid m => ParseSuccess s m -> m
$cfold :: forall s m. Monoid m => ParseSuccess s m -> m
Foldable, forall s. Functor (ParseSuccess s)
forall s. Foldable (ParseSuccess s)
forall s (m :: * -> *) a.
Monad m =>
ParseSuccess s (m a) -> m (ParseSuccess s a)
forall s (f :: * -> *) a.
Applicative f =>
ParseSuccess s (f a) -> f (ParseSuccess s a)
forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParseSuccess s a -> m (ParseSuccess s b)
forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseSuccess s a -> f (ParseSuccess s b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseSuccess s a -> f (ParseSuccess s b)
sequence :: forall (m :: * -> *) a.
Monad m =>
ParseSuccess s (m a) -> m (ParseSuccess s a)
$csequence :: forall s (m :: * -> *) a.
Monad m =>
ParseSuccess s (m a) -> m (ParseSuccess s a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParseSuccess s a -> m (ParseSuccess s b)
$cmapM :: forall s (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParseSuccess s a -> m (ParseSuccess s b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ParseSuccess s (f a) -> f (ParseSuccess s a)
$csequenceA :: forall s (f :: * -> *) a.
Applicative f =>
ParseSuccess s (f a) -> f (ParseSuccess s a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseSuccess s a -> f (ParseSuccess s b)
$ctraverse :: forall s (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseSuccess s a -> f (ParseSuccess s b)
Traversable)
newtype ParseErrorBundle l s e = ParseErrorBundle { forall l s e. ParseErrorBundle l s e -> NESeq (ParseError l s e)
unParseErrorBundle :: NESeq (ParseError l s e) }
deriving instance (Eq l, Eq s, Eq (Token s), Eq (Chunk s), Eq e) => Eq (ParseErrorBundle l s e)
deriving instance (Show l, Show s, Show (Token s), Show (Chunk s), Show e) => Show (ParseErrorBundle l s e)
instance (
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)
listParseErrors :: ParseErrorBundle l s e -> [ParseError l s e]
listParseErrors :: forall l s e. ParseErrorBundle l s e -> [ParseError l s e]
listParseErrors = forall (t :: * -> *) a. Foldable t => t a -> [a]
toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l s e. ParseErrorBundle l s e -> NESeq (ParseError l s e)
unParseErrorBundle
matchSoleParseError :: ParseErrorBundle l s e -> Maybe (ParseError l s e)
matchSoleParseError :: forall l s e. ParseErrorBundle l s e -> Maybe (ParseError l s e)
matchSoleParseError (ParseErrorBundle NESeq (ParseError l s e)
es) =
case NESeq (ParseError l s e)
es of
ParseError l s e
e :<|| Seq (ParseError l s e)
Empty -> forall a. a -> Maybe a
Just ParseError l s e
e
NESeq (ParseError l s e)
_ -> forall a. Maybe a
Nothing
data ParseResult l s e a =
ParseResultError !(ParseErrorBundle l s e)
| ParseResultSuccess !(ParseSuccess s a)
deriving (forall a b. a -> ParseResult l s e b -> ParseResult l s e a
forall a b. (a -> b) -> ParseResult l s e a -> ParseResult l s e b
forall l s e a b. a -> ParseResult l s e b -> ParseResult l s e a
forall l s e a b.
(a -> b) -> ParseResult l s e a -> ParseResult l s e b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ParseResult l s e b -> ParseResult l s e a
$c<$ :: forall l s e a b. a -> ParseResult l s e b -> ParseResult l s e a
fmap :: forall a b. (a -> b) -> ParseResult l s e a -> ParseResult l s e b
$cfmap :: forall l s e a b.
(a -> b) -> ParseResult l s e a -> ParseResult l s e b
Functor, forall a. ParseResult l s e a -> Bool
forall m a. Monoid m => (a -> m) -> ParseResult l s e a -> m
forall a b. (a -> b -> b) -> b -> ParseResult l s e a -> b
forall l s e a. Eq a => a -> ParseResult l s e a -> Bool
forall l s e a. Num a => ParseResult l s e a -> a
forall l s e a. Ord a => ParseResult l s e a -> a
forall l s e m. Monoid m => ParseResult l s e m -> m
forall l s e a. ParseResult l s e a -> Bool
forall l s e a. ParseResult l s e a -> Int
forall l s e a. ParseResult l s e a -> [a]
forall l s e a. (a -> a -> a) -> ParseResult l s e a -> a
forall l s e m a. Monoid m => (a -> m) -> ParseResult l s e a -> m
forall l s e b a. (b -> a -> b) -> b -> ParseResult l s e a -> b
forall l s e a b. (a -> b -> b) -> b -> ParseResult l s e a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => ParseResult l s e a -> a
$cproduct :: forall l s e a. Num a => ParseResult l s e a -> a
sum :: forall a. Num a => ParseResult l s e a -> a
$csum :: forall l s e a. Num a => ParseResult l s e a -> a
minimum :: forall a. Ord a => ParseResult l s e a -> a
$cminimum :: forall l s e a. Ord a => ParseResult l s e a -> a
maximum :: forall a. Ord a => ParseResult l s e a -> a
$cmaximum :: forall l s e a. Ord a => ParseResult l s e a -> a
elem :: forall a. Eq a => a -> ParseResult l s e a -> Bool
$celem :: forall l s e a. Eq a => a -> ParseResult l s e a -> Bool
length :: forall a. ParseResult l s e a -> Int
$clength :: forall l s e a. ParseResult l s e a -> Int
null :: forall a. ParseResult l s e a -> Bool
$cnull :: forall l s e a. ParseResult l s e a -> Bool
toList :: forall a. ParseResult l s e a -> [a]
$ctoList :: forall l s e a. ParseResult l s e a -> [a]
foldl1 :: forall a. (a -> a -> a) -> ParseResult l s e a -> a
$cfoldl1 :: forall l s e a. (a -> a -> a) -> ParseResult l s e a -> a
foldr1 :: forall a. (a -> a -> a) -> ParseResult l s e a -> a
$cfoldr1 :: forall l s e a. (a -> a -> a) -> ParseResult l s e a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> ParseResult l s e a -> b
$cfoldl' :: forall l s e b a. (b -> a -> b) -> b -> ParseResult l s e a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ParseResult l s e a -> b
$cfoldl :: forall l s e b a. (b -> a -> b) -> b -> ParseResult l s e a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ParseResult l s e a -> b
$cfoldr' :: forall l s e a b. (a -> b -> b) -> b -> ParseResult l s e a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ParseResult l s e a -> b
$cfoldr :: forall l s e a b. (a -> b -> b) -> b -> ParseResult l s e a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> ParseResult l s e a -> m
$cfoldMap' :: forall l s e m a. Monoid m => (a -> m) -> ParseResult l s e a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ParseResult l s e a -> m
$cfoldMap :: forall l s e m a. Monoid m => (a -> m) -> ParseResult l s e a -> m
fold :: forall m. Monoid m => ParseResult l s e m -> m
$cfold :: forall l s e m. Monoid m => ParseResult l s e m -> m
Foldable, forall l s e. Functor (ParseResult l s e)
forall l s e. Foldable (ParseResult l s e)
forall l s e (m :: * -> *) a.
Monad m =>
ParseResult l s e (m a) -> m (ParseResult l s e a)
forall l s e (f :: * -> *) a.
Applicative f =>
ParseResult l s e (f a) -> f (ParseResult l s e a)
forall l s e (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParseResult l s e a -> m (ParseResult l s e b)
forall l s e (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseResult l s e a -> f (ParseResult l s e b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseResult l s e a -> f (ParseResult l s e b)
sequence :: forall (m :: * -> *) a.
Monad m =>
ParseResult l s e (m a) -> m (ParseResult l s e a)
$csequence :: forall l s e (m :: * -> *) a.
Monad m =>
ParseResult l s e (m a) -> m (ParseResult l s e a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParseResult l s e a -> m (ParseResult l s e b)
$cmapM :: forall l s e (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParseResult l s e a -> m (ParseResult l s e b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ParseResult l s e (f a) -> f (ParseResult l s e a)
$csequenceA :: forall l s e (f :: * -> *) a.
Applicative f =>
ParseResult l s e (f a) -> f (ParseResult l s e a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseResult l s e a -> f (ParseResult l s e b)
$ctraverse :: forall l s e (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseResult l s e a -> f (ParseResult l s e b)
Traversable)
deriving instance (Eq l, Eq s, Eq (Token s), Eq (Chunk s), Eq e, Eq a) => Eq (ParseResult l s e a)
deriving instance (Show l, Show s, Show (Token s), Show (Chunk s), Show e, Show a) => Show (ParseResult l s e a)