Text.Trifecta.Diagnostic

Diagnostics

data Diagnostic m

Constructors

Diagnostic !(Either String Rendering) !DiagnosticLevel m [Diagnostic m]

Instances

Functor Diagnostic

Typeable1 Diagnostic

Foldable Diagnostic

Traversable Diagnostic

Comonad Diagnostic

Extend Diagnostic

Foldable1 Diagnostic

Traversable1 Diagnostic

Show m => Show (Diagnostic m)

(Typeable m, Show m) => Exception (Diagnostic m)

Pretty m => Pretty (Diagnostic m)

PrettyTerm m => PrettyTerm (Diagnostic m)

HasBytes (Diagnostic m)

HasDelta (Diagnostic m)

Highlightable (Diagnostic e)

Renderable (Diagnostic m)

Rendering

class Renderable t where

Methods

render :: t -> Rendering

Instances

Renderable Rendering

Renderable Caret

Renderable Span

Renderable Fixit

Renderable (Rendered a)

Renderable (Diagnostic m)

Renderable (Careted a)

Renderable (Spanned a)

class Source t

Instances

Source String

Source ByteString

rendering :: Source s => Delta -> s -> Rendering

create a drawing surface

renderingCaret :: Delta -> ByteString -> Rendering

data Caret

 In file included from baz.c:9
 In file included from bar.c:4
 foo.c:8:36: note
 int main(int argc, char ** argv) { int; }
                                    ^

Constructors

Caret !Delta !ByteString

Instances

Eq Caret

Ord Caret

Show Caret

Hashable Caret

Semigroup Caret

HasBytes Caret

HasDelta Caret

Renderable Caret

Reducer Caret Rendering

data Careted a

Constructors

a :^ Caret

Instances

Functor Careted

Foldable Careted

Traversable Careted

Comonad Careted

Extend Careted

Foldable1 Careted

Traversable1 Careted

Eq a => Eq (Careted a)

Ord a => Ord (Careted a)

Show a => Show (Careted a)

Hashable a => Hashable (Careted a)

HasBytes (Careted a)

HasDelta (Careted a)

Renderable (Careted a)

Reducer (Careted a) Rendering

data Span

Constructors

Span !Delta !Delta !ByteString

Instances

Eq Span

Ord Span

Show Span

Hashable Span

Semigroup Span

Renderable Span

Reducer Span Rendering

data Spanned a

Constructors

a :~ Span

Instances

Functor Spanned

Foldable Spanned

Traversable Spanned

Comonad Spanned

Extend Spanned

Apply Spanned

Foldable1 Spanned

Traversable1 Spanned

Bind Spanned

Eq a => Eq (Spanned a)

Ord a => Ord (Spanned a)

Show a => Show (Spanned a)

Hashable a => Hashable (Spanned a)

Renderable (Spanned a)

Reducer (Spanned a) Rendering

data Fixit

Constructors

Fixit

Fields

fixitSpan :: !Span

fixitReplacement :: !ByteString

Instances

Eq Fixit

Ord Fixit

Show Fixit

Hashable Fixit

Renderable Fixit

Reducer Fixit Rendering

data Rendered a

Constructors

a :@ Rendering

Instances

Functor Rendered

Foldable Rendered

Traversable Rendered

Comonad Rendered

Extend Rendered

Apply Rendered

Foldable1 Rendered

Traversable1 Rendered

Bind Rendered

Show a => Show (Rendered a)

HasBytes (Rendered a)

HasDelta (Rendered a)

Renderable (Rendered a)

Emitting diagnostics

class Monad m => MonadDiagnostic e m | m -> e where

Methods

throwDiagnostic :: Diagnostic e -> m a

logDiagnostic :: Diagnostic e -> m ()

Instances

MonadDiagnostic e m => MonadDiagnostic e (IdentityT m)

MonadDiagnostic e m => MonadDiagnostic e (Language m)

MonadDiagnostic e m => MonadDiagnostic e (Literate m)

MonadDiagnostic e m => MonadDiagnostic e (Layout m)

(MonadDiagnostic e m, Monoid w) => MonadDiagnostic e (WriterT w m)

(MonadDiagnostic e m, Monoid w) => MonadDiagnostic e (WriterT w m)

MonadDiagnostic e m => MonadDiagnostic e (ReaderT r m)

MonadDiagnostic e m => MonadDiagnostic e (StateT s m)

MonadDiagnostic e m => MonadDiagnostic e (StateT s m)

MonadDiagnostic e (Parser r e)

(MonadDiagnostic e m, Monoid w) => MonadDiagnostic e (RWST r w s m)

(MonadDiagnostic e m, Monoid w) => MonadDiagnostic e (RWST r w s m)

panic, err, fatal :: (MonadParser m, MonadDiagnostic e m) => [Diagnostic e] -> e -> m a

panicAt, errAt, fatalAt :: MonadDiagnostic e m => [Diagnostic e] -> e -> Rendering -> m a

warn, note :: (MonadParser m, MonadDiagnostic e m) => [Diagnostic e] -> e -> m ()

warnAt, noteAt :: MonadDiagnostic e m => [Diagnostic e] -> e -> Rendering -> m ()

verbose :: (MonadParser m, MonadDiagnostic e m) => Int -> [Diagnostic e] -> e -> m ()

verboseAt :: MonadDiagnostic e m => Int -> [Diagnostic e] -> e -> Rendering -> m ()

Diagnostic Levels

data DiagnosticLevel

The severity of an error (or message)

Constructors

Verbose !Int

a comment we should only show to the excessively curious

Note

a comment

Warning

a warning, computation continues

Error

a user specified error

Fatal

a user specified fatal error

Panic

a non-maskable death sentence thrown by the parser itself

Instances

Eq DiagnosticLevel

Ord DiagnosticLevel

Read DiagnosticLevel

Show DiagnosticLevel

Semigroup DiagnosticLevel

Compute the maximum of two diagnostic levels

Pretty DiagnosticLevel

PrettyTerm DiagnosticLevel

pretty print as a color coded description