    {-# LANGUAGE BangPatterns #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveFunctor #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE LambdaCase #-}
    {-# LANGUAGE RecordWildCards #-}
    {-# LANGUAGE Safe #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE StandaloneDeriving #-}
    {-# LANGUAGE UndecidableInstances #-}

    -- |
    -- Module      :  Text.Megaparsec.Error
    -- Copyright   :  © 2015–present Megaparsec contributors
    -- License     :  FreeBSD
    --
    -- Maintainer  :  Mark Karpov <markkarpov92@gmail.com>
    -- Stability   :  experimental
    -- Portability :  portable
    --
    -- Parse errors. The current version of Megaparsec supports typed errors
    -- instead of 'String'-based ones. This gives a lot of flexibility in
    -- describing what exactly went wrong as well as a way to return arbitrary
    -- data in case of failure.
    --
    -- You probably do not want to import this module directly because
    -- "Text.Megaparsec" re-exports it anyway.
    module Text.Megaparsec.Error
      ( -- * Parse error type
        ErrorItem (..),
        ErrorFancy (..),
        ParseError (..),
        mapParseError,
        errorOffset,
        setErrorOffset,
        ParseErrorBundle (..),
        attachSourcePos,

        -- * Pretty-printing
        ShowErrorComponent (..),
        errorBundlePretty,
        parseErrorPretty,
        parseErrorTextPretty,
        showErrorItem,
      )
    where

    import Control.DeepSeq
    import Control.Exception
    import Control.Monad.State.Strict
    import Data.Data (Data)
    import Data.List (intercalate)
    import Data.List.NonEmpty (NonEmpty (..))
    import qualified Data.List.NonEmpty as NE
    import Data.Maybe (isNothing)
    import Data.Proxy
    import Data.Set (Set)
    import qualified Data.Set as E
    import Data.Typeable (Typeable)
    import Data.Void
    import GHC.Generics
    import Text.Megaparsec.Pos
    import Text.Megaparsec.State
    import Text.Megaparsec.Stream

    ----------------------------------------------------------------------------
    -- Parse error type

    -- | A data type that is used to represent “unexpected\/expected” items in
    -- 'ParseError'. It is parametrized over the token type @t@.
    --
    -- @since 5.0.0
    data ErrorItem t
      = -- | Non-empty stream of tokens
        Tokens (NonEmpty t)
      | -- | Label (cannot be empty)
        Label (NonEmpty Char)
      | -- | End of input
        EndOfInput
      deriving (Int -> ErrorItem t -> ShowS
    [ErrorItem t] -> ShowS
    ErrorItem t -> String
    (Int -> ErrorItem t -> ShowS)
    -> (ErrorItem t -> String)
    -> ([ErrorItem t] -> ShowS)
    -> Show (ErrorItem t)
    forall t. Show t => Int -> ErrorItem t -> ShowS
    forall t. Show t => [ErrorItem t] -> ShowS
    forall t. Show t => ErrorItem t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> ErrorItem t -> ShowS
    showsPrec :: Int -> ErrorItem t -> ShowS
    $cshow :: forall t. Show t => ErrorItem t -> String
    show :: ErrorItem t -> String
    $cshowList :: forall t. Show t => [ErrorItem t] -> ShowS
    showList :: [ErrorItem t] -> ShowS
    Show, ReadPrec [ErrorItem t]
    ReadPrec (ErrorItem t)
    Int -> ReadS (ErrorItem t)
    ReadS [ErrorItem t]
    (Int -> ReadS (ErrorItem t))
    -> ReadS [ErrorItem t]
    -> ReadPrec (ErrorItem t)
    -> ReadPrec [ErrorItem t]
    -> Read (ErrorItem t)
    forall t. Read t => ReadPrec [ErrorItem t]
    forall t. Read t => ReadPrec (ErrorItem t)
    forall t. Read t => Int -> ReadS (ErrorItem t)
    forall t. Read t => ReadS [ErrorItem t]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall t. Read t => Int -> ReadS (ErrorItem t)
    readsPrec :: Int -> ReadS (ErrorItem t)
    $creadList :: forall t. Read t => ReadS [ErrorItem t]
    readList :: ReadS [ErrorItem t]
    $creadPrec :: forall t. Read t => ReadPrec (ErrorItem t)
    readPrec :: ReadPrec (ErrorItem t)
    $creadListPrec :: forall t. Read t => ReadPrec [ErrorItem t]
    readListPrec :: ReadPrec [ErrorItem t]
    Read, ErrorItem t -> ErrorItem t -> Bool
    (ErrorItem t -> ErrorItem t -> Bool)
    -> (ErrorItem t -> ErrorItem t -> Bool) -> Eq (ErrorItem t)
    forall t. Eq t => ErrorItem t -> ErrorItem t -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall t. Eq t => ErrorItem t -> ErrorItem t -> Bool
    == :: ErrorItem t -> ErrorItem t -> Bool
    $c/= :: forall t. Eq t => ErrorItem t -> ErrorItem t -> Bool
    /= :: ErrorItem t -> ErrorItem t -> Bool
    Eq, Eq (ErrorItem t)
    Eq (ErrorItem t) =>
    (ErrorItem t -> ErrorItem t -> Ordering)
    -> (ErrorItem t -> ErrorItem t -> Bool)
    -> (ErrorItem t -> ErrorItem t -> Bool)
    -> (ErrorItem t -> ErrorItem t -> Bool)
    -> (ErrorItem t -> ErrorItem t -> Bool)
    -> (ErrorItem t -> ErrorItem t -> ErrorItem t)
    -> (ErrorItem t -> ErrorItem t -> ErrorItem t)
    -> Ord (ErrorItem t)
    ErrorItem t -> ErrorItem t -> Bool
    ErrorItem t -> ErrorItem t -> Ordering
    ErrorItem t -> ErrorItem t -> ErrorItem t
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall t. Ord t => Eq (ErrorItem t)
    forall t. Ord t => ErrorItem t -> ErrorItem t -> Bool
    forall t. Ord t => ErrorItem t -> ErrorItem t -> Ordering
    forall t. Ord t => ErrorItem t -> ErrorItem t -> ErrorItem t
    $ccompare :: forall t. Ord t => ErrorItem t -> ErrorItem t -> Ordering
    compare :: ErrorItem t -> ErrorItem t -> Ordering
    $c< :: forall t. Ord t => ErrorItem t -> ErrorItem t -> Bool
    < :: ErrorItem t -> ErrorItem t -> Bool
    $c<= :: forall t. Ord t => ErrorItem t -> ErrorItem t -> Bool
    <= :: ErrorItem t -> ErrorItem t -> Bool
    $c> :: forall t. Ord t => ErrorItem t -> ErrorItem t -> Bool
    > :: ErrorItem t -> ErrorItem t -> Bool
    $c>= :: forall t. Ord t => ErrorItem t -> ErrorItem t -> Bool
    >= :: ErrorItem t -> ErrorItem t -> Bool
    $cmax :: forall t. Ord t => ErrorItem t -> ErrorItem t -> ErrorItem t
    max :: ErrorItem t -> ErrorItem t -> ErrorItem t
    $cmin :: forall t. Ord t => ErrorItem t -> ErrorItem t -> ErrorItem t
    min :: ErrorItem t -> ErrorItem t -> ErrorItem t
    Ord, Typeable (ErrorItem t)
    Typeable (ErrorItem t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ErrorItem t -> c (ErrorItem t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ErrorItem t))
    -> (ErrorItem t -> Constr)
    -> (ErrorItem t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ErrorItem t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ErrorItem t)))
    -> ((forall b. Data b => b -> b) -> ErrorItem t -> ErrorItem t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ErrorItem t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ErrorItem t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t))
    -> Data (ErrorItem t)
    ErrorItem t -> Constr
    ErrorItem t -> DataType
    (forall b. Data b => b -> b) -> ErrorItem t -> ErrorItem t
    forall t. Data t => Typeable (ErrorItem t)
    forall t. Data t => ErrorItem t -> Constr
    forall t. Data t => ErrorItem t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> ErrorItem t -> ErrorItem t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> ErrorItem t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> ErrorItem t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ErrorItem t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ErrorItem t -> c (ErrorItem t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ErrorItem t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ErrorItem t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ErrorItem t -> u
    forall u. (forall d. Data d => d -> u) -> ErrorItem t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ErrorItem t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ErrorItem t -> c (ErrorItem t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ErrorItem t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ErrorItem t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ErrorItem t -> c (ErrorItem t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ErrorItem t -> c (ErrorItem t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ErrorItem t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ErrorItem t)
    $ctoConstr :: forall t. Data t => ErrorItem t -> Constr
    toConstr :: ErrorItem t -> Constr
    $cdataTypeOf :: forall t. Data t => ErrorItem t -> DataType
    dataTypeOf :: ErrorItem t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ErrorItem t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ErrorItem t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ErrorItem t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ErrorItem t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> ErrorItem t -> ErrorItem t
    gmapT :: (forall b. Data b => b -> b) -> ErrorItem t -> ErrorItem t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorItem t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> ErrorItem t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ErrorItem t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> ErrorItem t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ErrorItem t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ErrorItem t -> m (ErrorItem t)
    Data, Typeable, (forall x. ErrorItem t -> Rep (ErrorItem t) x)
    -> (forall x. Rep (ErrorItem t) x -> ErrorItem t)
    -> Generic (ErrorItem t)
    forall x. Rep (ErrorItem t) x -> ErrorItem t
    forall x. ErrorItem t -> Rep (ErrorItem t) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall t x. Rep (ErrorItem t) x -> ErrorItem t
    forall t x. ErrorItem t -> Rep (ErrorItem t) x
    $cfrom :: forall t x. ErrorItem t -> Rep (ErrorItem t) x
    from :: forall x. ErrorItem t -> Rep (ErrorItem t) x
    $cto :: forall t x. Rep (ErrorItem t) x -> ErrorItem t
    to :: forall x. Rep (ErrorItem t) x -> ErrorItem t
    Generic, (forall a b. (a -> b) -> ErrorItem a -> ErrorItem b)
    -> (forall a b. a -> ErrorItem b -> ErrorItem a)
    -> Functor ErrorItem
    forall a b. a -> ErrorItem b -> ErrorItem a
    forall a b. (a -> b) -> ErrorItem a -> ErrorItem b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ErrorItem a -> ErrorItem b
    fmap :: forall a b. (a -> b) -> ErrorItem a -> ErrorItem b
    $c<$ :: forall a b. a -> ErrorItem b -> ErrorItem a
    <$ :: forall a b. a -> ErrorItem b -> ErrorItem a
    Functor)

    instance (NFData t) => NFData (ErrorItem t)

    -- | Additional error data, extendable by user. When no custom data is
    -- necessary, the type is typically indexed by 'Void' to “cancel” the
    -- 'ErrorCustom' constructor.
    --
    -- @since 6.0.0
    data ErrorFancy e
      = -- | 'fail' has been used in parser monad
        ErrorFail String
      | -- | Incorrect indentation error: desired ordering between reference
        -- level and actual level, reference indentation level, actual
        -- indentation level
        ErrorIndentation Ordering Pos Pos
      | -- | Custom error data
        ErrorCustom e
      deriving (Int -> ErrorFancy e -> ShowS
    [ErrorFancy e] -> ShowS
    ErrorFancy e -> String
    (Int -> ErrorFancy e -> ShowS)
    -> (ErrorFancy e -> String)
    -> ([ErrorFancy e] -> ShowS)
    -> Show (ErrorFancy e)
    forall e. Show e => Int -> ErrorFancy e -> ShowS
    forall e. Show e => [ErrorFancy e] -> ShowS
    forall e. Show e => ErrorFancy e -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall e. Show e => Int -> ErrorFancy e -> ShowS
    showsPrec :: Int -> ErrorFancy e -> ShowS
    $cshow :: forall e. Show e => ErrorFancy e -> String
    show :: ErrorFancy e -> String
    $cshowList :: forall e. Show e => [ErrorFancy e] -> ShowS
    showList :: [ErrorFancy e] -> ShowS
    Show, ReadPrec [ErrorFancy e]
    ReadPrec (ErrorFancy e)
    Int -> ReadS (ErrorFancy e)
    ReadS [ErrorFancy e]
    (Int -> ReadS (ErrorFancy e))
    -> ReadS [ErrorFancy e]
    -> ReadPrec (ErrorFancy e)
    -> ReadPrec [ErrorFancy e]
    -> Read (ErrorFancy e)
    forall e. Read e => ReadPrec [ErrorFancy e]
    forall e. Read e => ReadPrec (ErrorFancy e)
    forall e. Read e => Int -> ReadS (ErrorFancy e)
    forall e. Read e => ReadS [ErrorFancy e]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall e. Read e => Int -> ReadS (ErrorFancy e)
    readsPrec :: Int -> ReadS (ErrorFancy e)
    $creadList :: forall e. Read e => ReadS [ErrorFancy e]
    readList :: ReadS [ErrorFancy e]
    $creadPrec :: forall e. Read e => ReadPrec (ErrorFancy e)
    readPrec :: ReadPrec (ErrorFancy e)
    $creadListPrec :: forall e. Read e => ReadPrec [ErrorFancy e]
    readListPrec :: ReadPrec [ErrorFancy e]
    Read, ErrorFancy e -> ErrorFancy e -> Bool
    (ErrorFancy e -> ErrorFancy e -> Bool)
    -> (ErrorFancy e -> ErrorFancy e -> Bool) -> Eq (ErrorFancy e)
    forall e. Eq e => ErrorFancy e -> ErrorFancy e -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall e. Eq e => ErrorFancy e -> ErrorFancy e -> Bool
    == :: ErrorFancy e -> ErrorFancy e -> Bool
    $c/= :: forall e. Eq e => ErrorFancy e -> ErrorFancy e -> Bool
    /= :: ErrorFancy e -> ErrorFancy e -> Bool
    Eq, Eq (ErrorFancy e)
    Eq (ErrorFancy e) =>
    (ErrorFancy e -> ErrorFancy e -> Ordering)
    -> (ErrorFancy e -> ErrorFancy e -> Bool)
    -> (ErrorFancy e -> ErrorFancy e -> Bool)
    -> (ErrorFancy e -> ErrorFancy e -> Bool)
    -> (ErrorFancy e -> ErrorFancy e -> Bool)
    -> (ErrorFancy e -> ErrorFancy e -> ErrorFancy e)
    -> (ErrorFancy e -> ErrorFancy e -> ErrorFancy e)
    -> Ord (ErrorFancy e)
    ErrorFancy e -> ErrorFancy e -> Bool
    ErrorFancy e -> ErrorFancy e -> Ordering
    ErrorFancy e -> ErrorFancy e -> ErrorFancy e
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall e. Ord e => Eq (ErrorFancy e)
    forall e. Ord e => ErrorFancy e -> ErrorFancy e -> Bool
    forall e. Ord e => ErrorFancy e -> ErrorFancy e -> Ordering
    forall e. Ord e => ErrorFancy e -> ErrorFancy e -> ErrorFancy e
    $ccompare :: forall e. Ord e => ErrorFancy e -> ErrorFancy e -> Ordering
    compare :: ErrorFancy e -> ErrorFancy e -> Ordering
    $c< :: forall e. Ord e => ErrorFancy e -> ErrorFancy e -> Bool
    < :: ErrorFancy e -> ErrorFancy e -> Bool
    $c<= :: forall e. Ord e => ErrorFancy e -> ErrorFancy e -> Bool
    <= :: ErrorFancy e -> ErrorFancy e -> Bool
    $c> :: forall e. Ord e => ErrorFancy e -> ErrorFancy e -> Bool
    > :: ErrorFancy e -> ErrorFancy e -> Bool
    $c>= :: forall e. Ord e => ErrorFancy e -> ErrorFancy e -> Bool
    >= :: ErrorFancy e -> ErrorFancy e -> Bool
    $cmax :: forall e. Ord e => ErrorFancy e -> ErrorFancy e -> ErrorFancy e
    max :: ErrorFancy e -> ErrorFancy e -> ErrorFancy e
    $cmin :: forall e. Ord e => ErrorFancy e -> ErrorFancy e -> ErrorFancy e
    min :: ErrorFancy e -> ErrorFancy e -> ErrorFancy e
    Ord, Typeable (ErrorFancy e)
    Typeable (ErrorFancy e) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ErrorFancy e -> c (ErrorFancy e))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ErrorFancy e))
    -> (ErrorFancy e -> Constr)
    -> (ErrorFancy e -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ErrorFancy e)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ErrorFancy e)))
    -> ((forall b. Data b => b -> b) -> ErrorFancy e -> ErrorFancy e)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ErrorFancy e -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ErrorFancy e -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e))
    -> Data (ErrorFancy e)
    ErrorFancy e -> Constr
    ErrorFancy e -> DataType
    (forall b. Data b => b -> b) -> ErrorFancy e -> ErrorFancy e
    forall e. Data e => Typeable (ErrorFancy e)
    forall e. Data e => ErrorFancy e -> Constr
    forall e. Data e => ErrorFancy e -> DataType
    forall e.
    Data e =>
    (forall b. Data b => b -> b) -> ErrorFancy e -> ErrorFancy e
    forall e u.
    Data e =>
    Int -> (forall d. Data d => d -> u) -> ErrorFancy e -> u
    forall e u.
    Data e =>
    (forall d. Data d => d -> u) -> ErrorFancy e -> [u]
    forall e r r'.
    Data e =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r
    forall e r r'.
    Data e =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r
    forall e (m :: * -> *).
    (Data e, Monad m) =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    forall e (m :: * -> *).
    (Data e, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    forall e (c :: * -> *).
    Data e =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ErrorFancy e)
    forall e (c :: * -> *).
    Data e =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ErrorFancy e -> c (ErrorFancy e)
    forall e (t :: * -> *) (c :: * -> *).
    (Data e, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ErrorFancy e))
    forall e (t :: * -> * -> *) (c :: * -> *).
    (Data e, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ErrorFancy e))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ErrorFancy e -> u
    forall u. (forall d. Data d => d -> u) -> ErrorFancy e -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ErrorFancy e)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ErrorFancy e -> c (ErrorFancy e)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ErrorFancy e))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ErrorFancy e))
    $cgfoldl :: forall e (c :: * -> *).
    Data e =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ErrorFancy e -> c (ErrorFancy e)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ErrorFancy e -> c (ErrorFancy e)
    $cgunfold :: forall e (c :: * -> *).
    Data e =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ErrorFancy e)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ErrorFancy e)
    $ctoConstr :: forall e. Data e => ErrorFancy e -> Constr
    toConstr :: ErrorFancy e -> Constr
    $cdataTypeOf :: forall e. Data e => ErrorFancy e -> DataType
    dataTypeOf :: ErrorFancy e -> DataType
    $cdataCast1 :: forall e (t :: * -> *) (c :: * -> *).
    (Data e, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ErrorFancy e))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ErrorFancy e))
    $cdataCast2 :: forall e (t :: * -> * -> *) (c :: * -> *).
    (Data e, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ErrorFancy e))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ErrorFancy e))
    $cgmapT :: forall e.
    Data e =>
    (forall b. Data b => b -> b) -> ErrorFancy e -> ErrorFancy e
    gmapT :: (forall b. Data b => b -> b) -> ErrorFancy e -> ErrorFancy e
    $cgmapQl :: forall e r r'.
    Data e =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r
    $cgmapQr :: forall e r r'.
    Data e =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ErrorFancy e -> r
    $cgmapQ :: forall e u.
    Data e =>
    (forall d. Data d => d -> u) -> ErrorFancy e -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ErrorFancy e -> [u]
    $cgmapQi :: forall e u.
    Data e =>
    Int -> (forall d. Data d => d -> u) -> ErrorFancy e -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ErrorFancy e -> u
    $cgmapM :: forall e (m :: * -> *).
    (Data e, Monad m) =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    $cgmapMp :: forall e (m :: * -> *).
    (Data e, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    $cgmapMo :: forall e (m :: * -> *).
    (Data e, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ErrorFancy e -> m (ErrorFancy e)
    Data, Typeable, (forall x. ErrorFancy e -> Rep (ErrorFancy e) x)
    -> (forall x. Rep (ErrorFancy e) x -> ErrorFancy e)
    -> Generic (ErrorFancy e)
    forall x. Rep (ErrorFancy e) x -> ErrorFancy e
    forall x. ErrorFancy e -> Rep (ErrorFancy e) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall e x. Rep (ErrorFancy e) x -> ErrorFancy e
    forall e x. ErrorFancy e -> Rep (ErrorFancy e) x
    $cfrom :: forall e x. ErrorFancy e -> Rep (ErrorFancy e) x
    from :: forall x. ErrorFancy e -> Rep (ErrorFancy e) x
    $cto :: forall e x. Rep (ErrorFancy e) x -> ErrorFancy e
    to :: forall x. Rep (ErrorFancy e) x -> ErrorFancy e
    Generic, (forall a b. (a -> b) -> ErrorFancy a -> ErrorFancy b)
    -> (forall a b. a -> ErrorFancy b -> ErrorFancy a)
    -> Functor ErrorFancy
    forall a b. a -> ErrorFancy b -> ErrorFancy a
    forall a b. (a -> b) -> ErrorFancy a -> ErrorFancy b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ErrorFancy a -> ErrorFancy b
    fmap :: forall a b. (a -> b) -> ErrorFancy a -> ErrorFancy b
    $c<$ :: forall a b. a -> ErrorFancy b -> ErrorFancy a
    <$ :: forall a b. a -> ErrorFancy b -> ErrorFancy a
    Functor)

    instance (NFData a) => NFData (ErrorFancy a) where
      rnf :: ErrorFancy a -> ()
    rnf (ErrorFail String
    str) = String -> ()
    forall a. NFData a => a -> ()
    rnf String
    str
      rnf (ErrorIndentation Ordering
    ord Pos
    ref Pos
    act) = Ordering
    ord Ordering -> () -> ()
    forall a b. a -> b -> b
    `seq` Pos -> ()
    forall a. NFData a => a -> ()
    rnf Pos
    ref () -> () -> ()
    forall a b. a -> b -> b
    `seq` Pos -> ()
    forall a. NFData a => a -> ()
    rnf Pos
    act
      rnf (ErrorCustom a
    a) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a

    -- | @'ParseError' s e@ represents a parse error parametrized over the
    -- stream type @s@ and the custom data @e@.
    --
    -- 'Semigroup' and 'Monoid' instances of the data type allow us to merge
    -- parse errors from different branches of parsing. When merging two
    -- 'ParseError's, the longest match is preferred; if positions are the same,
    -- custom data sets and collections of message items are combined. Note that
    -- fancy errors take precedence over trivial errors in merging.
    --
    -- @since 7.0.0
    data ParseError s e
      = -- | Trivial errors, generated by the Megaparsec's machinery. The data
        -- constructor includes the offset of error, unexpected token (if any),
        -- and expected tokens.
        --
        -- Type of the first argument was changed in the version /7.0.0/.
        TrivialError Int (Maybe (ErrorItem (Token s))) (Set (ErrorItem (Token s)))
      | -- | Fancy, custom errors.
        --
        -- Type of the first argument was changed in the version /7.0.0/.
        FancyError Int (Set (ErrorFancy e))
      deriving (Typeable, (forall x. ParseError s e -> Rep (ParseError s e) x)
    -> (forall x. Rep (ParseError s e) x -> ParseError s e)
    -> Generic (ParseError s e)
    forall x. Rep (ParseError s e) x -> ParseError s e
    forall x. ParseError s e -> Rep (ParseError s e) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall s e x. Rep (ParseError s e) x -> ParseError s e
    forall s e x. ParseError s e -> Rep (ParseError s e) x
    $cfrom :: forall s e x. ParseError s e -> Rep (ParseError s e) x
    from :: forall x. ParseError s e -> Rep (ParseError s e) x
    $cto :: forall s e x. Rep (ParseError s e) x -> ParseError s e
    to :: forall x. Rep (ParseError s e) x -> ParseError s e
    Generic)

    deriving instance
      ( Show (Token s),
        Show e
      ) =>
      Show (ParseError s e)

    deriving instance
      ( Eq (Token s),
        Eq e
      ) =>
      Eq (ParseError s e)

    deriving instance
      ( Data s,
        Data (Token s),
        Ord (Token s),
        Data e,
        Ord e
      ) =>
      Data (ParseError s e)

    instance
      ( NFData (Token s),
        NFData e
      ) =>
      NFData (ParseError s e)

    instance (Stream s, Ord e) => Semigroup (ParseError s e) where
      <> :: ParseError s e -> ParseError s e -> ParseError s e
    (<>) = ParseError s e -> ParseError s e -> ParseError s e
    forall s e.
    (Stream s, Ord e) =>
    ParseError s e -> ParseError s e -> ParseError s e
    mergeError
      {-# INLINE (<>) #-}

    instance (Stream s, Ord e) => Monoid (ParseError s e) where
      mempty :: ParseError s e
    mempty = Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    0 Maybe (ErrorItem (Token s))
    forall a. Maybe a
    Nothing Set (ErrorItem (Token s))
    forall a. Set a
    E.empty
      mappend :: ParseError s e -> ParseError s e -> ParseError s e
    mappend = ParseError s e -> ParseError s e -> ParseError s e
    forall a. Semigroup a => a -> a -> a
    (<>)
      {-# INLINE mappend #-}

    instance
      ( Show s,
        Show (Token s),
        Show e,
        ShowErrorComponent e,
        VisualStream s,
        Typeable s,
        Typeable e
      ) =>
      Exception (ParseError s e)
      where
      displayException :: ParseError s e -> String
    displayException = ParseError s e -> String
    forall s e.
    (VisualStream s, ShowErrorComponent e) =>
    ParseError s e -> String
    parseErrorPretty

    -- | Modify the custom data component in a parse error. This could be done
    -- via 'fmap' if not for the 'Ord' constraint.
    --
    -- @since 7.0.0
    mapParseError ::
      (Ord e') =>
      (e -> e') ->
      ParseError s e ->
      ParseError s e'
    mapParseError :: forall e' e s.
    Ord e' =>
    (e -> e') -> ParseError s e -> ParseError s e'
    mapParseError e -> e'
    _ (TrivialError Int
    o Maybe (ErrorItem (Token s))
    u Set (ErrorItem (Token s))
    p) = Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e'
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o Maybe (ErrorItem (Token s))
    u Set (ErrorItem (Token s))
    p
    mapParseError e -> e'
    f (FancyError Int
    o Set (ErrorFancy e)
    x) = Int -> Set (ErrorFancy e') -> ParseError s e'
    forall s e. Int -> Set (ErrorFancy e) -> ParseError s e
    FancyError Int
    o ((ErrorFancy e -> ErrorFancy e')
    -> Set (ErrorFancy e) -> Set (ErrorFancy e')
    forall b a. Ord b => (a -> b) -> Set a -> Set b
    E.map ((e -> e') -> ErrorFancy e -> ErrorFancy e'
    forall a b. (a -> b) -> ErrorFancy a -> ErrorFancy b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap e -> e'
    f) Set (ErrorFancy e)
    x)

    -- | Get the offset of a 'ParseError'.
    --
    -- @since 7.0.0
    errorOffset :: ParseError s e -> Int
    errorOffset :: forall s e. ParseError s e -> Int
    errorOffset (TrivialError Int
    o Maybe (ErrorItem (Token s))
    _ Set (ErrorItem (Token s))
    _) = Int
    o
    errorOffset (FancyError Int
    o Set (ErrorFancy e)
    _) = Int
    o

    -- | Set the offset of a 'ParseError'.
    --
    -- @since 8.0.0
    setErrorOffset :: Int -> ParseError s e -> ParseError s e
    setErrorOffset :: forall s e. Int -> ParseError s e -> ParseError s e
    setErrorOffset Int
    o (TrivialError Int
    _ Maybe (ErrorItem (Token s))
    u Set (ErrorItem (Token s))
    p) = Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o Maybe (ErrorItem (Token s))
    u Set (ErrorItem (Token s))
    p
    setErrorOffset Int
    o (FancyError Int
    _ Set (ErrorFancy e)
    x) = Int -> Set (ErrorFancy e) -> ParseError s e
    forall s e. Int -> Set (ErrorFancy e) -> ParseError s e
    FancyError Int
    o Set (ErrorFancy e)
    x

    -- | Merge two error data structures into one joining their collections of
    -- message items and preferring the longest match. In other words, earlier
    -- error message is discarded. This may seem counter-intuitive, but
    -- 'mergeError' is only used to merge error messages of alternative branches
    -- of parsing and in this case longest match should be preferred.
    mergeError ::
      (Stream s, Ord e) =>
      ParseError s e ->
      ParseError s e ->
      ParseError s e
    mergeError :: forall s e.
    (Stream s, Ord e) =>
    ParseError s e -> ParseError s e -> ParseError s e
    mergeError ParseError s e
    e1 ParseError s e
    e2 =
      case ParseError s e -> Int
    forall s e. ParseError s e -> Int
    errorOffset ParseError s e
    e1 Int -> Int -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` ParseError s e -> Int
    forall s e. ParseError s e -> Int
    errorOffset ParseError s e
    e2 of
        Ordering
    LT -> ParseError s e
    e2
        Ordering
    EQ ->
          case (ParseError s e
    e1, ParseError s e
    e2) of
            (TrivialError Int
    s1 Maybe (ErrorItem (Token s))
    u1 Set (ErrorItem (Token s))
    p1, TrivialError Int
    _ Maybe (ErrorItem (Token s))
    u2 Set (ErrorItem (Token s))
    p2) ->
              Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    s1 (Maybe (ErrorItem (Token s))
    -> Maybe (ErrorItem (Token s)) -> Maybe (ErrorItem (Token s))
    forall {a}. Ord a => Maybe a -> Maybe a -> Maybe a
    n Maybe (ErrorItem (Token s))
    u1 Maybe (ErrorItem (Token s))
    u2) (Set (ErrorItem (Token s))
    -> Set (ErrorItem (Token s)) -> Set (ErrorItem (Token s))
    forall a. Ord a => Set a -> Set a -> Set a
    E.union Set (ErrorItem (Token s))
    p1 Set (ErrorItem (Token s))
    p2)
            (FancyError {}, TrivialError {}) -> ParseError s e
    e1
            (TrivialError {}, FancyError {}) -> ParseError s e
    e2
            (FancyError Int
    s1 Set (ErrorFancy e)
    x1, FancyError Int
    _ Set (ErrorFancy e)
    x2) ->
              Int -> Set (ErrorFancy e) -> ParseError s e
    forall s e. Int -> Set (ErrorFancy e) -> ParseError s e
    FancyError Int
    s1 (Set (ErrorFancy e) -> Set (ErrorFancy e) -> Set (ErrorFancy e)
    forall a. Ord a => Set a -> Set a -> Set a
    E.union Set (ErrorFancy e)
    x1 Set (ErrorFancy e)
    x2)
        Ordering
    GT -> ParseError s e
    e1
      where
        -- NOTE The logic behind this merging is that since we only combine
        -- parse errors that happen at exactly the same position, all the
        -- unexpected items will be prefixes of input stream at that position or
        -- labels referring to the same thing. Our aim here is to choose the
        -- longest prefix (merging with labels and end of input is somewhat
        -- arbitrary, but is necessary because otherwise we can't make
        -- ParseError lawful Monoid and have nice parse errors at the same
        -- time).
        n :: Maybe a -> Maybe a -> Maybe a
    n Maybe a
    Nothing Maybe a
    Nothing = Maybe a
    forall a. Maybe a
    Nothing
        n (Just a
    x) Maybe a
    Nothing = a -> Maybe a
    forall a. a -> Maybe a
    Just a
    x
        n Maybe a
    Nothing (Just a
    y) = a -> Maybe a
    forall a. a -> Maybe a
    Just a
    y
        n (Just a
    x) (Just a
    y) = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> a -> a
    forall a. Ord a => a -> a -> a
    max a
    x a
    y)
    {-# INLINE mergeError #-}

    -- | A non-empty collection of 'ParseError's equipped with 'PosState' that
    -- allows us to pretty-print the errors efficiently and correctly.
    --
    -- @since 7.0.0
    data ParseErrorBundle s e = ParseErrorBundle
      { -- | A collection of 'ParseError's that is sorted by parse error offsets
        forall s e. ParseErrorBundle s e -> NonEmpty (ParseError s e)
    bundleErrors :: NonEmpty (ParseError s e),
        -- | The state that is used for line\/column calculation
        forall s e. ParseErrorBundle s e -> PosState s
    bundlePosState :: PosState s
      }
      deriving ((forall x. ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x)
    -> (forall x. Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e)
    -> Generic (ParseErrorBundle s e)
    forall x. Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e
    forall x. ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall s e x. Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e
    forall s e x. ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x
    $cfrom :: forall s e x. ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x
    from :: forall x. ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x
    $cto :: forall s e x. Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e
    to :: forall x. Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e
    Generic)

    deriving instance
      ( Show s,
        Show (Token s),
        Show e
      ) =>
      Show (ParseErrorBundle s e)

    deriving instance
      ( Eq s,
        Eq (Token s),
        Eq e
      ) =>
      Eq (ParseErrorBundle s e)

    deriving instance
      ( Typeable s,
        Typeable (Token s),
        Typeable e
      ) =>
      Typeable (ParseErrorBundle s e)

    deriving instance
      ( Data s,
        Data (Token s),
        Ord (Token s),
        Data e,
        Ord e
      ) =>
      Data (ParseErrorBundle s e)

    instance
      ( NFData s,
        NFData (Token s),
        NFData e
      ) =>
      NFData (ParseErrorBundle s e)

    instance
      ( Show s,
        Show (Token s),
        Show e,
        ShowErrorComponent e,
        VisualStream s,
        TraversableStream s,
        Typeable s,
        Typeable e
      ) =>
      Exception (ParseErrorBundle s e)
      where
      displayException :: ParseErrorBundle s e -> String
    displayException = ParseErrorBundle s e -> String
    forall s e.
    (VisualStream s, TraversableStream s, ShowErrorComponent e) =>
    ParseErrorBundle s e -> String
    errorBundlePretty

    -- | Attach 'SourcePos'es to items in a 'Traversable' container given that
    -- there is a projection allowing us to get an offset per item.
    --
    -- Items must be in ascending order with respect to their offsets.
    --
    -- @since 7.0.0
    attachSourcePos ::
      (Traversable t, TraversableStream s) =>
      -- | How to project offset from an item (e.g. 'errorOffset')
      (a -> Int) ->
      -- | The collection of items
      t a ->
      -- | Initial 'PosState'
      PosState s ->
      -- | The collection with 'SourcePos'es added and the final 'PosState'
      (t (a, SourcePos), PosState s)
    attachSourcePos :: forall (t :: * -> *) s a.
    (Traversable t, TraversableStream s) =>
    (a -> Int) -> t a -> PosState s -> (t (a, SourcePos), PosState s)
    attachSourcePos a -> Int
    projectOffset t a
    xs = State (PosState s) (t (a, SourcePos))
    -> PosState s -> (t (a, SourcePos), PosState s)
    forall s a. State s a -> s -> (a, s)
    runState ((a -> StateT (PosState s) Identity (a, SourcePos))
    -> t a -> State (PosState s) (t (a, SourcePos))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b)
    traverse a -> StateT (PosState s) Identity (a, SourcePos)
    forall {m :: * -> *} {s}.
    (MonadState (PosState s) m, TraversableStream s) =>
    a -> m (a, SourcePos)
    f t a
    xs)
      where
        f :: a -> m (a, SourcePos)
    f a
    a = do
          PosState s
    pst <- m (PosState s)
    forall s (m :: * -> *). MonadState s m => m s
    get
          let pst' :: PosState s
    pst' = Int -> PosState s -> PosState s
    forall s. TraversableStream s => Int -> PosState s -> PosState s
    reachOffsetNoLine (a -> Int
    projectOffset a
    a) PosState s
    pst
          PosState s -> m ()
    forall s (m :: * -> *). MonadState s m => s -> m ()
    put PosState s
    pst'
          (a, SourcePos) -> m (a, SourcePos)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    a, PosState s -> SourcePos
    forall s. PosState s -> SourcePos
    pstateSourcePos PosState s
    pst')
    {-# INLINEABLE attachSourcePos #-}

    ----------------------------------------------------------------------------
    -- Pretty-printing

    -- | The type class defines how to print a custom component of 'ParseError'.
    --
    -- @since 5.0.0
    class (Ord a) => ShowErrorComponent a where
      -- | Pretty-print a component of 'ParseError'.
      showErrorComponent :: a -> String

      -- | Length of the error component in characters, used for highlighting of
      -- parse errors in input string.
      --
      -- @since 7.0.0
      errorComponentLen :: a -> Int
      errorComponentLen a
    _ = Int
    1

    instance ShowErrorComponent Void where
      showErrorComponent :: Void -> String
    showErrorComponent = Void -> String
    forall a. Void -> a
    absurd

    -- | Pretty-print a 'ParseErrorBundle'. All 'ParseError's in the bundle will
    -- be pretty-printed in order together with the corresponding offending
    -- lines by doing a single pass over the input stream. The rendered 'String'
    -- always ends with a newline.
    --
    -- @since 7.0.0
    errorBundlePretty ::
      forall s e.
      ( VisualStream s,
        TraversableStream s,
        ShowErrorComponent e
      ) =>
      -- | Parse error bundle to display
      ParseErrorBundle s e ->
      -- | Textual rendition of the bundle
      String
    errorBundlePretty :: forall s e.
    (VisualStream s, TraversableStream s, ShowErrorComponent e) =>
    ParseErrorBundle s e -> String
    errorBundlePretty ParseErrorBundle {NonEmpty (ParseError s e)
    PosState s
    bundleErrors :: forall s e. ParseErrorBundle s e -> NonEmpty (ParseError s e)
    bundlePosState :: forall s e. ParseErrorBundle s e -> PosState s
    bundleErrors :: NonEmpty (ParseError s e)
    bundlePosState :: PosState s
    ..} =
      let (ShowS
    r, PosState s
    _) = ((ShowS, PosState s) -> ParseError s e -> (ShowS, PosState s))
    -> (ShowS, PosState s)
    -> NonEmpty (ParseError s e)
    -> (ShowS, PosState s)
    forall b a. (b -> a -> b) -> b -> NonEmpty a -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl (ShowS, PosState s) -> ParseError s e -> (ShowS, PosState s)
    f (ShowS
    forall a. a -> a
    id, PosState s
    bundlePosState) NonEmpty (ParseError s e)
    bundleErrors
       in Int -> ShowS
    forall a. Int -> [a] -> [a]
    drop Int
    1 (ShowS
    r String
    "")
      where
        f ::
          (ShowS, PosState s) ->
          ParseError s e ->
          (ShowS, PosState s)
        f :: (ShowS, PosState s) -> ParseError s e -> (ShowS, PosState s)
    f (ShowS
    o, !PosState s
    pst) ParseError s e
    e = (ShowS
    o ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (String
    outChunk String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++), PosState s
    pst')
          where
            (Maybe String
    msline, PosState s
    pst') = Int -> PosState s -> (Maybe String, PosState s)
    forall s.
    TraversableStream s =>
    Int -> PosState s -> (Maybe String, PosState s)
    reachOffset (ParseError s e -> Int
    forall s e. ParseError s e -> Int
    errorOffset ParseError s e
    e) PosState s
    pst
            epos :: SourcePos
    epos = PosState s -> SourcePos
    forall s. PosState s -> SourcePos
    pstateSourcePos PosState s
    pst'
            outChunk :: String
    outChunk =
              String
    "\n"
                String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> SourcePos -> String
    sourcePosPretty SourcePos
    epos
                String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    ":\n"
                String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    offendingLine
                String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> ParseError s e -> String
    forall s e.
    (VisualStream s, ShowErrorComponent e) =>
    ParseError s e -> String
    parseErrorTextPretty ParseError s e
    e
            offendingLine :: String
    offendingLine =
              case Maybe String
    msline of
                Maybe String
    Nothing -> String
    ""
                Just String
    sline ->
                  let rpadding :: String
    rpadding =
                        if Int
    pointerLen Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0
                          then Int -> Char -> String
    forall a. Int -> a -> [a]
    replicate Int
    rpshift Char
    ' '
                          else String
    ""
                      pointerLen :: Int
    pointerLen =
                        if Int
    rpshift Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    elen Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    slineLen
                          then Int
    slineLen Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    rpshift Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1
                          else Int
    elen
                      pointer :: String
    pointer = Int -> Char -> String
    forall a. Int -> a -> [a]
    replicate Int
    pointerLen Char
    '^'
                      lineNumber :: String
    lineNumber = (Int -> String
    forall a. Show a => a -> String
    show (Int -> String) -> (SourcePos -> Int) -> SourcePos -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Pos -> Int
    unPos (Pos -> Int) -> (SourcePos -> Pos) -> SourcePos -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SourcePos -> Pos
    sourceLine) SourcePos
    epos
                      padding :: String
    padding = Int -> Char -> String
    forall a. Int -> a -> [a]
    replicate (String -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length String
    lineNumber Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Char
    ' '
                      rpshift :: Int
    rpshift = Pos -> Int
    unPos (SourcePos -> Pos
    sourceColumn SourcePos
    epos) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1
                      slineLen :: Int
    slineLen = String -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length String
    sline
                   in String
    padding
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    "|\n"
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    lineNumber
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    " | "
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    sline
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    "\n"
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    padding
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    "| "
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    rpadding
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    pointer
                        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    "\n"
            pxy :: Proxy s
    pxy = Proxy s
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy s
            elen :: Int
    elen =
              case ParseError s e
    e of
                TrivialError Int
    _ Maybe (ErrorItem (Token s))
    Nothing Set (ErrorItem (Token s))
    _ -> Int
    1
                TrivialError Int
    _ (Just ErrorItem (Token s)
    x) Set (ErrorItem (Token s))
    _ -> Proxy s -> ErrorItem (Token s) -> Int
    forall s. VisualStream s => Proxy s -> ErrorItem (Token s) -> Int
    errorItemLength Proxy s
    pxy ErrorItem (Token s)
    x
                FancyError Int
    _ Set (ErrorFancy e)
    xs ->
                  (Int -> ErrorFancy e -> Int) -> Int -> Set (ErrorFancy e) -> Int
    forall a b. (a -> b -> a) -> a -> Set b -> a
    E.foldl' (\Int
    a ErrorFancy e
    b -> Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    a (ErrorFancy e -> Int
    forall e. ShowErrorComponent e => ErrorFancy e -> Int
    errorFancyLength ErrorFancy e
    b)) Int
    1 Set (ErrorFancy e)
    xs

    -- | Pretty-print a 'ParseError'. The rendered 'String' always ends with a
    -- newline.
    --
    -- @since 5.0.0
    parseErrorPretty ::
      (VisualStream s, ShowErrorComponent e) =>
      -- | Parse error to render
      ParseError s e ->
      -- | Result of rendering
      String
    parseErrorPretty :: forall s e.
    (VisualStream s, ShowErrorComponent e) =>
    ParseError s e -> String
    parseErrorPretty ParseError s e
    e =
      String
    "offset=" String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> Int -> String
    forall a. Show a => a -> String
    show (ParseError s e -> Int
    forall s e. ParseError s e -> Int
    errorOffset ParseError s e
    e) String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    ":\n" String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> ParseError s e -> String
    forall s e.
    (VisualStream s, ShowErrorComponent e) =>
    ParseError s e -> String
    parseErrorTextPretty ParseError s e
    e

    -- | Pretty-print a textual part of a 'ParseError', that is, everything
    -- except for its position. The rendered 'String' always ends with a
    -- newline.
    --
    -- @since 5.1.0
    parseErrorTextPretty ::
      forall s e.
      (VisualStream s, ShowErrorComponent e) =>
      -- | Parse error to render
      ParseError s e ->
      -- | Result of rendering
      String
    parseErrorTextPretty :: forall s e.
    (VisualStream s, ShowErrorComponent e) =>
    ParseError s e -> String
    parseErrorTextPretty (TrivialError Int
    _ Maybe (ErrorItem (Token s))
    us Set (ErrorItem (Token s))
    ps) =
      if Maybe (ErrorItem (Token s)) -> Bool
    forall a. Maybe a -> Bool
    isNothing Maybe (ErrorItem (Token s))
    us Bool -> Bool -> Bool
    && Set (ErrorItem (Token s)) -> Bool
    forall a. Set a -> Bool
    E.null Set (ErrorItem (Token s))
    ps
        then String
    "unknown parse error\n"
        else
          String -> Set String -> String
    messageItemsPretty String
    "unexpected " (Proxy s -> ErrorItem (Token s) -> String
    forall s.
    VisualStream s =>
    Proxy s -> ErrorItem (Token s) -> String
    showErrorItem Proxy s
    pxy (ErrorItem (Token s) -> String)
    -> Set (ErrorItem (Token s)) -> Set String
    forall b a. Ord b => (a -> b) -> Set a -> Set b
    `E.map` Set (ErrorItem (Token s))
    -> (ErrorItem (Token s) -> Set (ErrorItem (Token s)))
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Set (ErrorItem (Token s))
    forall a. Set a
    E.empty ErrorItem (Token s) -> Set (ErrorItem (Token s))
    forall a. a -> Set a
    E.singleton Maybe (ErrorItem (Token s))
    us)
            String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String -> Set String -> String
    messageItemsPretty String
    "expecting " (Proxy s -> ErrorItem (Token s) -> String
    forall s.
    VisualStream s =>
    Proxy s -> ErrorItem (Token s) -> String
    showErrorItem Proxy s
    pxy (ErrorItem (Token s) -> String)
    -> Set (ErrorItem (Token s)) -> Set String
    forall b a. Ord b => (a -> b) -> Set a -> Set b
    `E.map` Set (ErrorItem (Token s))
    ps)
      where
        pxy :: Proxy s
    pxy = Proxy s
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy s
    parseErrorTextPretty (FancyError Int
    _ Set (ErrorFancy e)
    xs) =
      if Set (ErrorFancy e) -> Bool
    forall a. Set a -> Bool
    E.null Set (ErrorFancy e)
    xs
        then String
    "unknown fancy parse error\n"
        else [String] -> String
    unlines (ErrorFancy e -> String
    forall e. ShowErrorComponent e => ErrorFancy e -> String
    showErrorFancy (ErrorFancy e -> String) -> [ErrorFancy e] -> [String]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set (ErrorFancy e) -> [ErrorFancy e]
    forall a. Set a -> [a]
    E.toAscList Set (ErrorFancy e)
    xs)

    ----------------------------------------------------------------------------
    -- Helpers

    -- | Pretty-print an 'ErrorItem'.
    --
    -- @since 9.4.0
    showErrorItem :: (VisualStream s) => Proxy s -> ErrorItem (Token s) -> String
    showErrorItem :: forall s.
    VisualStream s =>
    Proxy s -> ErrorItem (Token s) -> String
    showErrorItem Proxy s
    pxy = \case
      Tokens NonEmpty (Token s)
    ts -> Proxy s -> NonEmpty (Token s) -> String
    forall s. VisualStream s => Proxy s -> NonEmpty (Token s) -> String
    showTokens Proxy s
    pxy NonEmpty (Token s)
    ts
      Label NonEmpty Char
    label -> NonEmpty Char -> String
    forall a. NonEmpty a -> [a]
    NE.toList NonEmpty Char
    label
      ErrorItem (Token s)
    EndOfInput -> String
    "end of input"

    -- | Get length of the “pointer” to display under a given 'ErrorItem'.
    errorItemLength :: (VisualStream s) => Proxy s -> ErrorItem (Token s) -> Int
    errorItemLength :: forall s. VisualStream s => Proxy s -> ErrorItem (Token s) -> Int
    errorItemLength Proxy s
    pxy = \case
      Tokens NonEmpty (Token s)
    ts -> Proxy s -> NonEmpty (Token s) -> Int
    forall s. VisualStream s => Proxy s -> NonEmpty (Token s) -> Int
    tokensLength Proxy s
    pxy NonEmpty (Token s)
    ts
      ErrorItem (Token s)
    _ -> Int
    1

    -- | Pretty-print an 'ErrorFancy'.
    showErrorFancy :: (ShowErrorComponent e) => ErrorFancy e -> String
    showErrorFancy :: forall e. ShowErrorComponent e => ErrorFancy e -> String
    showErrorFancy = \case
      ErrorFail String
    msg -> String
    msg
      ErrorIndentation Ordering
    ord Pos
    ref Pos
    actual ->
        String
    "incorrect indentation (got "
          String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> Int -> String
    forall a. Show a => a -> String
    show (Pos -> Int
    unPos Pos
    actual)
          String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    ", should be "
          String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    p
          String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> Int -> String
    forall a. Show a => a -> String
    show (Pos -> Int
    unPos Pos
    ref)
          String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    ")"
        where
          p :: String
    p = case Ordering
    ord of
            Ordering
    LT -> String
    "less than "
            Ordering
    EQ -> String
    "equal to "
            Ordering
    GT -> String
    "greater than "
      ErrorCustom e
    a -> e -> String
    forall a. ShowErrorComponent a => a -> String
    showErrorComponent e
    a

    -- | Get length of the “pointer” to display under a given 'ErrorFancy'.
    errorFancyLength :: (ShowErrorComponent e) => ErrorFancy e -> Int
    errorFancyLength :: forall e. ShowErrorComponent e => ErrorFancy e -> Int
    errorFancyLength = \case
      ErrorCustom e
    a -> e -> Int
    forall a. ShowErrorComponent a => a -> Int
    errorComponentLen e
    a
      ErrorFancy e
    _ -> Int
    1

    -- | Transform a list of error messages into their textual representation.
    messageItemsPretty ::
      -- | Prefix to prepend
      String ->
      -- | Collection of messages
      Set String ->
      -- | Result of rendering
      String
    messageItemsPretty :: String -> Set String -> String
    messageItemsPretty String
    prefix Set String
    ts
      | Set String -> Bool
    forall a. Set a -> Bool
    E.null Set String
    ts = String
    ""
      | Bool
    otherwise =
          String
    prefix String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> (NonEmpty String -> String
    orList (NonEmpty String -> String)
    -> (Set String -> NonEmpty String) -> Set String -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [String] -> NonEmpty String
    forall a. HasCallStack => [a] -> NonEmpty a
    NE.fromList ([String] -> NonEmpty String)
    -> (Set String -> [String]) -> Set String -> NonEmpty String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Set String -> [String]
    forall a. Set a -> [a]
    E.toAscList) Set String
    ts String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    "\n"

    -- | Print a pretty list where items are separated with commas and the word
    -- “or” according to the rules of English punctuation.
    orList :: NonEmpty String -> String
    orList :: NonEmpty String -> String
    orList (String
    x :| []) = String
    x
    orList (String
    x :| [String
    y]) = String
    x String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    " or " String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    y
    orList NonEmpty String
    xs = String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    ", " (NonEmpty String -> [String]
    forall a. NonEmpty a -> [a]
    NE.init NonEmpty String
    xs) String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    ", or " String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> NonEmpty String -> String
    forall a. NonEmpty a -> a
    NE.last NonEmpty String
    xs