-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A modern parser combinator library with convenient diagnostics
--   
--   A modern unicode-aware parser combinator library with slicing and
--   Clang-style colored diagnostics
--   
--   Current documentation is available from
--   <a>http://ekmett.github.com/trifecta/</a>.
@package trifecta
@version 0.40

module Text.Trifecta.Diagnostic.Level
data DiagnosticLevel
Verbose :: !Int -> DiagnosticLevel
Note :: DiagnosticLevel
Warning :: DiagnosticLevel
Error :: DiagnosticLevel
Fatal :: DiagnosticLevel
Panic :: DiagnosticLevel
instance Eq DiagnosticLevel
instance Show DiagnosticLevel
instance Read DiagnosticLevel
instance PrettyTerm DiagnosticLevel
instance Pretty DiagnosticLevel
instance Semigroup DiagnosticLevel
instance Ord DiagnosticLevel

module Text.Trifecta.Rope.Bytes
class HasBytes t
bytes :: HasBytes t => t -> Int64
instance (Measured v a, HasBytes v) => HasBytes (FingerTree v a)
instance HasBytes ByteString

module Text.Trifecta.Rope.Delta
data Delta
Columns :: {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> Delta
Tab :: {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> Delta
Lines :: {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> Delta
Directed :: !ByteString -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> Delta
class HasDelta t
delta :: HasDelta t => t -> Delta
nextTab :: Int64 -> Int64
rewind :: Delta -> Delta
near :: (HasDelta s, HasDelta t) => s -> t -> Bool
column :: HasDelta t => t -> Int64
columnByte :: Delta -> Int64
instance Show Delta
instance (Measured v a, HasDelta v) => HasDelta (FingerTree v a)
instance HasDelta ByteString
instance HasDelta Word8
instance HasDelta Char
instance HasDelta Delta
instance Semigroup Delta
instance Monoid Delta
instance Hashable Delta
instance HasBytes Delta
instance PrettyTerm Delta
instance Pretty Delta
instance (HasDelta l, HasDelta r) => HasDelta (Either l r)
instance Ord Delta
instance Eq Delta

module Text.Trifecta.Rope.Prim
data Rope
Rope :: !Delta -> !FingerTree Delta Strand -> Rope
rope :: FingerTree Delta Strand -> Rope
data Strand
Strand :: {-# UNPACK #-} !ByteString -> !Delta -> Strand
LineDirective :: {-# UNPACK #-} !ByteString -> {-# UNPACK #-} !Int64 -> Strand
strand :: ByteString -> Strand
strands :: Rope -> FingerTree Delta Strand

-- | grab a the contents of a rope from a given location up to a newline
grabRest :: Delta -> Rope -> r -> (Delta -> ByteString -> r) -> r

-- | grab a the contents of a rope from a given location up to a newline
grabLine :: Delta -> Rope -> r -> (Delta -> ByteString -> r) -> r
instance Show Strand
instance Show Rope
instance Reducer [Char] Rope
instance Reducer ByteString Rope
instance Reducer Strand Rope
instance Reducer Rope Rope
instance Semigroup Rope
instance Monoid Rope
instance Measured Delta Rope
instance HasDelta Rope
instance HasBytes Rope
instance HasBytes Strand
instance HasDelta Strand
instance Hashable Strand
instance Measured Delta Strand


-- | Interval maps implemented using the <a>FingerTree</a> type, following
--   section 4.8 of
--   
--   <ul>
--   <li>Ralf Hinze and Ross Paterson, "Finger trees: a simple
--   general-purpose data structure", <i>Journal of Functional
--   Programming</i> 16:2 (2006) pp 197-217.
--   <a>http://www.soi.city.ac.uk/~ross/papers/FingerTree.html</a></li>
--   </ul>
--   
--   An amortized running time is given for each operation, with <i>n</i>
--   referring to the size of the priority queue. These bounds hold even in
--   a persistent (shared) setting.
--   
--   <i>Note</i>: Many of these operations have the same names as similar
--   operations on lists in the <a>Prelude</a>. The ambiguity may be
--   resolved using either qualification or the <tt>hiding</tt> clause.
--   
--   Unlike <a>Data.IntervalMap.FingerTree</a>, this version sorts things
--   so that the largest interval from a given point comes first. This way
--   if you have nested intervals, you get the outermost interval before
--   the contained intervals.
module Text.Trifecta.IntervalMap

-- | A closed interval. The lower bound should be less than or equal to the
--   higher bound.
data Interval v
Interval :: v -> v -> Interval v
low :: Interval v -> v
high :: Interval v -> v

-- | Map of closed intervals, possibly with duplicates. The <a>Foldable</a>
--   and <a>Traversable</a> instances process the intervals in
--   lexicographical order.
newtype IntervalMap v a
IntervalMap :: FingerTree (IntInterval v) (Node v a) -> IntervalMap v a
runIntervalMap :: IntervalMap v a -> FingerTree (IntInterval v) (Node v a)

-- | <i>O(1)</i>. Interval map with a single entry.
singleton :: Ord v => Interval v -> a -> IntervalMap v a

-- | <i>O(log n)</i>. Insert an interval into a map. The map may contain
--   duplicate intervals; the new entry will be inserted before any
--   existing entries for the same interval.
insert :: Ord v => v -> v -> a -> IntervalMap v a -> IntervalMap v a

-- | <i>O(k log (n</i>/<i>k))</i>. All intervals that contain the given
--   point, in lexicographical order.
search :: Ord v => v -> IntervalMap v a -> [(Interval v, a)]

-- | <i>O(k log (n</i>/<i>k))</i>. All intervals that intersect with the
--   given interval, in lexicographical order.
intersections :: Ord v => v -> v -> IntervalMap v a -> [(Interval v, a)]

-- | <i>O(k log (n</i>/<i>k))</i>. All intervals that contain the given
--   interval, in lexicographical order.
dominators :: Ord v => v -> v -> IntervalMap v a -> [(Interval v, a)]

-- | <i>O(n)</i>. Add a delta to each interval in the map
offset :: (Ord v, Monoid v) => v -> IntervalMap v a -> IntervalMap v a
data IntInterval v
NoInterval :: IntInterval v
IntInterval :: (Interval v) -> v -> IntInterval v
fromList :: Ord v => [(v, v, a)] -> IntervalMap v a
instance Show v => Show (Interval v)
instance Ord v => Plus (IntervalMap v)
instance Ord v => Alt (IntervalMap v)
instance Ord v => Monoid (IntervalMap v a)
instance Ord v => HasUnion0 (IntervalMap v a)
instance Ord v => HasUnion (IntervalMap v a)
instance Ord v => Measured (IntInterval v) (IntervalMap v a)
instance TraversableWithKey (IntervalMap v)
instance Traversable (IntervalMap v)
instance FoldableWithKey (IntervalMap v)
instance Foldable (IntervalMap v)
instance Keyed (IntervalMap v)
instance Functor (IntervalMap v)
instance Ord v => Measured (IntInterval v) (Node v a)
instance Ord v => Monoid (IntInterval v)
instance TraversableWithKey1 (Node v)
instance Traversable1 (Node v)
instance FoldableWithKey1 (Node v)
instance Foldable1 (Node v)
instance TraversableWithKey (Node v)
instance Traversable (Node v)
instance FoldableWithKey (Node v)
instance Foldable (Node v)
instance Keyed (Node v)
instance Bifunctor Node
instance Functor (Node v)
instance Pointed Interval
instance Traversable1 Interval
instance Foldable1 Interval
instance Traversable Interval
instance Foldable Interval
instance Functor Interval
instance Ord v => Ord (Interval v)
instance Eq v => Eq (Interval v)
instance (Ord v, Monoid v) => Reducer v (Interval v)
instance Ord v => Semigroup (Interval v)

module Text.Trifecta.Highlight.Prim
data Highlight
EscapeCode :: Highlight
Number :: Highlight
Comment :: Highlight
CharLiteral :: Highlight
StringLiteral :: Highlight
Constant :: Highlight
Statement :: Highlight
Special :: Highlight
Symbol :: Highlight
Identifier :: Highlight
ReservedIdentifier :: Highlight
Operator :: Highlight
ReservedOperator :: Highlight
Constructor :: Highlight
ReservedConstructor :: Highlight
ConstructorOperator :: Highlight
ReservedConstructorOperator :: Highlight
type Highlights = IntervalMap Delta Highlight
instance Eq Highlight
instance Ord Highlight
instance Show Highlight
instance Read Highlight
instance Enum Highlight
instance Ix Highlight
instance Bounded Highlight

module Text.Trifecta.Highlight.Class
class Highlightable a
addHighlights :: Highlightable a => Highlights -> a -> a

module Text.Trifecta.Highlight.Effects
highlightEffects :: Highlight -> [ScopedEffect]
pushToken, popToken :: Highlight -> TermDoc
withHighlight :: Highlight -> TermDoc -> TermDoc

module Text.Trifecta.Rope.Highlighted
data HighlightedRope
HighlightedRope :: !Highlights -> {-# UNPACK #-} !Rope -> HighlightedRope
ropeHighlights :: HighlightedRope -> !Highlights
ropeContent :: HighlightedRope -> {-# UNPACK #-} !Rope
instance PrettyTerm HighlightedRope
instance Pretty HighlightedRope
instance ToHtml HighlightedRope
instance Ord (Located a)
instance Eq (Located a)
instance Highlightable HighlightedRope
instance Monoid HighlightedRope
instance Semigroup HighlightedRope
instance HasBytes HighlightedRope
instance HasDelta HighlightedRope

module Text.Trifecta.Highlight.Rendering.HTML

-- | Represents a source file like an HsColour rendered document
data Doc
Doc :: String -> String -> HighlightedRope -> Doc
docTitle :: Doc -> String
docCss :: Doc -> String
docContent :: Doc -> HighlightedRope

-- | <pre>
--   renderHtml $ toHtml $ addHighlights highlightedRope $ doc "Foo.hs"
--   </pre>
doc :: String -> Doc
instance Highlightable Doc
instance ToHtml Doc


-- | Diagnostics rendering
--   
--   The type for Lines will very likely change over time, so we can draw
--   lit up control characters for ^Z, ^[, <a>0xff</a>, etc. this will make
--   for much nicer diagnostics when working with protocols!
module Text.Trifecta.Diagnostic.Rendering.Prim
data Rendering
Rendering :: !Delta -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> (Lines -> Lines) -> (Delta -> Lines -> Lines) -> Rendering
renderingDelta :: Rendering -> !Delta
renderingLineLen :: Rendering -> {-# UNPACK #-} !Int64
renderingLineBytes :: Rendering -> {-# UNPACK #-} !Int64
renderingLine :: Rendering -> Lines -> Lines
renderingOverlays :: Rendering -> Delta -> Lines -> Lines
nullRendering :: Rendering -> Bool
emptyRendering :: Rendering
class Source t
source :: Source t => t -> (Int64, Int64, Lines -> Lines)

-- | create a drawing surface
rendering :: Source s => Delta -> s -> Rendering
class Renderable t
render :: Renderable t => t -> Rendering
data Rendered a
(:@) :: a -> Rendering -> Rendered a
type Lines = Array (Int, Int64) ([ScopedEffect], Char)
draw :: [ScopedEffect] -> Int -> Int64 -> String -> Lines -> Lines
ifNear :: Delta -> (Lines -> Lines) -> Delta -> Lines -> Lines
(.#) :: (Delta -> Lines -> Lines) -> Rendering -> Rendering
instance Show a => Show (Rendered a)
instance Renderable (Rendered a)
instance Traversable1 Rendered
instance Foldable1 Rendered
instance Traversable Rendered
instance Foldable Rendered
instance Bind Rendered
instance Apply Rendered
instance Comonad Rendered
instance Extend Rendered
instance HasBytes (Rendered a)
instance HasDelta (Rendered a)
instance Functor Rendered
instance PrettyTerm Rendering
instance Pretty Rendering
instance Source ByteString
instance Source String
instance Renderable Rendering
instance HasDelta Rendering
instance Monoid Rendering
instance Semigroup Rendering
instance Show Rendering
instance Highlightable Rendering

module Text.Trifecta.Diagnostic.Prim
data Diagnostic m
Diagnostic :: !Either String Rendering -> !DiagnosticLevel -> m -> [Diagnostic m] -> Diagnostic m
tellDiagnostic :: (MonadWriter t m, Reducer (Diagnostic e) t) => Diagnostic e -> m ()
instance Typeable1 Diagnostic
instance Show m => Show (Diagnostic m)
instance Traversable1 Diagnostic
instance Foldable1 Diagnostic
instance Traversable Diagnostic
instance Foldable Diagnostic
instance Functor Diagnostic
instance PrettyTerm m => PrettyTerm (Diagnostic m)
instance Pretty m => Pretty (Diagnostic m)
instance Comonad Diagnostic
instance Extend Diagnostic
instance HasBytes (Diagnostic m)
instance HasDelta (Diagnostic m)
instance Renderable (Diagnostic m)
instance (Typeable m, Show m) => Exception (Diagnostic m)
instance Highlightable (Diagnostic e)

module Text.Trifecta.Diagnostic.Err.Log
data ErrLog e
ErrLog :: !Seq (Diagnostic e) -> !Highlights -> ErrLog e
errLog :: ErrLog e -> !Seq (Diagnostic e)
errHighlights :: ErrLog e -> !Highlights
instance Monoid (ErrLog e)
instance Semigroup (ErrLog e)
instance Plus ErrLog
instance Alt ErrLog
instance Functor ErrLog

module Text.Trifecta.Parser.Result
data Result e a
Success :: !Seq (Diagnostic e) -> a -> Result e a
Failure :: !Seq (Diagnostic e) -> Result e a
instance (Show e, Show a) => Show (Result e a)
instance Alternative (Result e)
instance Plus (Result e)
instance Alt (Result e)
instance Apply (Result e)
instance Applicative (Result e)
instance Traversable (Result e)
instance Foldable (Result e)
instance Bifunctor Result
instance Functor (Result e)
instance (PrettyTerm e, Show a) => PrettyTerm (Result e a)
instance (Pretty e, Show a) => Pretty (Result e a)

module Text.Trifecta.Parser.Step
data Step e a
StepDone :: !Rope -> !Seq (Diagnostic e) -> a -> Step e a
StepFail :: !Rope -> !Seq (Diagnostic e) -> Step e a
StepCont :: !Rope -> (Result e a) -> (Rope -> Step e a) -> Step e a
feed :: Reducer t Rope => t -> Step e r -> Step e r
starve :: Step e a -> Result e a
stepResult :: Rope -> Result e a -> Step e a
instance Bifunctor Step
instance Functor (Step e)
instance (Show e, Show a) => Show (Step e a)


-- | harder, better, faster, stronger...
module Text.Trifecta.Parser.It
data It r a
Pure :: a -> It r a
It :: a -> (r -> It r a) -> It r a
needIt :: a -> (r -> Maybe a) -> It r a
wantIt :: a -> (r -> (# Bool, a #)) -> It r a
simplifyIt :: It r a -> r -> It r a
runIt :: (a -> o) -> (a -> (r -> It r a) -> o) -> It r a -> o

-- | Given a position, go there, and grab the text forward from that point
fillIt :: r -> (Delta -> ByteString -> r) -> Delta -> It Rope r

-- | Return the text of the line that contains a given position
rewindIt :: Delta -> It Rope (Maybe ByteString)
sliceIt :: Delta -> Delta -> It Rope ByteString
stepIt :: It Rope a -> Step e a
instance Comonad (It r)
instance Extend (It r)
instance Bind (It r)
instance Apply (It r)
instance Monad (It r)
instance Zip (It r)
instance Lookup (It r)
instance Indexable (It r)
instance Applicative (It r)
instance Profunctor It
instance Functor (It r)
instance Show a => Show (It r a)

module Text.Trifecta.Diagnostic.Class
class Monad m => MonadDiagnostic e m | m -> e
fatalWith :: MonadDiagnostic e m => [Diagnostic e] -> [Rendering] -> e -> m a
errWith :: MonadDiagnostic e m => [Diagnostic e] -> [Rendering] -> e -> m a
logWith :: MonadDiagnostic e m => DiagnosticLevel -> [Diagnostic e] -> [Rendering] -> e -> m ()
instance MonadDiagnostic e m => MonadDiagnostic e (IdentityT m)
instance (MonadDiagnostic e m, Monoid w) => MonadDiagnostic e (RWST r w s m)
instance (MonadDiagnostic e m, Monoid w) => MonadDiagnostic e (RWST r w s m)
instance (MonadDiagnostic e m, Monoid w) => MonadDiagnostic e (WriterT w m)
instance (MonadDiagnostic e m, Monoid w) => MonadDiagnostic e (WriterT w m)
instance MonadDiagnostic e m => MonadDiagnostic e (ReaderT r m)
instance MonadDiagnostic e m => MonadDiagnostic e (StateT s m)
instance MonadDiagnostic e m => MonadDiagnostic e (StateT s m)

module Text.Trifecta.Diagnostic.Combinators
fatal :: MonadDiagnostic e m => e -> m a
err :: MonadDiagnostic e m => e -> m a
warn :: MonadDiagnostic e m => e -> m ()
note :: MonadDiagnostic e m => e -> m ()
verbose :: MonadDiagnostic e m => Int -> e -> m ()
warnWith :: MonadDiagnostic e m => [Diagnostic e] -> [Rendering] -> e -> m ()
noteWith :: MonadDiagnostic e m => [Diagnostic e] -> [Rendering] -> e -> m ()
verboseWith :: MonadDiagnostic e m => Int -> [Diagnostic e] -> [Rendering] -> e -> m ()

module Text.Trifecta.Diagnostic.Err

-- | unlocated error
data Err e
EmptyErr :: Err e
FailErr :: String -> Err e
PanicErr :: String -> Err e
Err :: [Rendering] -> !DiagnosticLevel -> e -> [Diagnostic e] -> Err e
knownErr :: Err e -> Bool
fatalErr :: Err e -> Bool
instance Show e => Show (Err e)
instance Monoid (Err t)
instance Semigroup (Err t)
instance Plus Err
instance Alt Err
instance Functor Err

module Text.Trifecta.Diagnostic.Err.State
data ErrState e
ErrState :: !Set String -> !Err e -> ErrState e
errExpected :: ErrState e -> !Set String
errMessage :: ErrState e -> !Err e
instance Monoid (ErrState e)
instance Semigroup (ErrState e)
instance Plus ErrState
instance Alt ErrState
instance Functor ErrState


module Text.Trifecta.Parser.Class
class (Alternative m, MonadPlus m) => MonadParser m
try :: MonadParser m => m a -> m a
labels :: MonadParser m => m a -> Set String -> m a
skipMany :: MonadParser m => m a -> m ()
satisfy :: MonadParser m => (Char -> Bool) -> m Char
satisfy8 :: MonadParser m => (Word8 -> Bool) -> m Word8
highlight :: MonadParser m => Highlight -> m a -> m a
liftIt :: MonadParser m => It Rope a -> m a
mark :: MonadParser m => m Delta
unexpected :: (MonadParser m, MonadParser m) => String -> m a
line :: MonadParser m => m ByteString
release :: MonadParser m => Delta -> m ()
satisfyAscii :: MonadParser m => (Char -> Bool) -> m Char

-- | grab the remainder of the current line
restOfLine :: MonadParser m => m ByteString

-- | label a parser with a name
(<?>) :: MonadParser m => m a -> String -> m a
skipping :: MonadParser m => Delta -> m ()

-- | run a parser, grabbing all of the text between its start and end
--   points
slicedWith :: MonadParser m => (a -> ByteString -> r) -> m a -> m r

-- | run a parser, grabbing all of the text between its start and end
--   points and discarding the original result
sliced :: MonadParser m => m a -> m ByteString
rend :: MonadParser m => m Rendering
instance MonadParser m => MonadParser (Yoneda m)
instance MonadParser m => MonadParser (IdentityT m)
instance (MonadParser m, Monoid w) => MonadParser (RWST r w s m)
instance (MonadParser m, Monoid w) => MonadParser (RWST r w s m)
instance (MonadParser m, Monoid w) => MonadParser (WriterT w m)
instance (MonadParser m, Monoid w) => MonadParser (WriterT w m)
instance MonadParser m => MonadParser (ReaderT e m)
instance MonadParser m => MonadParser (StateT s m)
instance MonadParser m => MonadParser (StateT s m)

module Text.Trifecta.Diagnostic.Rendering.Caret

-- | <pre>
--   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; }
--                                      ^
--   </pre>
data Caret
Caret :: !Delta -> {-# UNPACK #-} !ByteString -> Caret
caret :: MonadParser m => m Caret
data Careted a
(:^) :: a -> Caret -> Careted a
careted :: MonadParser m => m a -> m (Careted a)
drawCaret :: Delta -> Delta -> Lines -> Lines
addCaret :: Delta -> Rendering -> Rendering
caretEffects :: [ScopedEffect]
instance Eq Caret
instance Ord Caret
instance Show Caret
instance Eq a => Eq (Careted a)
instance Ord a => Ord (Careted a)
instance Show a => Show (Careted a)
instance Hashable a => Hashable (Careted a)
instance Reducer (Careted a) Rendering
instance Renderable (Careted a)
instance Traversable1 Careted
instance Foldable1 Careted
instance Traversable Careted
instance Foldable Careted
instance Comonad Careted
instance Extend Careted
instance Functor Careted
instance Semigroup Caret
instance Reducer Caret Rendering
instance Renderable Caret
instance HasDelta Caret
instance HasBytes Caret
instance Hashable Caret

module Text.Trifecta.Diagnostic.Rendering.Span
data Span
Span :: !Delta -> !Delta -> {-# UNPACK #-} !ByteString -> Span
span :: MonadParser m => m a -> m Span
data Spanned a
(:~) :: a -> Span -> Spanned a
spanned :: MonadParser m => m a -> m (Spanned a)
spanEffects :: [ScopedEffect]
drawSpan :: Delta -> Delta -> Delta -> Lines -> Lines

-- | <pre>
--   int main(int argc, char ** argv) { int; }
--                                      ^~~
--   </pre>
addSpan :: Delta -> Delta -> Rendering -> Rendering
instance Eq Span
instance Ord Span
instance Show Span
instance Eq a => Eq (Spanned a)
instance Ord a => Ord (Spanned a)
instance Show a => Show (Spanned a)
instance Hashable a => Hashable (Spanned a)
instance Hashable Span
instance Renderable (Spanned a)
instance Reducer (Spanned a) Rendering
instance Traversable1 Spanned
instance Foldable1 Spanned
instance Traversable Spanned
instance Foldable Spanned
instance Bind Spanned
instance Apply Spanned
instance Comonad Spanned
instance Extend Spanned
instance Functor Spanned
instance Reducer Span Rendering
instance Semigroup Span
instance Renderable Span

module Text.Trifecta.Diagnostic.Rendering.Fixit
data Fixit
Fixit :: {-# UNPACK #-} !Span -> {-# UNPACK #-} !ByteString -> Fixit
fixitSpan :: Fixit -> {-# UNPACK #-} !Span
fixitReplacement :: Fixit -> {-# UNPACK #-} !ByteString

-- | <pre>
--   int main(int argc char ** argv) { int; }
--                    ^
--                    ,
--   </pre>
drawFixit :: Delta -> Delta -> String -> Delta -> Lines -> Lines
addFixit :: Delta -> Delta -> String -> Rendering -> Rendering
fixit :: MonadParser m => m ByteString -> m Fixit
instance Eq Fixit
instance Ord Fixit
instance Show Fixit
instance Renderable Fixit
instance Reducer Fixit Rendering
instance Hashable Fixit

module Text.Trifecta.Diagnostic.Rendering
class Renderable t
render :: Renderable t => t -> Rendering
class Source t

-- | create a drawing surface
rendering :: Source s => Delta -> s -> Rendering

-- | <pre>
--   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; }
--                                      ^
--   </pre>
data Caret
Caret :: !Delta -> {-# UNPACK #-} !ByteString -> Caret
data Careted a
(:^) :: a -> Caret -> Careted a
data Span
Span :: !Delta -> !Delta -> {-# UNPACK #-} !ByteString -> Span
data Spanned a
(:~) :: a -> Span -> Spanned a
data Fixit
Fixit :: {-# UNPACK #-} !Span -> {-# UNPACK #-} !ByteString -> Fixit
fixitSpan :: Fixit -> {-# UNPACK #-} !Span
fixitReplacement :: Fixit -> {-# UNPACK #-} !ByteString
data Rendered a
(:@) :: a -> Rendering -> Rendered a


-- | Commonly used generic combinators
module Text.Trifecta.Parser.Combinators

-- | <tt>choice ps</tt> tries to apply the parsers in the list <tt>ps</tt>
--   in order, until one of them succeeds. Returns the value of the
--   succeeding parser.
choice :: Alternative m => [m a] -> m a

-- | <tt>option x p</tt> tries to apply parser <tt>p</tt>. If <tt>p</tt>
--   fails without consuming input, it returns the value <tt>x</tt>,
--   otherwise the value returned by <tt>p</tt>.
--   
--   <pre>
--   priority  = option 0 (do{ d &lt;- digit
--                           ; return (digitToInt d) 
--                           })
--   </pre>
option :: Alternative m => a -> m a -> m a

-- | One or none.
optional :: Alternative f => f a -> f (Maybe a)

-- | <tt>skipOptional p</tt> tries to apply parser <tt>p</tt>. It will
--   parse <tt>p</tt> or nothing. It only fails if <tt>p</tt> fails after
--   consuming input. It discards the result of <tt>p</tt>. (Plays the role
--   of parsec's optional, which conflicts with Applicative's optional)
skipOptional :: Alternative m => m a -> m ()

-- | <tt>between open close p</tt> parses <tt>open</tt>, followed by
--   <tt>p</tt> and <tt>close</tt>. Returns the value returned by
--   <tt>p</tt>.
--   
--   <pre>
--   braces  = between (symbol "{") (symbol "}")
--   </pre>
between :: Applicative m => m bra -> m ket -> m a -> m a

-- | <tt>skipSome p</tt> applies the parser <tt>p</tt> <i>one</i> or more
--   times, skipping its result. (aka skipMany1 in parsec)
skipSome :: MonadParser m => m a -> m ()

-- | One or more.
some :: Alternative f => forall a. f a -> f [a]

-- | Zero or more.
many :: Alternative f => forall a. f a -> f [a]

-- | <tt>sepBy p sep</tt> parses <i>zero</i> or more occurrences of
--   <tt>p</tt>, separated by <tt>sep</tt>. Returns a list of values
--   returned by <tt>p</tt>.
--   
--   <pre>
--   commaSep p  = p `sepBy` (symbol ",")
--   </pre>
sepBy :: Alternative m => m a -> m sep -> m [a]

-- | <tt>sepBy1 p sep</tt> parses <i>one</i> or more occurrences of
--   <tt>p</tt>, separated by <tt>sep</tt>. Returns a list of values
--   returned by <tt>p</tt>.
sepBy1 :: Alternative m => m a -> m sep -> m [a]

-- | <tt>sepEndBy1 p sep</tt> parses <i>one</i> or more occurrences of
--   <tt>p</tt>, separated and optionally ended by <tt>sep</tt>. Returns a
--   list of values returned by <tt>p</tt>.
sepEndBy1 :: Alternative m => m a -> m sep -> m [a]

-- | <tt>sepEndBy p sep</tt> parses <i>zero</i> or more occurrences of
--   <tt>p</tt>, separated and optionally ended by <tt>sep</tt>, ie.
--   haskell style statements. Returns a list of values returned by
--   <tt>p</tt>.
--   
--   <pre>
--   haskellStatements  = haskellStatement `sepEndBy` semi
--   </pre>
sepEndBy :: Alternative m => m a -> m sep -> m [a]

-- | <tt>endBy1 p sep</tt> parses <i>one</i> or more occurrences of
--   <tt>p</tt>, seperated and ended by <tt>sep</tt>. Returns a list of
--   values returned by <tt>p</tt>.
endBy1 :: Alternative m => m a -> m sep -> m [a]

-- | <tt>endBy p sep</tt> parses <i>zero</i> or more occurrences of
--   <tt>p</tt>, seperated and ended by <tt>sep</tt>. Returns a list of
--   values returned by <tt>p</tt>.
--   
--   <pre>
--   cStatements  = cStatement `endBy` semi
--   </pre>
endBy :: Alternative m => m a -> m sep -> m [a]

-- | <tt>count n p</tt> parses <tt>n</tt> occurrences of <tt>p</tt>. If
--   <tt>n</tt> is smaller or equal to zero, the parser equals to
--   <tt>return []</tt>. Returns a list of <tt>n</tt> values returned by
--   <tt>p</tt>.
count :: Applicative m => Int -> m a -> m [a]

-- | <tt>chainl p op x</tt> parser <i>zero</i> or more occurrences of
--   <tt>p</tt>, separated by <tt>op</tt>. Returns a value obtained by a
--   <i>left</i> associative application of all functions returned by
--   <tt>op</tt> to the values returned by <tt>p</tt>. If there are zero
--   occurrences of <tt>p</tt>, the value <tt>x</tt> is returned.
chainl :: Alternative m => m a -> m (a -> a -> a) -> a -> m a

-- | <tt>chainr p op x</tt> parser <i>zero</i> or more occurrences of
--   <tt>p</tt>, separated by <tt>op</tt> Returns a value obtained by a
--   <i>right</i> associative application of all functions returned by
--   <tt>op</tt> to the values returned by <tt>p</tt>. If there are no
--   occurrences of <tt>p</tt>, the value <tt>x</tt> is returned.
chainr :: Alternative m => m a -> m (a -> a -> a) -> a -> m a

-- | <tt>chainl1 p op x</tt> parser <i>one</i> or more occurrences of
--   <tt>p</tt>, separated by <tt>op</tt> Returns a value obtained by a
--   <i>left</i> associative application of all functions returned by
--   <tt>op</tt> to the values returned by <tt>p</tt>. . This parser can
--   for example be used to eliminate left recursion which typically occurs
--   in expression grammars.
--   
--   <pre>
--   expr    = term   `chainl1` addop
--   term    = factor `chainl1` mulop
--   factor  = parens expr &lt;|&gt; integer
--   
--   mulop   =   do{ symbol "*"; return (*)   }
--           &lt;|&gt; do{ symbol "/"; return (div) }
--   
--   addop   =   do{ symbol "+"; return (+) }
--           &lt;|&gt; do{ symbol "-"; return (-) }
--   </pre>
chainl1 :: Alternative m => m a -> m (a -> a -> a) -> m a

-- | <tt>chainr1 p op x</tt> parser <i>one</i> or more occurrences of |p|,
--   separated by <tt>op</tt> Returns a value obtained by a <i>right</i>
--   associative application of all functions returned by <tt>op</tt> to
--   the values returned by <tt>p</tt>.
chainr1 :: Alternative m => m a -> m (a -> a -> a) -> m a

-- | This parser only succeeds at the end of the input. This is not a
--   primitive parser but it is defined using <a>notFollowedBy</a>.
--   
--   <pre>
--   eof  = notFollowedBy anyChar &lt;?&gt; "end of input"
--   </pre>
eof :: MonadParser m => m ()

-- | <tt>manyTill p end</tt> applies parser <tt>p</tt> <i>zero</i> or more
--   times until parser <tt>end</tt> succeeds. Returns the list of values
--   returned by <tt>p</tt>. This parser can be used to scan comments:
--   
--   <pre>
--   simpleComment   = do{ string "&lt;!--"
--                       ; manyTill anyChar (try (string "--&gt;"))
--                       }
--   </pre>
--   
--   Note the overlapping parsers <tt>anyChar</tt> and <tt>string
--   "--&gt;"</tt>, and therefore the use of the <a>try</a> combinator.
manyTill :: (Alternative m, MonadPlus m) => m a -> m end -> m [a]

-- | <tt>notFollowedBy p</tt> only succeeds when parser <tt>p</tt> fails.
--   This parser does not consume any input. This parser can be used to
--   implement the 'longest match' rule. For example, when recognizing
--   keywords (for example <tt>let</tt>), we want to make sure that a
--   keyword is not followed by a legal identifier character, in which case
--   the keyword is actually an identifier (for example <tt>lets</tt>). We
--   can program this behaviour as follows:
--   
--   <pre>
--   keywordLet  = try (do{ string "let"
--                        ; notFollowedBy alphaNum
--                        })
--   </pre>
notFollowedBy :: (MonadParser m, Show a) => m a -> m ()

-- | <tt>lookAhead p</tt> parses <tt>p</tt> without consuming any input.
lookAhead :: MonadParser m => m a -> m a


-- | This module implements permutation parsers. The algorithm is described
--   in:
--   
--   <i>Parsing Permutation Phrases,</i> by Arthur Baars, Andres Loh and
--   Doaitse Swierstra. Published as a functional pearl at the Haskell
--   Workshop 2001.
module Text.Trifecta.Parser.Perm

-- | The type <tt>Perm m a</tt> denotes a permutation parser that, when
--   converted by the <a>permute</a> function, parses using the base
--   parsing monad <tt>m</tt> and returns a value of type <tt>a</tt> on
--   success.
--   
--   Normally, a permutation parser is first build with special operators
--   like (<a>&lt;||&gt;</a>) and than transformed into a normal parser
--   using <a>permute</a>.
data Perm m a

-- | The parser <tt>permute perm</tt> parses a permutation of parser
--   described by <tt>perm</tt>. For example, suppose we want to parse a
--   permutation of: an optional string of <tt>a</tt>'s, the character
--   <tt>b</tt> and an optional <tt>c</tt>. This can be described by:
--   
--   <pre>
--   test  = permute (tuple &lt;$?&gt; ("",some (char 'a'))
--                          &lt;||&gt; char 'b' 
--                          &lt;|?&gt; ('_',char 'c'))
--         where
--           tuple a b c  = (a,b,c)
--   </pre>
permute :: Alternative m => Perm m a -> m a

-- | The expression <tt>perm &lt;||&gt; p</tt> adds parser <tt>p</tt> to
--   the permutation parser <tt>perm</tt>. The parser <tt>p</tt> is not
--   allowed to accept empty input - use the optional combinator
--   (<a>&lt;|?&gt;</a>) instead. Returns a new permutation parser that
--   includes <tt>p</tt>.
(<||>) :: Functor m => Perm m (a -> b) -> m a -> Perm m b

-- | The expression <tt>f &lt;$$&gt; p</tt> creates a fresh permutation
--   parser consisting of parser <tt>p</tt>. The the final result of the
--   permutation parser is the function <tt>f</tt> applied to the return
--   value of <tt>p</tt>. The parser <tt>p</tt> is not allowed to accept
--   empty input - use the optional combinator (<a>&lt;$?&gt;</a>) instead.
--   
--   If the function <tt>f</tt> takes more than one parameter, the type
--   variable <tt>b</tt> is instantiated to a functional type which
--   combines nicely with the adds parser <tt>p</tt> to the
--   (<a>&lt;||&gt;</a>) combinator. This results in stylized code where a
--   permutation parser starts with a combining function <tt>f</tt>
--   followed by the parsers. The function <tt>f</tt> gets its parameters
--   in the order in which the parsers are specified, but actual input can
--   be in any order.
(<$$>) :: Functor m => (a -> b) -> m a -> Perm m b

-- | The expression <tt>perm &lt;||&gt; (x,p)</tt> adds parser <tt>p</tt>
--   to the permutation parser <tt>perm</tt>. The parser <tt>p</tt> is
--   optional - if it can not be applied, the default value <tt>x</tt> will
--   be used instead. Returns a new permutation parser that includes the
--   optional parser <tt>p</tt>.
(<|?>) :: Functor m => Perm m (a -> b) -> (a, m a) -> Perm m b

-- | The expression <tt>f &lt;$?&gt; (x,p)</tt> creates a fresh permutation
--   parser consisting of parser <tt>p</tt>. The the final result of the
--   permutation parser is the function <tt>f</tt> applied to the return
--   value of <tt>p</tt>. The parser <tt>p</tt> is optional - if it can not
--   be applied, the default value <tt>x</tt> will be used instead.
(<$?>) :: Functor m => (a -> b) -> (a, m a) -> Perm m b
instance Functor m => Functor (Branch m)
instance Functor m => Functor (Perm m)


-- | A helper module to parse "expressions". Builds a parser given a table
--   of operators and associativities.
module Text.Trifecta.Parser.Expr

-- | This data type specifies the associativity of operators: left, right
--   or none.
data Assoc
AssocNone :: Assoc
AssocLeft :: Assoc
AssocRight :: Assoc

-- | This data type specifies operators that work on values of type
--   <tt>a</tt>. An operator is either binary infix or unary prefix or
--   postfix. A binary operator has also an associated associativity.
data Operator m a
Infix :: (m (a -> a -> a)) -> Assoc -> Operator m a
Prefix :: (m (a -> a)) -> Operator m a
Postfix :: (m (a -> a)) -> Operator m a

-- | An <tt>OperatorTable m a</tt> is a list of <tt>Operator m a</tt>
--   lists. The list is ordered in descending precedence. All operators in
--   one list have the same precedence (but may have a different
--   associativity).
type OperatorTable m a = [[Operator m a]]

-- | <tt>buildExpressionParser table term</tt> builds an expression parser
--   for terms <tt>term</tt> with operators from <tt>table</tt>, taking the
--   associativity and precedence specified in <tt>table</tt> into account.
--   Prefix and postfix operators of the same precedence can only occur
--   once (i.e. <tt>--2</tt> is not allowed if <tt>-</tt> is prefix
--   negate). Prefix and postfix operators of the same precedence associate
--   to the left (i.e. if <tt>++</tt> is postfix increment, than
--   <tt>-2++</tt> equals <tt>-1</tt>, not <tt>-3</tt>).
--   
--   The <tt>buildExpressionParser</tt> takes care of all the complexity
--   involved in building expression parser. Here is an example of an
--   expression parser that handles prefix signs, postfix increment and
--   basic arithmetic.
--   
--   <pre>
--   expr    = buildExpressionParser table term
--           &lt;?&gt; "expression"
--   
--   term    =  parens expr 
--           &lt;|&gt; natural
--           &lt;?&gt; "simple expression"
--   
--   table   = [ [prefix "-" negate, prefix "+" id ]
--             , [postfix "++" (+1)]
--             , [binary "*" (*) AssocLeft, binary "/" (div) AssocLeft ]
--             , [binary "+" (+) AssocLeft, binary "-" (-)   AssocLeft ]
--             ]
--           
--   binary  name fun assoc = Infix (do{ reservedOp name; return fun }) assoc
--   prefix  name fun       = Prefix (do{ reservedOp name; return fun })
--   postfix name fun       = Postfix (do{ reservedOp name; return fun })
--   </pre>
buildExpressionParser :: MonadParser m => OperatorTable m a -> m a -> m a


module Text.Trifecta.Parser.Token.Class
class MonadParser m => MonadTokenParser m
whiteSpace :: MonadTokenParser m => m ()
lexeme :: MonadTokenParser m => m a -> m a
instance MonadTokenParser m => MonadTokenParser (IdentityT m)
instance (MonadTokenParser m, Monoid w) => MonadTokenParser (RWST r w s m)
instance (MonadTokenParser m, Monoid w) => MonadTokenParser (RWST r w s m)
instance (MonadTokenParser m, Monoid w) => MonadTokenParser (WriterT w m)
instance (MonadTokenParser m, Monoid w) => MonadTokenParser (WriterT w m)
instance MonadTokenParser m => MonadTokenParser (StateT s m)
instance MonadTokenParser m => MonadTokenParser (StateT s m)
instance MonadTokenParser m => MonadTokenParser (ReaderT r m)


module Text.Trifecta.Parser.Prim
data Parser e a
Parser :: (forall r. (a -> ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> (ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> (a -> ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> (ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> Parser e a
unparser :: Parser e a -> forall r. (a -> ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> (ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> (a -> ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> (ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r
why :: Pretty e => (e -> Doc t) -> ErrState e -> Highlights -> Bool -> Delta -> ByteString -> Diagnostic (Doc t)
stepParser :: (Diagnostic e -> Diagnostic t) -> (ErrState e -> Highlights -> Bool -> Delta -> ByteString -> Diagnostic t) -> Parser e a -> ErrLog e -> Bool -> Delta -> ByteString -> Step t a
parseTest :: Show a => Parser String a -> String -> IO ()
manyAccum :: (a -> [a] -> [a]) -> Parser e a -> Parser e [a]
instance MonadParser (Parser e)
instance MonadError (ErrState e) (Parser e)
instance MonadDiagnostic e (Parser e)
instance MonadWriter (ErrLog e) (Parser e)
instance MonadPlus (Parser e)
instance Monad (Parser e)
instance Bind (Parser e)
instance Monoid (Parser e a)
instance Semigroup (Parser e a)
instance Alternative (Parser e)
instance Plus (Parser e)
instance Alt (Parser e)
instance Applicative (Parser e)
instance Apply (Parser e)
instance Functor (Parser e)


-- | Loading a file as a strict bytestring in one step.
module Text.Trifecta.Parser.ByteString

-- | <tt>parseFromFile p filePath</tt> runs a parser <tt>p</tt> on the
--   input read from <tt>filePath</tt> using <tt>ByteString.readFile</tt>.
--   All diagnostic messages emitted over the course of the parse attempt
--   are shown to the user on the console.
--   
--   <pre>
--   main = do
--     result &lt;- parseFromFile numbers "digits.txt"
--     case result of
--       Nothing -&gt; return ()
--       Just a  -&gt; print $ sum a
--   </pre>
parseFromFile :: Show a => Parser String a -> String -> IO (Maybe a)

-- | <tt>parseFromFileEx p filePath</tt> runs a parser <tt>p</tt> on the
--   input read from <tt>filePath</tt> using <tt>ByteString.readFile</tt>.
--   Returns all diagnostic messages emitted over the course of the parse
--   and the answer if the parse was successful.
--   
--   <pre>
--   main = do
--     result &lt;- parseFromFileEx (many number) "digits.txt"
--     case result of
--       Failure xs -&gt; unless (Seq.null xs) $ displayLn xs
--       Success xs a  -&gt; 
--         unless (Seq.null xs) $ displayLn xs
--         print $ sum a
--   </pre>
parseFromFileEx :: Show a => Parser String a -> String -> IO (Result TermDoc a)


-- | Fast set membership tests for byte values, The set representation is
--   unboxed for efficiency and uses a lookup table. This is a fairly
--   minimal API. You probably want to use CharSet.
module Text.Trifecta.ByteSet
newtype ByteSet
ByteSet :: ByteString -> ByteSet
fromList :: [Word8] -> ByteSet

-- | Check the set for membership.
member :: Word8 -> ByteSet -> Bool
instance Eq ByteSet
instance Ord ByteSet
instance Show ByteSet


-- | Fast set membership tests for <a>Char</a> values
--   
--   Stored as a (possibly negated) IntMap and a fast set used for the head
--   byte.
--   
--   The set of valid (possibly negated) head bytes is stored unboxed as a
--   32-byte bytestring-based lookup table.
--   
--   Designed to be imported qualified:
--   
--   <pre>
--   import Text.Trifecta.CharSet (CharSet)
--   import qualified Text.Trifecta.CharSet as CharSet
--   </pre>
module Text.Trifecta.CharSet
data CharSet
CharSet :: !Bool -> {-# UNPACK #-} !ByteSet -> !IntSet -> CharSet
(\\) :: CharSet -> CharSet -> CharSet

-- | <i>O(n)</i> worst case
null :: CharSet -> Bool

-- | <i>O(n)</i>
size :: CharSet -> Int
member :: Char -> CharSet -> Bool
notMember :: Char -> CharSet -> Bool
overlaps :: CharSet -> CharSet -> Bool
isSubsetOf :: CharSet -> CharSet -> Bool
isComplemented :: CharSet -> Bool
build :: (Char -> Bool) -> CharSet
empty :: CharSet
singleton :: Char -> CharSet
full :: CharSet
insert :: Char -> CharSet -> CharSet
delete :: Char -> CharSet -> CharSet
complement :: CharSet -> CharSet
range :: Char -> Char -> CharSet
union :: CharSet -> CharSet -> CharSet
intersection :: CharSet -> CharSet -> CharSet
difference :: CharSet -> CharSet -> CharSet
filter :: (Char -> Bool) -> CharSet -> CharSet
partition :: (Char -> Bool) -> CharSet -> (CharSet, CharSet)
map :: (Char -> Char) -> CharSet -> CharSet
fold :: (Char -> b -> b) -> b -> CharSet -> b
toList :: CharSet -> String
fromList :: String -> CharSet
toAscList :: CharSet -> String
fromAscList :: String -> CharSet
fromDistinctAscList :: String -> CharSet
fromCharSet :: CharSet -> (Bool, IntSet)
toCharSet :: IntSet -> CharSet
toArray :: CharSet -> UArray Char Bool
instance Monoid CharSet
instance Semigroup CharSet
instance Read CharSet
instance Show CharSet
instance Bounded CharSet
instance Ord CharSet
instance Eq CharSet
instance Data CharSet
instance Typeable CharSet


-- | The various character classifications from <a>Data.Char</a> as
--   <a>CharSet</a>s
module Text.Trifecta.CharSet.Common
control, asciiLower, asciiUpper, latin1, ascii, separator, symbol, punctuation, number, mark, letter, octDigit, digit, print, alphaNum, alpha, upper, lower, space :: CharSet


module Text.Trifecta.CharSet.Posix.Ascii
posixAscii :: HashMap String CharSet
lookupPosixAsciiCharSet :: String -> Maybe CharSet
alnum, xdigit, lower, upper, space, punct, word, print, graph, digit, cntrl, blank, ascii, alpha :: CharSet


-- | Provides unicode general categories, which are typically connoted by
--   <tt>p{Ll}</tt> or <tt>p{Modifier_Letter}</tt>. Lookups can be
--   constructed using <tt>categories</tt> or individual character sets can
--   be used directly.
module Text.Trifecta.CharSet.Unicode
data UnicodeCategory
UnicodeCategory :: String -> String -> CharSet -> String -> UnicodeCategory
unicodeCategories :: [UnicodeCategory]
lowercaseLetter, letter, otherLetter, modifierLetter, letterAnd, titlecaseLetter, uppercaseLetter :: CharSet
nonSpacingMark, mark, enclosingMark, spacingCombiningMark :: CharSet
space, separator, paragraphSeparator, lineSeparator :: CharSet
mathSymbol, symbol, otherSymbol, modifierSymbol, currencySymbol :: CharSet
decimalNumber, number, otherNumber, letterNumber :: CharSet
dashPunctuation, punctuation, otherPunctuation, connectorPunctuation, finalQuote, initialQuote, closePunctuation, openPunctuation :: CharSet
control, other, notAssigned, surrogate, privateUse, format :: CharSet
instance Typeable UnicodeCategory
instance Show UnicodeCategory
instance Data UnicodeCategory


-- | Provides unicode general categories, which are typically connoted by
--   <tt>p{Ll}</tt> or <tt>p{Modifier_Letter}</tt>. Lookups can be
--   constructed using <a>categories</a> or individual character sets can
--   be used directly.
--   
--   A case, <tt>_</tt> and <tt>-</tt> insensitive lookup is provided by
--   <a>lookupCategory</a> and can be used to provide behavior similar to
--   that of Perl or PCRE.
module Text.Trifecta.CharSet.Unicode.Category
data Category
Category :: String -> String -> CharSet -> String -> Category
categoryName :: Category -> String
categoryAbbreviation :: Category -> String
categoryCharSet :: Category -> CharSet
categoryDescription :: Category -> String
categories :: [Category]
lookupCategory :: String -> Maybe Category
lookupCategoryCharSet :: String -> Maybe CharSet
lowercaseLetter, letter, otherLetter, modifierLetter, letterAnd, titlecaseLetter, uppercaseLetter :: CharSet
nonSpacingMark, mark, enclosingMark, spacingCombiningMark :: CharSet
space, separator, paragraphSeparator, lineSeparator :: CharSet
mathSymbol, symbol, otherSymbol, modifierSymbol, currencySymbol :: CharSet
decimalNumber, number, otherNumber, letterNumber :: CharSet
dashPunctuation, punctuation, otherPunctuation, connectorPunctuation, finalQuote, initialQuote, closePunctuation, openPunctuation :: CharSet
control, other, notAssigned, surrogate, privateUse, format :: CharSet
instance Typeable Category
instance Show Category
instance Data Category


-- | Provides unicode general categories, which are typically connoted by
--   <tt>p{InBasicLatin}</tt> or <tt>p{InIPA_Extensions}</tt>. Lookups can
--   be constructed using <tt>categories</tt> or individual character sets
--   can be used directly.
module Text.Trifecta.CharSet.Unicode.Block
data Block
Block :: String -> CharSet -> Block
blockName :: Block -> String
blockCharSet :: Block -> CharSet
blocks :: [Block]
lookupBlock :: String -> Maybe Block
lookupBlockCharSet :: String -> Maybe CharSet
basicLatin :: CharSet
latin1Supplement :: CharSet
latinExtendedA :: CharSet
latinExtendedB :: CharSet
ipaExtensions :: CharSet
spacingModifierLetters :: CharSet
combiningDiacriticalMarks :: CharSet
greekAndCoptic :: CharSet
cyrillic :: CharSet
cyrillicSupplementary :: CharSet
armenian :: CharSet
hebrew :: CharSet
arabic :: CharSet
syriac :: CharSet
thaana :: CharSet
devanagari :: CharSet
bengali :: CharSet
gurmukhi :: CharSet
gujarati :: CharSet
oriya :: CharSet
tamil :: CharSet
telugu :: CharSet
kannada :: CharSet
malayalam :: CharSet
sinhala :: CharSet
thai :: CharSet
lao :: CharSet
tibetan :: CharSet
myanmar :: CharSet
georgian :: CharSet
hangulJamo :: CharSet
ethiopic :: CharSet
cherokee :: CharSet
unifiedCanadianAboriginalSyllabics :: CharSet
ogham :: CharSet
runic :: CharSet
tagalog :: CharSet
hanunoo :: CharSet
buhid :: CharSet
tagbanwa :: CharSet
khmer :: CharSet
mongolian :: CharSet
limbu :: CharSet
taiLe :: CharSet
khmerSymbols :: CharSet
phoneticExtensions :: CharSet
latinExtendedAdditional :: CharSet
greekExtended :: CharSet
generalPunctuation :: CharSet
superscriptsAndSubscripts :: CharSet
currencySymbols :: CharSet
combiningDiacriticalMarksForSymbols :: CharSet
letterlikeSymbols :: CharSet
numberForms :: CharSet
arrows :: CharSet
mathematicalOperators :: CharSet
miscellaneousTechnical :: CharSet
controlPictures :: CharSet
opticalCharacterRecognition :: CharSet
enclosedAlphanumerics :: CharSet
boxDrawing :: CharSet
blockElements :: CharSet
geometricShapes :: CharSet
miscellaneousSymbols :: CharSet
dingbats :: CharSet
miscellaneousMathematicalSymbolsA :: CharSet
supplementalArrowsA :: CharSet
braillePatterns :: CharSet
supplementalArrowsB :: CharSet
miscellaneousMathematicalSymbolsB :: CharSet
supplementalMathematicalOperators :: CharSet
miscellaneousSymbolsAndArrows :: CharSet
cjkRadicalsSupplement :: CharSet
kangxiRadicals :: CharSet
ideographicDescriptionCharacters :: CharSet
cjkSymbolsAndPunctuation :: CharSet
hiragana :: CharSet
katakana :: CharSet
bopomofo :: CharSet
hangulCompatibilityJamo :: CharSet
kanbun :: CharSet
bopomofoExtended :: CharSet
katakanaPhoneticExtensions :: CharSet
enclosedCjkLettersAndMonths :: CharSet
cjkCompatibility :: CharSet
cjkUnifiedIdeographsExtensionA :: CharSet
yijingHexagramSymbols :: CharSet
cjkUnifiedIdeographs :: CharSet
yiSyllables :: CharSet
yiRadicals :: CharSet
hangulSyllables :: CharSet
highSurrogates :: CharSet
highPrivateUseSurrogates :: CharSet
lowSurrogates :: CharSet
privateUseArea :: CharSet
cjkCompatibilityIdeographs :: CharSet
alphabeticPresentationForms :: CharSet
arabicPresentationFormsA :: CharSet
variationSelectors :: CharSet
combiningHalfMarks :: CharSet
cjkCompatibilityForms :: CharSet
smallFormVariants :: CharSet
arabicPresentationFormsB :: CharSet
halfwidthAndFullwidthForms :: CharSet
specials :: CharSet
instance Typeable Block
instance Show Block
instance Data Block


module Text.Trifecta.CharSet.Posix.Unicode
posixUnicode :: HashMap String CharSet
lookupPosixUnicodeCharSet :: String -> Maybe CharSet
alnum, xdigit, lower, upper, space, punct, word, print, graph, digit, cntrl, blank, ascii, alpha :: CharSet


module Text.Trifecta.CharSet.Posix
posixAscii :: HashMap String CharSet
lookupPosixAsciiCharSet :: String -> Maybe CharSet
posixUnicode :: HashMap String CharSet
lookupPosixUnicodeCharSet :: String -> Maybe CharSet

module Text.Trifecta.Parser.Char

-- | <tt>oneOf cs</tt> succeeds if the current character is in the supplied
--   list of characters <tt>cs</tt>. Returns the parsed character. See also
--   <a>satisfy</a>.
--   
--   <pre>
--   vowel  = oneOf "aeiou"
--   </pre>
oneOf :: MonadParser m => [Char] -> m Char

-- | As the dual of <a>oneOf</a>, <tt>noneOf cs</tt> succeeds if the
--   current character <i>not</i> in the supplied list of characters
--   <tt>cs</tt>. Returns the parsed character.
--   
--   <pre>
--   consonant = noneOf "aeiou"
--   </pre>
noneOf :: MonadParser m => [Char] -> m Char

-- | <tt>oneOfSet cs</tt> succeeds if the current character is in the
--   supplied set of characters <tt>cs</tt>. Returns the parsed character.
--   See also <a>satisfy</a>.
--   
--   <pre>
--   vowel  = oneOf "aeiou"
--   </pre>
oneOfSet :: MonadParser m => CharSet -> m Char

-- | As the dual of <a>oneOf</a>, <tt>noneOf cs</tt> succeeds if the
--   current character <i>not</i> in the supplied list of characters
--   <tt>cs</tt>. Returns the parsed character.
--   
--   <pre>
--   consonant = noneOf "aeiou"
--   </pre>
noneOfSet :: MonadParser m => CharSet -> m Char

-- | Skips <i>zero</i> or more white space characters. See also
--   <a>skipMany</a> and <tt>whiteSpace</tt>.
spaces :: MonadParser m => m ()

-- | Parses a white space character (any character which satisfies
--   <a>isSpace</a>) Returns the parsed character.
space :: MonadParser m => m Char

-- | Parses a newline character ('\n'). Returns a newline character.
newline :: MonadParser m => m Char

-- | Parses a tab character ('\t'). Returns a tab character.
tab :: MonadParser m => m Char

-- | Parses an upper case letter (a character between 'A' and 'Z'). Returns
--   the parsed character.
upper :: MonadParser m => m Char

-- | Parses a lower case character (a character between 'a' and 'z').
--   Returns the parsed character.
lower :: MonadParser m => m Char

-- | Parses a letter or digit (a character between '0' and '9'). Returns
--   the parsed character.
alphaNum :: MonadParser m => m Char

-- | Parses a letter (an upper case or lower case character). Returns the
--   parsed character.
letter :: MonadParser m => m Char

-- | Parses a digit. Returns the parsed character.
digit :: MonadParser m => m Char

-- | Parses a hexadecimal digit (a digit or a letter between 'a' and 'f' or
--   'A' and 'F'). Returns the parsed character.
hexDigit :: MonadParser m => m Char

-- | Parses an octal digit (a character between '0' and '7'). Returns the
--   parsed character.
octDigit :: MonadParser m => m Char

-- | <tt>char c</tt> parses a single character <tt>c</tt>. Returns the
--   parsed character (i.e. <tt>c</tt>).
--   
--   <pre>
--   semiColon  = char ';'
--   </pre>
char :: MonadParser m => Char -> m Char

-- | <tt>notChar c</tt> parses any single character other than <tt>c</tt>.
--   Returns the parsed character.
--   
--   <pre>
--   semiColon  = char ';'
--   </pre>
notChar :: MonadParser m => Char -> m Char

-- | This parser succeeds for any character. Returns the parsed character.
anyChar :: MonadParser m => m Char

-- | <tt>string s</tt> parses a sequence of characters given by <tt>s</tt>.
--   Returns the parsed string (i.e. <tt>s</tt>).
--   
--   <pre>
--   divOrMod    =   string "div" 
--               &lt;|&gt; string "mod"
--   </pre>
string :: MonadParser m => String -> m String

-- | <tt>byteString s</tt> parses a sequence of bytes given by <tt>s</tt>.
--   Returns the parsed byteString (i.e. <tt>s</tt>).
--   
--   <pre>
--   divOrMod    =   string "div" 
--               &lt;|&gt; string "mod"
--   </pre>
byteString :: MonadParser m => ByteString -> m ByteString


-- | idStyle = haskellIdentifierStyle { styleReserved = ... } identifier =
--   ident haskellIdentifierStyle reserved = reserve haskellIdentifierStyle
module Text.Trifecta.Parser.Token.Identifier
data IdentifierStyle m
IdentifierStyle :: String -> m () -> m () -> HashSet ByteString -> Highlight -> Highlight -> IdentifierStyle m
styleName :: IdentifierStyle m -> String
styleStart :: IdentifierStyle m -> m ()
styleLetter :: IdentifierStyle m -> m ()
styleReserved :: IdentifierStyle m -> HashSet ByteString
styleHighlight :: IdentifierStyle m -> Highlight
styleReservedHighlight :: IdentifierStyle m -> Highlight

-- | parse an non-reserved identifier or symbol
ident :: MonadTokenParser m => IdentifierStyle m -> m ByteString

-- | parse a reserved operator or identifier using a given style
reserve :: MonadTokenParser m => IdentifierStyle m -> String -> m ()

-- | parse a reserved operator or identifier using a given style specified
--   by bytestring
reserveByteString :: MonadTokenParser m => IdentifierStyle m -> ByteString -> m ()


module Text.Trifecta.Parser.Token.Prim

-- | This parser parses a single literal character. Returns the literal
--   character value. This parsers deals correctly with escape sequences.
--   The literal character is parsed according to the grammar rules defined
--   in the Haskell report (which matches most programming languages quite
--   closely).
--   
--   This parser does NOT swallow trailing whitespace.
charLiteral' :: MonadParser m => m Char
characterChar :: MonadParser m => m Char

-- | This parser parses a literal string. Returns the literal string value.
--   This parsers deals correctly with escape sequences and gaps. The
--   literal string is parsed according to the grammar rules defined in the
--   Haskell report (which matches most programming languages quite
--   closely).
--   
--   This parser does NOT swallow trailing whitespace
stringLiteral' :: MonadParser m => m String

-- | This parser parses a natural number (a positive whole number). Returns
--   the value of the number. The number can be specified in
--   <a>decimal</a>, <a>hexadecimal</a> or <a>octal</a>. The number is
--   parsed according to the grammar rules in the Haskell report.
--   
--   This parser does NOT swallow trailing whitespace.
natural' :: MonadParser m => m Integer

-- | This parser parses an integer (a whole number). This parser is like
--   <tt>natural</tt> except that it can be prefixed with sign (i.e. '-' or
--   '+'). Returns the value of the number. The number can be specified in
--   <a>decimal</a>, <a>hexadecimal</a> or <a>octal</a>. The number is
--   parsed according to the grammar rules in the Haskell report.
--   
--   This parser does NOT swallow trailing whitespace.
--   
--   Also, unlike the <tt>integer</tt> parser, this parser does not admit
--   spaces between the sign and the number.
integer' :: MonadParser m => m Integer

-- | This parser parses a floating point value. Returns the value of the
--   number. The number is parsed according to the grammar rules defined in
--   the Haskell report.
--   
--   This parser does NOT swallow trailing whitespace.
double' :: MonadParser m => m Double

-- | This parser parses either <tt>natural</tt> or a <tt>double</tt>.
--   Returns the value of the number. This parsers deals with any overlap
--   in the grammar rules for naturals and floats. The number is parsed
--   according to the grammar rules defined in the Haskell report.
--   
--   This parser does NOT swallow trailing whitespace.
naturalOrDouble' :: MonadParser m => m (Either Integer Double)

-- | Parses a positive whole number in the decimal system. Returns the
--   value of the number.
decimal :: MonadParser m => m Integer

-- | Parses a positive whole number in the hexadecimal system. The number
--   should be prefixed with "x" or "X". Returns the value of the number.
hexadecimal :: MonadParser m => m Integer

-- | Parses a positive whole number in the octal system. The number should
--   be prefixed with "o" or "O". Returns the value of the number.
octal :: MonadParser m => m Integer


module Text.Trifecta.Parser.Token.Combinators

-- | This lexeme parser parses a single literal character. Returns the
--   literal character value. This parsers deals correctly with escape
--   sequences. The literal character is parsed according to the grammar
--   rules defined in the Haskell report (which matches most programming
--   languages quite closely).
charLiteral :: MonadTokenParser m => m Char

-- | This lexeme parser parses a literal string. Returns the literal string
--   value. This parsers deals correctly with escape sequences and gaps.
--   The literal string is parsed according to the grammar rules defined in
--   the Haskell report (which matches most programming languages quite
--   closely).
stringLiteral :: MonadTokenParser m => m String

-- | This lexeme parser parses a natural number (a positive whole number).
--   Returns the value of the number. The number can be specified in
--   <a>decimal</a>, <a>hexadecimal</a> or <a>octal</a>. The number is
--   parsed according to the grammar rules in the Haskell report.
natural :: MonadTokenParser m => m Integer

-- | This lexeme parser parses an integer (a whole number). This parser is
--   like <a>natural</a> except that it can be prefixed with sign (i.e. '-'
--   or '+'). Returns the value of the number. The number can be specified
--   in <a>decimal</a>, <a>hexadecimal</a> or <a>octal</a>. The number is
--   parsed according to the grammar rules in the Haskell report.
integer :: MonadTokenParser m => m Integer

-- | This lexeme parser parses a floating point value. Returns the value of
--   the number. The number is parsed according to the grammar rules
--   defined in the Haskell report.
double :: MonadTokenParser m => m Double

-- | This lexeme parser parses either <a>natural</a> or a <tt>float</tt>.
--   Returns the value of the number. This parsers deals with any overlap
--   in the grammar rules for naturals and floats. The number is parsed
--   according to the grammar rules defined in the Haskell report.
naturalOrDouble :: MonadTokenParser m => m (Either Integer Double)

-- | Lexeme parser <tt>symbol s</tt> parses <a>string</a> <tt>s</tt> and
--   skips trailing white space.
symbol :: MonadTokenParser m => ByteString -> m ByteString

-- | Lexeme parser <tt>symbolic s</tt> parses <a>char</a> <tt>s</tt> and
--   skips trailing white space.
symbolic :: MonadTokenParser m => Char -> m Char

-- | Lexeme parser <tt>parens p</tt> parses <tt>p</tt> enclosed in
--   parenthesis, returning the value of <tt>p</tt>.
parens :: MonadTokenParser m => m a -> m a

-- | Lexeme parser <tt>braces p</tt> parses <tt>p</tt> enclosed in braces
--   ('{' and '}'), returning the value of <tt>p</tt>.
braces :: MonadTokenParser m => m a -> m a

-- | Lexeme parser <tt>angles p</tt> parses <tt>p</tt> enclosed in angle
--   brackets ('&lt;' and '&gt;'), returning the value of <tt>p</tt>.
angles :: MonadTokenParser m => m a -> m a

-- | Lexeme parser <tt>brackets p</tt> parses <tt>p</tt> enclosed in
--   brackets ('[' and ']'), returning the value of <tt>p</tt>.
brackets :: MonadTokenParser m => m a -> m a

-- | Lexeme parser |semi| parses the character ';' and skips any trailing
--   white space. Returns the string ";".
semi :: MonadTokenParser m => m Char

-- | Lexeme parser <tt>comma</tt> parses the character ',' and skips any
--   trailing white space. Returns the string ",".
comma :: MonadTokenParser m => m Char

-- | Lexeme parser <tt>colon</tt> parses the character ':' and skips any
--   trailing white space. Returns the string ":".
colon :: MonadTokenParser m => m Char

-- | Lexeme parser <tt>dot</tt> parses the character '.' and skips any
--   trailing white space. Returns the string ".".
dot :: MonadTokenParser m => m Char

-- | Lexeme parser <tt>semiSep p</tt> parses <i>zero</i> or more
--   occurrences of <tt>p</tt> separated by <a>semi</a>. Returns a list of
--   values returned by <tt>p</tt>.
semiSep :: MonadTokenParser m => m a -> m [a]

-- | Lexeme parser <tt>semiSep1 p</tt> parses <i>one</i> or more
--   occurrences of <tt>p</tt> separated by <a>semi</a>. Returns a list of
--   values returned by <tt>p</tt>.
semiSep1 :: MonadTokenParser m => m a -> m [a]

-- | Lexeme parser <tt>commaSep p</tt> parses <i>zero</i> or more
--   occurrences of <tt>p</tt> separated by <a>comma</a>. Returns a list of
--   values returned by <tt>p</tt>.
commaSep :: MonadTokenParser m => m a -> m [a]

-- | Lexeme parser <tt>commaSep1 p</tt> parses <i>one</i> or more
--   occurrences of <tt>p</tt> separated by <a>comma</a>. Returns a list of
--   values returned by <tt>p</tt>.
commaSep1 :: MonadTokenParser m => m a -> m [a]

module Text.Trifecta.Parser.Token

-- | Parses a positive whole number in the decimal system. Returns the
--   value of the number.
decimal :: MonadParser m => m Integer

-- | Parses a positive whole number in the hexadecimal system. The number
--   should be prefixed with "x" or "X". Returns the value of the number.
hexadecimal :: MonadParser m => m Integer

-- | Parses a positive whole number in the octal system. The number should
--   be prefixed with "o" or "O". Returns the value of the number.
octal :: MonadParser m => m Integer


module Text.Trifecta.Parser.Token.Style
data CommentStyle
CommentStyle :: String -> String -> String -> Bool -> CommentStyle
commentStart :: CommentStyle -> String
commentEnd :: CommentStyle -> String
commentLine :: CommentStyle -> String
commentNesting :: CommentStyle -> Bool
emptyCommentStyle, haskellCommentStyle, javaCommentStyle :: CommentStyle

-- | Use this to easily build the definition of whiteSpace for your
--   MonadTokenParser
buildWhiteSpaceParser :: MonadParser m => CommentStyle -> m ()


module Text.Trifecta.Parser.Token.Identifier.Style
emptyIdents, haskellIdents, haskell98Idents :: MonadTokenParser m => IdentifierStyle m
emptyOps, haskellOps, haskell98Ops :: MonadTokenParser m => IdentifierStyle m


-- | This provides a thin backwards compatibility layer for folks who want
--   to write parsers for languages where characters are bytes and don't
--   need to deal with unicode issues. Diagnostics will still report the
--   correct column number in the absence of high ascii characters but if
--   you have those in your source file, you probably aren't going to want
--   to draw those to the screen anyways.
module Text.Trifecta.Parser.Char8

-- | Using this instead of <tt>Text.Trifecta.Parser.Class.satisfy</tt> you
--   too can time travel back to when men were men and characters fit into
--   8 bits like God intended. It might also be useful when writing lots of
--   fiddly protocol code, where the UTF8 decoding is probably a very bad
--   idea.
satisfy :: MonadParser m => (Char -> Bool) -> m Char

-- | <tt>oneOf cs</tt> succeeds if the current character is in the supplied
--   list of characters <tt>cs</tt>. Returns the parsed character. See also
--   <a>satisfy</a>.
--   
--   <pre>
--   vowel  = oneOf "aeiou"
--   </pre>
oneOf :: MonadParser m => [Char] -> m Char

-- | As the dual of <a>oneOf</a>, <tt>noneOf cs</tt> succeeds if the
--   current character <i>not</i> in the supplied list of characters
--   <tt>cs</tt>. Returns the parsed character.
--   
--   <pre>
--   consonant = noneOf "aeiou"
--   </pre>
noneOf :: MonadParser m => [Char] -> m Char

-- | <tt>oneOfSet cs</tt> succeeds if the current character is in the
--   supplied set of characters <tt>cs</tt>. Returns the parsed character.
--   See also <a>satisfy</a>.
--   
--   <pre>
--   vowel  = oneOf "aeiou"
--   </pre>
oneOfSet :: MonadParser m => ByteSet -> m Char

-- | As the dual of <a>oneOf</a>, <tt>noneOf cs</tt> succeeds if the
--   current character <i>not</i> in the supplied list of characters
--   <tt>cs</tt>. Returns the parsed character.
--   
--   <pre>
--   consonant = noneOf "aeiou"
--   </pre>
noneOfSet :: MonadParser m => ByteSet -> m Char

-- | Skips <i>zero</i> or more white space characters. See also
--   <a>skipMany</a> and <tt>whiteSpace</tt>.
spaces :: MonadParser m => m ()

-- | Parses a white space character (any character which satisfies
--   <a>isSpace</a>) Returns the parsed character.
space :: MonadParser m => m Char

-- | Parses a newline character ('\n'). Returns a newline character.
newline :: MonadParser m => m Char

-- | Parses a tab character ('\t'). Returns a tab character.
tab :: MonadParser m => m Char

-- | Parses an upper case letter (a character between 'A' and 'Z'). Returns
--   the parsed character.
upper :: MonadParser m => m Char

-- | Parses a lower case character (a character between 'a' and 'z').
--   Returns the parsed character.
lower :: MonadParser m => m Char

-- | Parses a letter or digit (a character between '0' and '9'). Returns
--   the parsed character.
alphaNum :: MonadParser m => m Char

-- | Parses a letter (an upper case or lower case character). Returns the
--   parsed character.
letter :: MonadParser m => m Char

-- | Parses a digit. Returns the parsed character.
digit :: MonadParser m => m Char

-- | Parses a hexadecimal digit (a digit or a letter between 'a' and 'f' or
--   'A' and 'F'). Returns the parsed character.
hexDigit :: MonadParser m => m Char

-- | Parses an octal digit (a character between '0' and '7'). Returns the
--   parsed character.
octDigit :: MonadParser m => m Char

-- | <tt>char c</tt> parses a single character <tt>c</tt>. Returns the
--   parsed character (i.e. <tt>c</tt>).
--   
--   <pre>
--   semiColon  = char ';'
--   </pre>
char :: MonadParser m => Char -> m Char

-- | <tt>char c</tt> parses a single character <tt>c</tt>. Returns the
--   parsed character (i.e. <tt>c</tt>).
--   
--   <pre>
--   semiColon  = char ';'
--   </pre>
notChar :: MonadParser m => Char -> m Char

-- | This parser succeeds for any character. Returns the parsed character.
anyChar :: MonadParser m => m Char

-- | <tt>string s</tt> parses a sequence of characters given by <tt>s</tt>.
--   Returns the parsed string (i.e. <tt>s</tt>).
--   
--   <pre>
--   divOrMod    =   string "div" 
--               &lt;|&gt; string "mod"
--   </pre>
string :: MonadParser m => String -> m String

-- | <tt>byteString s</tt> parses a sequence of bytes given by <tt>s</tt>.
--   Returns the parsed byteString (i.e. <tt>s</tt>).
--   
--   <pre>
--   divOrMod    =   string "div" 
--               &lt;|&gt; string "mod"
--   </pre>
byteString :: MonadParser m => ByteString -> m ByteString

module Text.Trifecta.Highlight

module Text.Trifecta.Rope
data Rope
rope :: FingerTree Delta Strand -> Rope
strands :: Rope -> FingerTree Delta Strand
data Strand
Strand :: {-# UNPACK #-} !ByteString -> !Delta -> Strand
LineDirective :: {-# UNPACK #-} !ByteString -> {-# UNPACK #-} !Int64 -> Strand
strand :: ByteString -> Strand
data Delta
Columns :: {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> Delta
Tab :: {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> Delta
Lines :: {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> Delta
Directed :: !ByteString -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Int64 -> Delta
class HasDelta t
delta :: HasDelta t => t -> Delta
class HasBytes t
bytes :: HasBytes t => t -> Int64
data HighlightedRope
HighlightedRope :: !Highlights -> {-# UNPACK #-} !Rope -> HighlightedRope
ropeHighlights :: HighlightedRope -> !Highlights
ropeContent :: HighlightedRope -> {-# UNPACK #-} !Rope

module Text.Trifecta.Parser
caret :: MonadParser m => m Caret
careted :: MonadParser m => m a -> m (Careted a)
span :: MonadParser m => m a -> m Span
spanned :: MonadParser m => m a -> m (Spanned a)
fixit :: MonadParser m => m ByteString -> m Fixit

module Text.Trifecta.Diagnostic
data Diagnostic m
Diagnostic :: !Either String Rendering -> !DiagnosticLevel -> m -> [Diagnostic m] -> Diagnostic m
tellDiagnostic :: (MonadWriter t m, Reducer (Diagnostic e) t) => Diagnostic e -> m ()
class Renderable t
render :: Renderable t => t -> Rendering
class Source t

-- | create a drawing surface
rendering :: Source s => Delta -> s -> Rendering

-- | <pre>
--   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; }
--                                      ^
--   </pre>
data Caret
Caret :: !Delta -> {-# UNPACK #-} !ByteString -> Caret
data Careted a
(:^) :: a -> Caret -> Careted a
data Span
Span :: !Delta -> !Delta -> {-# UNPACK #-} !ByteString -> Span
data Spanned a
(:~) :: a -> Span -> Spanned a
data Fixit
Fixit :: {-# UNPACK #-} !Span -> {-# UNPACK #-} !ByteString -> Fixit
fixitSpan :: Fixit -> {-# UNPACK #-} !Span
fixitReplacement :: Fixit -> {-# UNPACK #-} !ByteString
data Rendered a
(:@) :: a -> Rendering -> Rendered a
class Monad m => MonadDiagnostic e m | m -> e
fatalWith :: MonadDiagnostic e m => [Diagnostic e] -> [Rendering] -> e -> m a
errWith :: MonadDiagnostic e m => [Diagnostic e] -> [Rendering] -> e -> m a
logWith :: MonadDiagnostic e m => DiagnosticLevel -> [Diagnostic e] -> [Rendering] -> e -> m ()
fatal :: MonadDiagnostic e m => e -> m a
err :: MonadDiagnostic e m => e -> m a
warn :: MonadDiagnostic e m => e -> m ()
note :: MonadDiagnostic e m => e -> m ()
verbose :: MonadDiagnostic e m => Int -> e -> m ()
warnWith :: MonadDiagnostic e m => [Diagnostic e] -> [Rendering] -> e -> m ()
noteWith :: MonadDiagnostic e m => [Diagnostic e] -> [Rendering] -> e -> m ()
verboseWith :: MonadDiagnostic e m => Int -> [Diagnostic e] -> [Rendering] -> e -> m ()
data DiagnosticLevel
Verbose :: !Int -> DiagnosticLevel
Note :: DiagnosticLevel
Warning :: DiagnosticLevel
Error :: DiagnosticLevel
Fatal :: DiagnosticLevel
Panic :: DiagnosticLevel

module Text.Trifecta