{-# 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
(
ErrorItem (..),
ErrorFancy (..),
ParseError (..),
mapParseError,
errorOffset,
setErrorOffset,
ParseErrorBundle (..),
attachSourcePos,
ShowErrorComponent (..),
errorBundlePretty,
errorBundlePrettyForGhcPreProcessors,
errorBundlePrettyWith,
parseErrorPretty,
parseErrorTextPretty,
showErrorItem,
)
where
import Control.Arrow ((>>>))
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
import qualified Text.Megaparsec.Unicode as Unicode
data ErrorItem t
=
Tokens (NonEmpty t)
|
Label (NonEmpty Char)
|
EndOfInput
deriving (Int -> ErrorItem t -> ShowS
[ErrorItem t] -> ShowS
ErrorItem t -> [Char]
(Int -> ErrorItem t -> ShowS)
-> (ErrorItem t -> [Char])
-> ([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 -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([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 -> [Char]
show :: ErrorItem t -> [Char]
$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, (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)
data ErrorFancy e
=
ErrorFail String
|
ErrorIndentation Ordering Pos Pos
|
ErrorCustom e
deriving (Int -> ErrorFancy e -> ShowS
[ErrorFancy e] -> ShowS
ErrorFancy e -> [Char]
(Int -> ErrorFancy e -> ShowS)
-> (ErrorFancy e -> [Char])
-> ([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 -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([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 -> [Char]
show :: ErrorFancy e -> [Char]
$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, (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 [Char]
str) = [Char] -> ()
forall a. NFData a => a -> ()
rnf [Char]
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
data ParseError s e
=
TrivialError Int (Maybe (ErrorItem (Token s))) (Set (ErrorItem (Token s)))
|
FancyError Int (Set (ErrorFancy e))
deriving ((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 (Token s),
Show e,
ShowErrorComponent e,
VisualStream s,
Typeable s,
Typeable e
) =>
Exception (ParseError s e)
where
displayException :: ParseError s e -> [Char]
displayException = ParseError s e -> [Char]
forall s e.
(VisualStream s, ShowErrorComponent e) =>
ParseError s e -> [Char]
parseErrorPretty
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)
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
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
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
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 #-}
data ParseErrorBundle s e = ParseErrorBundle
{
forall s e. ParseErrorBundle s e -> NonEmpty (ParseError s e)
bundleErrors :: NonEmpty (ParseError s e),
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
( 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 -> [Char]
displayException = ParseErrorBundle s e -> [Char]
forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> [Char]
errorBundlePretty
attachSourcePos ::
(Traversable t, TraversableStream s) =>
(a -> Int) ->
t a ->
PosState s ->
(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
pst <- m (PosState s)
forall s (m :: * -> *). MonadState s m => m s
get
let pst' = Int -> PosState s -> PosState s
forall s. TraversableStream s => Int -> PosState s -> PosState s
reachOffsetNoLine (a -> Int
projectOffset a
a) PosState s
pst
put pst'
return (a, pstateSourcePos pst')
{-# INLINEABLE attachSourcePos #-}
class (Ord a) => ShowErrorComponent a where
showErrorComponent :: a -> String
errorComponentLen :: a -> Int
errorComponentLen a
_ = Int
1
instance ShowErrorComponent Void where
showErrorComponent :: Void -> [Char]
showErrorComponent = Void -> [Char]
forall a. Void -> a
absurd
errorBundlePrettyWith ::
forall s e.
( VisualStream s,
TraversableStream s
) =>
(Maybe String -> SourcePos -> ParseError s e -> String) ->
ParseErrorBundle s e ->
String
errorBundlePrettyWith :: forall s e.
(VisualStream s, TraversableStream s) =>
(Maybe [Char] -> SourcePos -> ParseError s e -> [Char])
-> ParseErrorBundle s e -> [Char]
errorBundlePrettyWith Maybe [Char] -> SourcePos -> ParseError s e -> [Char]
format 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 ShowS
r [Char]
""
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
. ([Char]
outChunk [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++), PosState s
pst')
where
(Maybe [Char]
msline, PosState s
pst') = Int -> PosState s -> (Maybe [Char], PosState s)
forall s.
TraversableStream s =>
Int -> PosState s -> (Maybe [Char], 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 :: [Char]
outChunk = Maybe [Char] -> SourcePos -> ParseError s e -> [Char]
format Maybe [Char]
msline SourcePos
epos ParseError s e
e
errorBundlePretty ::
forall s e.
( VisualStream s,
TraversableStream s,
ShowErrorComponent e
) =>
ParseErrorBundle s e ->
String
errorBundlePretty :: forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> [Char]
errorBundlePretty = Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 ShowS
-> (ParseErrorBundle s e -> [Char])
-> ParseErrorBundle s e
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe [Char] -> SourcePos -> ParseError s e -> [Char])
-> ParseErrorBundle s e -> [Char]
forall s e.
(VisualStream s, TraversableStream s) =>
(Maybe [Char] -> SourcePos -> ParseError s e -> [Char])
-> ParseErrorBundle s e -> [Char]
errorBundlePrettyWith Maybe [Char] -> SourcePos -> ParseError s e -> [Char]
format
where
format ::
Maybe String ->
SourcePos ->
ParseError s e ->
String
format :: Maybe [Char] -> SourcePos -> ParseError s e -> [Char]
format Maybe [Char]
msline SourcePos
epos ParseError s e
e = [Char]
outChunk
where
outChunk :: [Char]
outChunk =
[Char]
"\n"
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> SourcePos -> [Char]
sourcePosPretty SourcePos
epos
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
":\n"
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
offendingLine
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> ParseError s e -> [Char]
forall s e.
(VisualStream s, ShowErrorComponent e) =>
ParseError s e -> [Char]
parseErrorTextPretty ParseError s e
e
offendingLine :: [Char]
offendingLine =
case Maybe [Char]
msline of
Maybe [Char]
Nothing -> [Char]
""
Just [Char]
sline ->
let rpadding :: [Char]
rpadding = Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
rpshift Char
' '
pointerLen :: Int
pointerLen =
Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$
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 :: [Char]
pointer = Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
pointerLen Char
'^'
lineNumber :: [Char]
lineNumber = (Int -> [Char]
forall a. Show a => a -> [Char]
show (Int -> [Char]) -> (SourcePos -> Int) -> SourcePos -> [Char]
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 :: [Char]
padding = Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate ([Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
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 = [Char] -> Int
forall (t :: * -> *). Traversable t => t Char -> Int
Unicode.stringLength [Char]
sline
in [Char]
padding
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
"|\n"
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
lineNumber
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
" | "
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
sline
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
"\n"
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
padding
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
"| "
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
rpadding
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
pointer
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
"\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
errorBundlePrettyForGhcPreProcessors ::
forall s e.
( VisualStream s,
TraversableStream s,
ShowErrorComponent e
) =>
ParseErrorBundle s e ->
String
errorBundlePrettyForGhcPreProcessors :: forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> [Char]
errorBundlePrettyForGhcPreProcessors = (Maybe [Char] -> SourcePos -> ParseError s e -> [Char])
-> ParseErrorBundle s e -> [Char]
forall s e.
(VisualStream s, TraversableStream s) =>
(Maybe [Char] -> SourcePos -> ParseError s e -> [Char])
-> ParseErrorBundle s e -> [Char]
errorBundlePrettyWith Maybe [Char] -> SourcePos -> ParseError s e -> [Char]
format
where
format ::
Maybe String ->
SourcePos ->
ParseError s e ->
String
format :: Maybe [Char] -> SourcePos -> ParseError s e -> [Char]
format Maybe [Char]
_msline SourcePos
epos ParseError s e
e =
SourcePos -> [Char]
sourcePosPretty SourcePos
epos
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
":"
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> ShowS
indent (ParseError s e -> [Char]
forall s e.
(VisualStream s, ShowErrorComponent e) =>
ParseError s e -> [Char]
parseErrorTextPretty ParseError s e
e)
indent :: String -> String
indent :: ShowS
indent =
[Char] -> [[Char]]
lines ([Char] -> [[Char]]) -> ([[Char]] -> [Char]) -> ShowS
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> \case
[[Char]
err] -> [Char]
err
[[Char]]
err -> [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"\n" ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ ShowS -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char]
" " [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<>) [[Char]]
err
parseErrorPretty ::
(VisualStream s, ShowErrorComponent e) =>
ParseError s e ->
String
parseErrorPretty :: forall s e.
(VisualStream s, ShowErrorComponent e) =>
ParseError s e -> [Char]
parseErrorPretty ParseError s e
e =
[Char]
"offset=" [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show (ParseError s e -> Int
forall s e. ParseError s e -> Int
errorOffset ParseError s e
e) [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
":\n" [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> ParseError s e -> [Char]
forall s e.
(VisualStream s, ShowErrorComponent e) =>
ParseError s e -> [Char]
parseErrorTextPretty ParseError s e
e
parseErrorTextPretty ::
forall s e.
(VisualStream s, ShowErrorComponent e) =>
ParseError s e ->
String
parseErrorTextPretty :: forall s e.
(VisualStream s, ShowErrorComponent e) =>
ParseError s e -> [Char]
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 [Char]
"unknown parse error\n"
else
[Char] -> Set [Char] -> [Char]
messageItemsPretty [Char]
"unexpected " (Proxy s -> ErrorItem (Token s) -> [Char]
forall s.
VisualStream s =>
Proxy s -> ErrorItem (Token s) -> [Char]
showErrorItem Proxy s
pxy (ErrorItem (Token s) -> [Char])
-> Set (ErrorItem (Token s)) -> Set [Char]
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)
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char] -> Set [Char] -> [Char]
messageItemsPretty [Char]
"expecting " (Proxy s -> ErrorItem (Token s) -> [Char]
forall s.
VisualStream s =>
Proxy s -> ErrorItem (Token s) -> [Char]
showErrorItem Proxy s
pxy (ErrorItem (Token s) -> [Char])
-> Set (ErrorItem (Token s)) -> Set [Char]
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 [Char]
"unknown fancy parse error\n"
else [[Char]] -> [Char]
unlines (ErrorFancy e -> [Char]
forall e. ShowErrorComponent e => ErrorFancy e -> [Char]
showErrorFancy (ErrorFancy e -> [Char]) -> [ErrorFancy e] -> [[Char]]
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)
showErrorItem :: (VisualStream s) => Proxy s -> ErrorItem (Token s) -> String
showErrorItem :: forall s.
VisualStream s =>
Proxy s -> ErrorItem (Token s) -> [Char]
showErrorItem Proxy s
pxy = \case
Tokens NonEmpty (Token s)
ts -> Proxy s -> NonEmpty (Token s) -> [Char]
forall s. VisualStream s => Proxy s -> NonEmpty (Token s) -> [Char]
showTokens Proxy s
pxy NonEmpty (Token s)
ts
Label NonEmpty Char
label -> NonEmpty Char -> [Char]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty Char
label
ErrorItem (Token s)
EndOfInput -> [Char]
"end of input"
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
showErrorFancy :: (ShowErrorComponent e) => ErrorFancy e -> String
showErrorFancy :: forall e. ShowErrorComponent e => ErrorFancy e -> [Char]
showErrorFancy = \case
ErrorFail [Char]
msg -> [Char]
msg
ErrorIndentation Ordering
ord Pos
ref Pos
actual ->
[Char]
"incorrect indentation (got "
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show (Pos -> Int
unPos Pos
actual)
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
", should be "
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
p
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show (Pos -> Int
unPos Pos
ref)
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
")"
where
p :: [Char]
p = case Ordering
ord of
Ordering
LT -> [Char]
"less than "
Ordering
EQ -> [Char]
"equal to "
Ordering
GT -> [Char]
"greater than "
ErrorCustom e
a -> e -> [Char]
forall a. ShowErrorComponent a => a -> [Char]
showErrorComponent e
a
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
messageItemsPretty ::
String ->
Set String ->
String
messageItemsPretty :: [Char] -> Set [Char] -> [Char]
messageItemsPretty [Char]
prefix Set [Char]
ts
| Set [Char] -> Bool
forall a. Set a -> Bool
E.null Set [Char]
ts = [Char]
""
| Bool
otherwise =
[Char]
prefix [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> (NonEmpty [Char] -> [Char]
orList (NonEmpty [Char] -> [Char])
-> (Set [Char] -> NonEmpty [Char]) -> Set [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> NonEmpty [Char]
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList ([[Char]] -> NonEmpty [Char])
-> (Set [Char] -> [[Char]]) -> Set [Char] -> NonEmpty [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set [Char] -> [[Char]]
forall a. Set a -> [a]
E.toAscList) Set [Char]
ts [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
"\n"
orList :: NonEmpty String -> String
orList :: NonEmpty [Char] -> [Char]
orList ([Char]
x :| []) = [Char]
x
orList ([Char]
x :| [[Char]
y]) = [Char]
x [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
" or " [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
y
orList NonEmpty [Char]
xs = [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
", " (NonEmpty [Char] -> [[Char]]
forall a. NonEmpty a -> [a]
NE.init NonEmpty [Char]
xs) [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
", or " [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> NonEmpty [Char] -> [Char]
forall a. NonEmpty a -> a
NE.last NonEmpty [Char]
xs