{-# LANGUAGE UndecidableInstances #-}

module SimpleParser.Result
  ( RawError (..)
  , StreamError (..)
  , coerceStreamError
  , CompoundError (..)
  , Mark (..)
  , ParseError (..)
  , parseErrorResume
  , parseErrorLabels
  , markParseError
  , unmarkParseError
  , parseErrorEnclosingLabels
  , parseErrorNarrowestSpan
  , ParseSuccess (..)
  , ParseResult (..)
  , matchSoleParseError
  ) where

import Data.Sequence (Seq (..))
import qualified Data.Sequence as Seq
import Data.Sequence.NonEmpty (NESeq (..))
import Data.Text (Text)
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
(RawError chunk token -> RawError chunk token -> Bool)
-> (RawError chunk token -> RawError chunk token -> Bool)
-> Eq (RawError chunk token)
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
[RawError chunk token] -> ShowS
RawError chunk token -> String
(Int -> RawError chunk token -> ShowS)
-> (RawError chunk token -> String)
-> ([RawError chunk token] -> ShowS)
-> Show (RawError chunk token)
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
  { 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 :: StreamError s -> StreamError t
coerceStreamError = RawError (Chunk t) (Token t) -> StreamError t
forall s. RawError (Chunk s) (Token s) -> StreamError s
StreamError (RawError (Chunk t) (Token t) -> StreamError t)
-> (StreamError s -> RawError (Chunk t) (Token t))
-> StreamError s
-> StreamError t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StreamError s -> RawError (Chunk t) (Token t)
forall s. StreamError s -> RawError (Chunk s) (Token s)
unStreamError

data CompoundError s e =
    CompoundErrorStream !(StreamError s)
  | CompoundErrorFail !Text
  | CompoundErrorCustom !e
  deriving (a -> CompoundError s b -> CompoundError s a
(a -> b) -> CompoundError s a -> CompoundError s b
(forall a b. (a -> b) -> CompoundError s a -> CompoundError s b)
-> (forall a b. a -> CompoundError s b -> CompoundError s a)
-> Functor (CompoundError s)
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
<$ :: a -> CompoundError s b -> CompoundError s a
$c<$ :: forall s a b. a -> CompoundError s b -> CompoundError s a
fmap :: (a -> b) -> CompoundError s a -> CompoundError s b
$cfmap :: forall s a b. (a -> b) -> CompoundError s a -> CompoundError s b
Functor, CompoundError s a -> Bool
(a -> m) -> CompoundError s a -> m
(a -> b -> b) -> b -> CompoundError s a -> b
(forall m. Monoid m => CompoundError s m -> m)
-> (forall m a. Monoid m => (a -> m) -> CompoundError s a -> m)
-> (forall m a. Monoid m => (a -> m) -> CompoundError s a -> m)
-> (forall a b. (a -> b -> b) -> b -> CompoundError s a -> b)
-> (forall a b. (a -> b -> b) -> b -> CompoundError s a -> b)
-> (forall b a. (b -> a -> b) -> b -> CompoundError s a -> b)
-> (forall b a. (b -> a -> b) -> b -> CompoundError s a -> b)
-> (forall a. (a -> a -> a) -> CompoundError s a -> a)
-> (forall a. (a -> a -> a) -> CompoundError s a -> a)
-> (forall a. CompoundError s a -> [a])
-> (forall a. CompoundError s a -> Bool)
-> (forall a. CompoundError s a -> Int)
-> (forall a. Eq a => a -> CompoundError s a -> Bool)
-> (forall a. Ord a => CompoundError s a -> a)
-> (forall a. Ord a => CompoundError s a -> a)
-> (forall a. Num a => CompoundError s a -> a)
-> (forall a. Num a => CompoundError s a -> a)
-> Foldable (CompoundError s)
forall a. Eq a => a -> CompoundError s a -> Bool
forall a. Num a => CompoundError s a -> a
forall a. Ord a => CompoundError s a -> a
forall m. Monoid m => CompoundError s m -> m
forall a. CompoundError s a -> Bool
forall a. CompoundError s a -> Int
forall a. CompoundError s a -> [a]
forall a. (a -> a -> a) -> CompoundError s a -> a
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 b a. (b -> a -> b) -> b -> CompoundError s a -> b
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 :: CompoundError s a -> a
$cproduct :: forall s a. Num a => CompoundError s a -> a
sum :: CompoundError s a -> a
$csum :: forall s a. Num a => CompoundError s a -> a
minimum :: CompoundError s a -> a
$cminimum :: forall s a. Ord a => CompoundError s a -> a
maximum :: CompoundError s a -> a
$cmaximum :: forall s a. Ord a => CompoundError s a -> a
elem :: a -> CompoundError s a -> Bool
$celem :: forall s a. Eq a => a -> CompoundError s a -> Bool
length :: CompoundError s a -> Int
$clength :: forall s a. CompoundError s a -> Int
null :: CompoundError s a -> Bool
$cnull :: forall s a. CompoundError s a -> Bool
toList :: CompoundError s a -> [a]
$ctoList :: forall s a. CompoundError s a -> [a]
foldl1 :: (a -> a -> a) -> CompoundError s a -> a
$cfoldl1 :: forall s a. (a -> a -> a) -> CompoundError s a -> a
foldr1 :: (a -> a -> a) -> CompoundError s a -> a
$cfoldr1 :: forall s a. (a -> a -> a) -> CompoundError s a -> a
foldl' :: (b -> a -> b) -> b -> CompoundError s a -> b
$cfoldl' :: forall s b a. (b -> a -> b) -> b -> CompoundError s a -> b
foldl :: (b -> a -> b) -> b -> CompoundError s a -> b
$cfoldl :: forall s b a. (b -> a -> b) -> b -> CompoundError s a -> b
foldr' :: (a -> b -> b) -> b -> CompoundError s a -> b
$cfoldr' :: forall s a b. (a -> b -> b) -> b -> CompoundError s a -> b
foldr :: (a -> b -> b) -> b -> CompoundError s a -> b
$cfoldr :: forall s a b. (a -> b -> b) -> b -> CompoundError s a -> b
foldMap' :: (a -> m) -> CompoundError s a -> m
$cfoldMap' :: forall s m a. Monoid m => (a -> m) -> CompoundError s a -> m
foldMap :: (a -> m) -> CompoundError s a -> m
$cfoldMap :: forall s m a. Monoid m => (a -> m) -> CompoundError s a -> m
fold :: CompoundError s m -> m
$cfold :: forall s m. Monoid m => CompoundError s m -> m
Foldable, Functor (CompoundError s)
Foldable (CompoundError s)
Functor (CompoundError s)
-> Foldable (CompoundError s)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CompoundError s a -> f (CompoundError s b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    CompoundError s (f a) -> f (CompoundError s a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CompoundError s a -> m (CompoundError s b))
-> (forall (m :: * -> *) a.
    Monad m =>
    CompoundError s (m a) -> m (CompoundError s a))
-> Traversable (CompoundError s)
(a -> f b) -> CompoundError s a -> f (CompoundError s b)
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 (m :: * -> *) a.
Monad m =>
CompoundError s (m a) -> m (CompoundError s a)
forall (f :: * -> *) a.
Applicative f =>
CompoundError s (f a) -> f (CompoundError s a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CompoundError s a -> m (CompoundError s b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CompoundError s a -> f (CompoundError s b)
sequence :: CompoundError s (m a) -> m (CompoundError s a)
$csequence :: forall s (m :: * -> *) a.
Monad m =>
CompoundError s (m a) -> m (CompoundError s a)
mapM :: (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 :: CompoundError s (f a) -> f (CompoundError s a)
$csequenceA :: forall s (f :: * -> *) a.
Applicative f =>
CompoundError s (f a) -> f (CompoundError s a)
traverse :: (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)
$cp2Traversable :: forall s. Foldable (CompoundError s)
$cp1Traversable :: forall s. Functor (CompoundError s)
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
  { Mark l s -> Maybe l
markLabel :: !(Maybe l)
  , Mark l s -> s
markState :: !s
  } deriving (Mark l s -> Mark l s -> Bool
(Mark l s -> Mark l s -> Bool)
-> (Mark l s -> Mark l s -> Bool) -> Eq (Mark l s)
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
[Mark l s] -> ShowS
Mark l s -> String
(Int -> Mark l s -> ShowS)
-> (Mark l s -> String) -> ([Mark l s] -> ShowS) -> Show (Mark l s)
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 :: MarkStack l s -> Seq l
markStackLabels = (Mark l s -> Maybe l) -> MarkStack l s -> Seq l
forall a b. (a -> Maybe b) -> Stack a -> Seq b
bottomUpStack Mark l s -> Maybe l
forall l s. Mark l s -> Maybe l
markLabel

data ParseError l s e = ParseError
  { ParseError l s e -> MarkStack l s
peMarkStack :: !(MarkStack l s)
  , ParseError l s e -> s
peEndState :: !s
  , ParseError l s e -> CompoundError s e
peError :: !(CompoundError 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 :: ParseError l s e -> s
parseErrorResume ParseError l s e
pe = s -> (Mark l s -> s) -> Maybe (Mark l s) -> s
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ParseError l s e -> s
forall l s e. ParseError l s e -> s
peEndState ParseError l s e
pe) Mark l s -> s
forall l s. Mark l s -> s
markState (Stack (Mark l s) -> Maybe (Mark l s)
forall a. Stack a -> Maybe a
topStack (ParseError l s e -> Stack (Mark l s)
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 :: ParseError l s e -> Seq l
parseErrorLabels = MarkStack l s -> Seq l
forall l s. MarkStack l s -> Seq l
markStackLabels (MarkStack l s -> Seq l)
-> (ParseError l s e -> MarkStack l s) -> ParseError l s e -> Seq l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError l s e -> MarkStack l s
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 :: 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 = Mark l s -> MarkStack l s -> MarkStack l s
forall a. a -> Stack a -> Stack a
pushStack Mark l s
s (ParseError l s e -> MarkStack l 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 :: ParseError l s e -> ParseError l s e
unmarkParseError ParseError l s e
pe = ParseError l s e
pe { peMarkStack :: MarkStack l s
peMarkStack = MarkStack l s
forall a. Stack a
emptyStack }

-- | Returns the narrowest span
parseErrorNarrowestSpan :: PosStream s => ParseError l s e -> (Maybe l, Span (Pos s))
parseErrorNarrowestSpan :: ParseError l s e -> (Maybe l, Span (Pos s))
parseErrorNarrowestSpan ParseError l s e
pe = (Maybe l
ml, Pos s -> Pos s -> Span (Pos s)
forall p. p -> p -> Span p
Span Pos s
startPos Pos s
endPos) where
  endPos :: Pos s
endPos = s -> Pos s
forall s. PosStream s => s -> Pos s
streamViewPos (ParseError l s e -> s
forall l s e. ParseError l s e -> s
peEndState ParseError l s e
pe)
  (Maybe l
ml, Pos s
startPos) = (Maybe l, Pos s)
-> (Mark l s -> (Maybe l, Pos s))
-> Maybe (Mark l s)
-> (Maybe l, Pos s)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe l
forall a. Maybe a
Nothing, Pos s
endPos) (\(Mark Maybe l
mx s
s) -> (Maybe l
mx, s -> Pos s
forall s. PosStream s => s -> Pos s
streamViewPos s
s)) (Stack (Mark l s) -> Maybe (Mark l s)
forall a. Stack a -> Maybe a
bottomStack (ParseError l s e -> Stack (Mark l s)
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 :: ParseError l s e -> Seq l
parseErrorEnclosingLabels ParseError l s e
pe =
  case Stack (Mark l s) -> Seq (Mark l s)
forall a. Stack a -> Seq a
unStack (ParseError l s e -> Stack (Mark l s)
forall l s e. ParseError l s e -> MarkStack l s
peMarkStack ParseError l s e
pe) of
    Seq (Mark l s)
Empty -> Seq l
forall a. Seq a
Empty
    Mark l s
_ :<| Seq (Mark l s)
s -> Seq (Mark l s)
s Seq (Mark l s) -> (Mark l s -> Seq l) -> Seq l
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(Mark Maybe l
ml s
_) -> Seq l -> (l -> Seq l) -> Maybe l -> Seq l
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Seq l
forall a. Seq a
Seq.empty l -> Seq l
forall a. a -> Seq a
Seq.singleton Maybe l
ml

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)

data ParseSuccess s a = ParseSuccess
  { ParseSuccess s a -> s
psEndState :: !s
  , ParseSuccess s a -> a
psValue :: !a
  } deriving (ParseSuccess s a -> ParseSuccess s a -> Bool
(ParseSuccess s a -> ParseSuccess s a -> Bool)
-> (ParseSuccess s a -> ParseSuccess s a -> Bool)
-> Eq (ParseSuccess s a)
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
[ParseSuccess s a] -> ShowS
ParseSuccess s a -> String
(Int -> ParseSuccess s a -> ShowS)
-> (ParseSuccess s a -> String)
-> ([ParseSuccess s a] -> ShowS)
-> Show (ParseSuccess s a)
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, a -> ParseSuccess s b -> ParseSuccess s a
(a -> b) -> ParseSuccess s a -> ParseSuccess s b
(forall a b. (a -> b) -> ParseSuccess s a -> ParseSuccess s b)
-> (forall a b. a -> ParseSuccess s b -> ParseSuccess s a)
-> Functor (ParseSuccess s)
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
<$ :: a -> ParseSuccess s b -> ParseSuccess s a
$c<$ :: forall s a b. a -> ParseSuccess s b -> ParseSuccess s a
fmap :: (a -> b) -> ParseSuccess s a -> ParseSuccess s b
$cfmap :: forall s a b. (a -> b) -> ParseSuccess s a -> ParseSuccess s b
Functor, ParseSuccess s a -> Bool
(a -> m) -> ParseSuccess s a -> m
(a -> b -> b) -> b -> ParseSuccess s a -> b
(forall m. Monoid m => ParseSuccess s m -> m)
-> (forall m a. Monoid m => (a -> m) -> ParseSuccess s a -> m)
-> (forall m a. Monoid m => (a -> m) -> ParseSuccess s a -> m)
-> (forall a b. (a -> b -> b) -> b -> ParseSuccess s a -> b)
-> (forall a b. (a -> b -> b) -> b -> ParseSuccess s a -> b)
-> (forall b a. (b -> a -> b) -> b -> ParseSuccess s a -> b)
-> (forall b a. (b -> a -> b) -> b -> ParseSuccess s a -> b)
-> (forall a. (a -> a -> a) -> ParseSuccess s a -> a)
-> (forall a. (a -> a -> a) -> ParseSuccess s a -> a)
-> (forall a. ParseSuccess s a -> [a])
-> (forall a. ParseSuccess s a -> Bool)
-> (forall a. ParseSuccess s a -> Int)
-> (forall a. Eq a => a -> ParseSuccess s a -> Bool)
-> (forall a. Ord a => ParseSuccess s a -> a)
-> (forall a. Ord a => ParseSuccess s a -> a)
-> (forall a. Num a => ParseSuccess s a -> a)
-> (forall a. Num a => ParseSuccess s a -> a)
-> Foldable (ParseSuccess s)
forall a. Eq a => a -> ParseSuccess s a -> Bool
forall a. Num a => ParseSuccess s a -> a
forall a. Ord a => ParseSuccess s a -> a
forall m. Monoid m => ParseSuccess s m -> m
forall a. ParseSuccess s a -> Bool
forall a. ParseSuccess s a -> Int
forall a. ParseSuccess s a -> [a]
forall a. (a -> a -> a) -> ParseSuccess s a -> a
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 b a. (b -> a -> b) -> b -> ParseSuccess s a -> b
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 :: ParseSuccess s a -> a
$cproduct :: forall s a. Num a => ParseSuccess s a -> a
sum :: ParseSuccess s a -> a
$csum :: forall s a. Num a => ParseSuccess s a -> a
minimum :: ParseSuccess s a -> a
$cminimum :: forall s a. Ord a => ParseSuccess s a -> a
maximum :: ParseSuccess s a -> a
$cmaximum :: forall s a. Ord a => ParseSuccess s a -> a
elem :: a -> ParseSuccess s a -> Bool
$celem :: forall s a. Eq a => a -> ParseSuccess s a -> Bool
length :: ParseSuccess s a -> Int
$clength :: forall s a. ParseSuccess s a -> Int
null :: ParseSuccess s a -> Bool
$cnull :: forall s a. ParseSuccess s a -> Bool
toList :: ParseSuccess s a -> [a]
$ctoList :: forall s a. ParseSuccess s a -> [a]
foldl1 :: (a -> a -> a) -> ParseSuccess s a -> a
$cfoldl1 :: forall s a. (a -> a -> a) -> ParseSuccess s a -> a
foldr1 :: (a -> a -> a) -> ParseSuccess s a -> a
$cfoldr1 :: forall s a. (a -> a -> a) -> ParseSuccess s a -> a
foldl' :: (b -> a -> b) -> b -> ParseSuccess s a -> b
$cfoldl' :: forall s b a. (b -> a -> b) -> b -> ParseSuccess s a -> b
foldl :: (b -> a -> b) -> b -> ParseSuccess s a -> b
$cfoldl :: forall s b a. (b -> a -> b) -> b -> ParseSuccess s a -> b
foldr' :: (a -> b -> b) -> b -> ParseSuccess s a -> b
$cfoldr' :: forall s a b. (a -> b -> b) -> b -> ParseSuccess s a -> b
foldr :: (a -> b -> b) -> b -> ParseSuccess s a -> b
$cfoldr :: forall s a b. (a -> b -> b) -> b -> ParseSuccess s a -> b
foldMap' :: (a -> m) -> ParseSuccess s a -> m
$cfoldMap' :: forall s m a. Monoid m => (a -> m) -> ParseSuccess s a -> m
foldMap :: (a -> m) -> ParseSuccess s a -> m
$cfoldMap :: forall s m a. Monoid m => (a -> m) -> ParseSuccess s a -> m
fold :: ParseSuccess s m -> m
$cfold :: forall s m. Monoid m => ParseSuccess s m -> m
Foldable, Functor (ParseSuccess s)
Foldable (ParseSuccess s)
Functor (ParseSuccess s)
-> Foldable (ParseSuccess s)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ParseSuccess s a -> f (ParseSuccess s b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ParseSuccess s (f a) -> f (ParseSuccess s a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ParseSuccess s a -> m (ParseSuccess s b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ParseSuccess s (m a) -> m (ParseSuccess s a))
-> Traversable (ParseSuccess s)
(a -> f b) -> ParseSuccess s a -> f (ParseSuccess s b)
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 (m :: * -> *) a.
Monad m =>
ParseSuccess s (m a) -> m (ParseSuccess s a)
forall (f :: * -> *) a.
Applicative f =>
ParseSuccess s (f a) -> f (ParseSuccess s a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParseSuccess s a -> m (ParseSuccess s b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseSuccess s a -> f (ParseSuccess s b)
sequence :: ParseSuccess s (m a) -> m (ParseSuccess s a)
$csequence :: forall s (m :: * -> *) a.
Monad m =>
ParseSuccess s (m a) -> m (ParseSuccess s a)
mapM :: (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 :: ParseSuccess s (f a) -> f (ParseSuccess s a)
$csequenceA :: forall s (f :: * -> *) a.
Applicative f =>
ParseSuccess s (f a) -> f (ParseSuccess s a)
traverse :: (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)
$cp2Traversable :: forall s. Foldable (ParseSuccess s)
$cp1Traversable :: forall s. Functor (ParseSuccess s)
Traversable)

data ParseResult l s e a =
    ParseResultError !(NESeq (ParseError l s e))
  | ParseResultSuccess !(ParseSuccess s a)
  deriving (a -> ParseResult l s e b -> ParseResult l s e a
(a -> b) -> ParseResult l s e a -> ParseResult l s e b
(forall a b.
 (a -> b) -> ParseResult l s e a -> ParseResult l s e b)
-> (forall a b. a -> ParseResult l s e b -> ParseResult l s e a)
-> Functor (ParseResult l s e)
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
<$ :: 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 :: (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, ParseResult l s e a -> Bool
(a -> m) -> ParseResult l s e a -> m
(a -> b -> b) -> b -> ParseResult l s e a -> b
(forall m. Monoid m => ParseResult l s e m -> m)
-> (forall m a. Monoid m => (a -> m) -> ParseResult l s e a -> m)
-> (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 a b. (a -> b -> b) -> b -> ParseResult l s e a -> b)
-> (forall b a. (b -> a -> b) -> b -> ParseResult l s e a -> b)
-> (forall b a. (b -> a -> b) -> b -> ParseResult l s e a -> b)
-> (forall a. (a -> a -> a) -> ParseResult l s e a -> a)
-> (forall a. (a -> a -> a) -> ParseResult l s e a -> a)
-> (forall a. ParseResult l s e a -> [a])
-> (forall a. ParseResult l s e a -> Bool)
-> (forall a. ParseResult l s e a -> Int)
-> (forall a. Eq a => a -> ParseResult l s e a -> Bool)
-> (forall a. Ord a => ParseResult l s e a -> a)
-> (forall a. Ord a => ParseResult l s e a -> a)
-> (forall a. Num a => ParseResult l s e a -> a)
-> (forall a. Num a => ParseResult l s e a -> a)
-> Foldable (ParseResult l s e)
forall a. Eq a => a -> ParseResult l s e a -> Bool
forall a. Num a => ParseResult l s e a -> a
forall a. Ord a => ParseResult l s e a -> a
forall m. Monoid m => ParseResult l s e m -> m
forall a. ParseResult l s e a -> Bool
forall a. ParseResult l s e a -> Int
forall a. ParseResult l s e a -> [a]
forall a. (a -> a -> a) -> ParseResult l s e a -> a
forall m a. Monoid m => (a -> m) -> ParseResult l s e a -> m
forall b a. (b -> a -> b) -> b -> ParseResult l s e a -> b
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 :: ParseResult l s e a -> a
$cproduct :: forall l s e a. Num a => ParseResult l s e a -> a
sum :: ParseResult l s e a -> a
$csum :: forall l s e a. Num a => ParseResult l s e a -> a
minimum :: ParseResult l s e a -> a
$cminimum :: forall l s e a. Ord a => ParseResult l s e a -> a
maximum :: ParseResult l s e a -> a
$cmaximum :: forall l s e a. Ord a => ParseResult l s e a -> a
elem :: a -> ParseResult l s e a -> Bool
$celem :: forall l s e a. Eq a => a -> ParseResult l s e a -> Bool
length :: ParseResult l s e a -> Int
$clength :: forall l s e a. ParseResult l s e a -> Int
null :: ParseResult l s e a -> Bool
$cnull :: forall l s e a. ParseResult l s e a -> Bool
toList :: ParseResult l s e a -> [a]
$ctoList :: forall l s e a. ParseResult l s e a -> [a]
foldl1 :: (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 :: (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' :: (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 :: (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' :: (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 :: (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' :: (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 :: (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 :: ParseResult l s e m -> m
$cfold :: forall l s e m. Monoid m => ParseResult l s e m -> m
Foldable, Functor (ParseResult l s e)
Foldable (ParseResult l s e)
Functor (ParseResult l s e)
-> Foldable (ParseResult l s e)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ParseResult l s e a -> f (ParseResult l s e b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ParseResult l s e (f a) -> f (ParseResult l s e a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ParseResult l s e a -> m (ParseResult l s e b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ParseResult l s e (m a) -> m (ParseResult l s e a))
-> Traversable (ParseResult l s e)
(a -> f b) -> ParseResult l s e a -> f (ParseResult l s e b)
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 (m :: * -> *) a.
Monad m =>
ParseResult l s e (m a) -> m (ParseResult l s e a)
forall (f :: * -> *) a.
Applicative f =>
ParseResult l s e (f a) -> f (ParseResult l s e a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParseResult l s e a -> m (ParseResult l s e b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParseResult l s e a -> f (ParseResult l s e b)
sequence :: 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 :: (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 :: 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 :: (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)
$cp2Traversable :: forall l s e. Foldable (ParseResult l s e)
$cp1Traversable :: forall l s e. Functor (ParseResult l s e)
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)

-- | If there is one parse error, 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 :: NESeq (ParseError l s e) -> Maybe (ParseError l s e)
matchSoleParseError :: NESeq (ParseError l s e) -> Maybe (ParseError l s e)
matchSoleParseError 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 -> ParseError l s e -> Maybe (ParseError l s e)
forall a. a -> Maybe a
Just ParseError l s e
e
    NESeq (ParseError l s e)
_ -> Maybe (ParseError l s e)
forall a. Maybe a
Nothing