{-# 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)

-- | 'RawStreamError' specialized to 'Stream' types - newtyped to allow GHC
-- to derive eq/show in the absense of type families.
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)

-- | Returns a sequence of labels from most general to most specific.
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)

-- | 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.
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))

-- | Returns the sequence of ALL labels from coarsest to finest.
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

-- | Updates a 'ParseError' with a resumption point.
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) }

-- | Clears marks from a 'ParseError'.
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 }

-- | Returns the narrowest span
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))

-- | Returns labels enclosing the narrowest span, from coarsest to finest
-- Does NOT include the label for the narrowest span (if any).
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)

-- | Lists all errors in the bundle.
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

-- | 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'.
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)