    {-# language CPP                    #-}
    {-# language FlexibleContexts       #-}
    {-# language FlexibleInstances      #-}
    {-# language FunctionalDependencies #-}
    {-# language MultiParamTypeClasses  #-}
    {-# language UndecidableInstances   #-}
    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Text.Trifecta.Combinators
    -- Copyright   :  (c) Edward Kmett 2011-2019
    -- License     :  BSD3
    --
    -- Maintainer  :  ekmett@gmail.com
    -- Stability   :  experimental
    -- Portability :  non-portable
    --
    -----------------------------------------------------------------------------
    module Text.Trifecta.Combinators
      ( DeltaParsing(..)
      , sliced
      , careting, careted
      , spanning, spanned
      , fixiting
      , MarkParsing(..)
      ) where

    import Control.Applicative
    import Control.Monad                     (MonadPlus)
    import Control.Monad.Trans.Class
    import Control.Monad.Trans.Identity
    import Control.Monad.Trans.Reader
    import Control.Monad.Trans.RWS.Lazy      as Lazy
    import Control.Monad.Trans.RWS.Strict    as Strict
    import Control.Monad.Trans.State.Lazy    as Lazy
    import Control.Monad.Trans.State.Strict  as Strict
    import Control.Monad.Trans.Writer.Lazy   as Lazy
    import Control.Monad.Trans.Writer.Strict as Strict
    import Data.ByteString                   as Strict hiding (span)
    #if !(MIN_VERSION_base(4,11,0))
    import Data.Semigroup
    #endif
    import Prelude                           hiding (span)

    import Text.Parser.Token
    import Text.Trifecta.Delta
    import Text.Trifecta.Rendering

    -- | This class provides parsers with easy access to:
    --
    -- 1) the current line contents.
    -- 2) the current position as a 'Delta'.
    -- 3) the ability to use 'sliced' on any parser.
    class (MonadPlus m, TokenParsing m) => DeltaParsing m where
      -- | Retrieve the contents of the current line (from the beginning of the line)
      line :: m ByteString

      -- | Retrieve the current position as a 'Delta'.
      position :: m Delta

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

      -- | Retrieve a 'Rendering' of the current line noting this position, but not
      -- placing a 'Caret' there.
      rend :: m Rendering
      rend = Delta -> ByteString -> Rendering
    forall s. Source s => Delta -> s -> Rendering
    rendered (Delta -> ByteString -> Rendering)
    -> m Delta -> m (ByteString -> Rendering)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position m (ByteString -> Rendering) -> m ByteString -> m Rendering
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable rend #-}

      -- | Grab the remainder of the current line
      restOfLine :: m ByteString
      restOfLine = Int -> ByteString -> ByteString
    Strict.drop (Int -> ByteString -> ByteString)
    -> (Delta -> Int) -> Delta -> ByteString -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int64 -> Int) -> (Delta -> Int64) -> Delta -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Delta -> Int64
    columnByte (Delta -> ByteString -> ByteString)
    -> m Delta -> m (ByteString -> ByteString)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position m (ByteString -> ByteString) -> m ByteString -> m ByteString
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable restOfLine #-}

    instance (MonadPlus m, DeltaParsing m) => DeltaParsing (Lazy.StateT s m) where
      line :: StateT s m ByteString
    line = m ByteString -> StateT s m ByteString
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable line #-}
      position :: StateT s m Delta
    position = m Delta -> StateT s m Delta
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
      {-# inlinable position #-}
      slicedWith :: forall a r. (a -> ByteString -> r) -> StateT s m a -> StateT s m r
    slicedWith a -> ByteString -> r
    f (Lazy.StateT s -> m (a, s)
    m) = (s -> m (r, s)) -> StateT s m r
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    Lazy.StateT ((s -> m (r, s)) -> StateT s m r)
    -> (s -> m (r, s)) -> StateT s m r
    forall a b. (a -> b) -> a -> b
    $ \s
    s -> ((a, s) -> ByteString -> (r, s)) -> m (a, s) -> m (r, s)
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith (\(a
    a,s
    s') ByteString
    b -> (a -> ByteString -> r
    f a
    a ByteString
    b, s
    s')) (m (a, s) -> m (r, s)) -> m (a, s) -> m (r, s)
    forall a b. (a -> b) -> a -> b
    $ s -> m (a, s)
    m s
    s
      {-# inlinable slicedWith #-}
      rend :: StateT s m Rendering
    rend = m Rendering -> StateT s m Rendering
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Rendering
    forall (m :: * -> *). DeltaParsing m => m Rendering
    rend
      {-# inlinable rend #-}
      restOfLine :: StateT s m ByteString
    restOfLine = m ByteString -> StateT s m ByteString
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    restOfLine
      {-# inlinable restOfLine #-}

    instance (MonadPlus m, DeltaParsing m) => DeltaParsing (Strict.StateT s m) where
      line :: StateT s m ByteString
    line = m ByteString -> StateT s m ByteString
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable line #-}
      position :: StateT s m Delta
    position = m Delta -> StateT s m Delta
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
      {-# inlinable position #-}
      slicedWith :: forall a r. (a -> ByteString -> r) -> StateT s m a -> StateT s m r
    slicedWith a -> ByteString -> r
    f (Strict.StateT s -> m (a, s)
    m) = (s -> m (r, s)) -> StateT s m r
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    Strict.StateT ((s -> m (r, s)) -> StateT s m r)
    -> (s -> m (r, s)) -> StateT s m r
    forall a b. (a -> b) -> a -> b
    $ \s
    s -> ((a, s) -> ByteString -> (r, s)) -> m (a, s) -> m (r, s)
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith (\(a
    a,s
    s') ByteString
    b -> (a -> ByteString -> r
    f a
    a ByteString
    b, s
    s')) (m (a, s) -> m (r, s)) -> m (a, s) -> m (r, s)
    forall a b. (a -> b) -> a -> b
    $ s -> m (a, s)
    m s
    s
      {-# inlinable slicedWith #-}
      rend :: StateT s m Rendering
    rend = m Rendering -> StateT s m Rendering
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Rendering
    forall (m :: * -> *). DeltaParsing m => m Rendering
    rend
      {-# inlinable rend #-}
      restOfLine :: StateT s m ByteString
    restOfLine = m ByteString -> StateT s m ByteString
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    restOfLine
      {-# inlinable restOfLine #-}

    instance (MonadPlus m, DeltaParsing m) => DeltaParsing (ReaderT e m) where
      line :: ReaderT e m ByteString
    line = m ByteString -> ReaderT e m ByteString
    forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable line #-}
      position :: ReaderT e m Delta
    position = m Delta -> ReaderT e m Delta
    forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
      {-# inlinable position #-}
      slicedWith :: forall a r.
    (a -> ByteString -> r) -> ReaderT e m a -> ReaderT e m r
    slicedWith a -> ByteString -> r
    f (ReaderT e -> m a
    m) = (e -> m r) -> ReaderT e m r
    forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
    ReaderT ((e -> m r) -> ReaderT e m r) -> (e -> m r) -> ReaderT e m r
    forall a b. (a -> b) -> a -> b
    $ (a -> ByteString -> r) -> m a -> m r
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith a -> ByteString -> r
    f (m a -> m r) -> (e -> m a) -> e -> m r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . e -> m a
    m
      {-# inlinable slicedWith #-}
      rend :: ReaderT e m Rendering
    rend = m Rendering -> ReaderT e m Rendering
    forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Rendering
    forall (m :: * -> *). DeltaParsing m => m Rendering
    rend
      {-# inlinable rend #-}
      restOfLine :: ReaderT e m ByteString
    restOfLine = m ByteString -> ReaderT e m ByteString
    forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    restOfLine
      {-# inlinable restOfLine #-}

    instance (MonadPlus m, DeltaParsing m, Monoid w) => DeltaParsing (Strict.WriterT w m) where
      line :: WriterT w m ByteString
    line = m ByteString -> WriterT w m ByteString
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable line #-}
      position :: WriterT w m Delta
    position = m Delta -> WriterT w m Delta
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
      {-# inlinable position #-}
      slicedWith :: forall a r.
    (a -> ByteString -> r) -> WriterT w m a -> WriterT w m r
    slicedWith a -> ByteString -> r
    f (Strict.WriterT m (a, w)
    m) = m (r, w) -> WriterT w m r
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    Strict.WriterT (m (r, w) -> WriterT w m r) -> m (r, w) -> WriterT w m r
    forall a b. (a -> b) -> a -> b
    $ ((a, w) -> ByteString -> (r, w)) -> m (a, w) -> m (r, w)
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith (\(a
    a,w
    s') ByteString
    b -> (a -> ByteString -> r
    f a
    a ByteString
    b, w
    s')) m (a, w)
    m
      {-# inlinable slicedWith #-}
      rend :: WriterT w m Rendering
    rend = m Rendering -> WriterT w m Rendering
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Rendering
    forall (m :: * -> *). DeltaParsing m => m Rendering
    rend
      {-# inlinable rend #-}
      restOfLine :: WriterT w m ByteString
    restOfLine = m ByteString -> WriterT w m ByteString
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    restOfLine
      {-# inlinable restOfLine #-}

    instance (MonadPlus m, DeltaParsing m, Monoid w) => DeltaParsing (Lazy.WriterT w m) where
      line :: WriterT w m ByteString
    line = m ByteString -> WriterT w m ByteString
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable line #-}
      position :: WriterT w m Delta
    position = m Delta -> WriterT w m Delta
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
      {-# inlinable position #-}
      slicedWith :: forall a r.
    (a -> ByteString -> r) -> WriterT w m a -> WriterT w m r
    slicedWith a -> ByteString -> r
    f (Lazy.WriterT m (a, w)
    m) = m (r, w) -> WriterT w m r
    forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
    Lazy.WriterT (m (r, w) -> WriterT w m r) -> m (r, w) -> WriterT w m r
    forall a b. (a -> b) -> a -> b
    $ ((a, w) -> ByteString -> (r, w)) -> m (a, w) -> m (r, w)
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith (\(a
    a,w
    s') ByteString
    b -> (a -> ByteString -> r
    f a
    a ByteString
    b, w
    s')) m (a, w)
    m
      {-# inlinable slicedWith #-}
      rend :: WriterT w m Rendering
    rend = m Rendering -> WriterT w m Rendering
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Rendering
    forall (m :: * -> *). DeltaParsing m => m Rendering
    rend
      {-# inlinable rend #-}
      restOfLine :: WriterT w m ByteString
    restOfLine = m ByteString -> WriterT w m ByteString
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    restOfLine
      {-# inlinable restOfLine #-}

    instance (MonadPlus m, DeltaParsing m, Monoid w) => DeltaParsing (Lazy.RWST r w s m) where
      line :: RWST r w s m ByteString
    line = m ByteString -> RWST r w s m ByteString
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable line #-}
      position :: RWST r w s m Delta
    position = m Delta -> RWST r w s m Delta
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
      {-# inlinable position #-}
      slicedWith :: forall a r.
    (a -> ByteString -> r) -> RWST r w s m a -> RWST r w s m r
    slicedWith a -> ByteString -> r
    f (Lazy.RWST r -> s -> m (a, s, w)
    m) = (r -> s -> m (r, s, w)) -> RWST r w s m r
    forall r w s (m :: * -> *) a.
    (r -> s -> m (a, s, w)) -> RWST r w s m a
    Lazy.RWST ((r -> s -> m (r, s, w)) -> RWST r w s m r)
    -> (r -> s -> m (r, s, w)) -> RWST r w s m r
    forall a b. (a -> b) -> a -> b
    $ \r
    r s
    s -> ((a, s, w) -> ByteString -> (r, s, w))
    -> m (a, s, w) -> m (r, s, w)
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith (\(a
    a,s
    s',w
    w) ByteString
    b -> (a -> ByteString -> r
    f a
    a ByteString
    b, s
    s',w
    w)) (m (a, s, w) -> m (r, s, w)) -> m (a, s, w) -> m (r, s, w)
    forall a b. (a -> b) -> a -> b
    $ r -> s -> m (a, s, w)
    m r
    r s
    s
      {-# inlinable slicedWith #-}
      rend :: RWST r w s m Rendering
    rend = m Rendering -> RWST r w s m Rendering
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Rendering
    forall (m :: * -> *). DeltaParsing m => m Rendering
    rend
      {-# inlinable rend #-}
      restOfLine :: RWST r w s m ByteString
    restOfLine = m ByteString -> RWST r w s m ByteString
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    restOfLine
      {-# inlinable restOfLine #-}

    instance (MonadPlus m, DeltaParsing m, Monoid w) => DeltaParsing (Strict.RWST r w s m) where
      line :: RWST r w s m ByteString
    line = m ByteString -> RWST r w s m ByteString
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable line #-}
      position :: RWST r w s m Delta
    position = m Delta -> RWST r w s m Delta
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
      {-# inlinable position #-}
      slicedWith :: forall a r.
    (a -> ByteString -> r) -> RWST r w s m a -> RWST r w s m r
    slicedWith a -> ByteString -> r
    f (Strict.RWST r -> s -> m (a, s, w)
    m) = (r -> s -> m (r, s, w)) -> RWST r w s m r
    forall r w s (m :: * -> *) a.
    (r -> s -> m (a, s, w)) -> RWST r w s m a
    Strict.RWST ((r -> s -> m (r, s, w)) -> RWST r w s m r)
    -> (r -> s -> m (r, s, w)) -> RWST r w s m r
    forall a b. (a -> b) -> a -> b
    $ \r
    r s
    s -> ((a, s, w) -> ByteString -> (r, s, w))
    -> m (a, s, w) -> m (r, s, w)
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith (\(a
    a,s
    s',w
    w) ByteString
    b -> (a -> ByteString -> r
    f a
    a ByteString
    b, s
    s',w
    w)) (m (a, s, w) -> m (r, s, w)) -> m (a, s, w) -> m (r, s, w)
    forall a b. (a -> b) -> a -> b
    $ r -> s -> m (a, s, w)
    m r
    r s
    s
      {-# inlinable slicedWith #-}
      rend :: RWST r w s m Rendering
    rend = m Rendering -> RWST r w s m Rendering
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Rendering
    forall (m :: * -> *). DeltaParsing m => m Rendering
    rend
      {-# inlinable rend #-}
      restOfLine :: RWST r w s m ByteString
    restOfLine = m ByteString -> RWST r w s m ByteString
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    restOfLine
      {-# inlinable restOfLine #-}

    instance (MonadPlus m, DeltaParsing m) => DeltaParsing (IdentityT m) where
      line :: IdentityT m ByteString
    line = m ByteString -> IdentityT m ByteString
    forall (m :: * -> *) a. Monad m => m a -> IdentityT m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
      {-# inlinable line #-}
      position :: IdentityT m Delta
    position = m Delta -> IdentityT m Delta
    forall (m :: * -> *) a. Monad m => m a -> IdentityT m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
      {-# inlinable position #-}
      slicedWith :: forall a r.
    (a -> ByteString -> r) -> IdentityT m a -> IdentityT m r
    slicedWith a -> ByteString -> r
    f (IdentityT m a
    m) = m r -> IdentityT m r
    forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
    IdentityT (m r -> IdentityT m r) -> m r -> IdentityT m r
    forall a b. (a -> b) -> a -> b
    $ (a -> ByteString -> r) -> m a -> m r
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith a -> ByteString -> r
    f m a
    m
      {-# inlinable slicedWith #-}
      rend :: IdentityT m Rendering
    rend = m Rendering -> IdentityT m Rendering
    forall (m :: * -> *) a. Monad m => m a -> IdentityT m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m Rendering
    forall (m :: * -> *). DeltaParsing m => m Rendering
    rend
      {-# inlinable rend #-}
      restOfLine :: IdentityT m ByteString
    restOfLine = m ByteString -> IdentityT m ByteString
    forall (m :: * -> *) a. Monad m => m a -> IdentityT m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    restOfLine
      {-# inlinable restOfLine #-}

    -- | Run a parser, grabbing all of the text between its start and end points and
    -- discarding the original result
    sliced :: DeltaParsing m => m a -> m ByteString
    sliced :: forall (m :: * -> *) a. DeltaParsing m => m a -> m ByteString
    sliced = (a -> ByteString -> ByteString) -> m a -> m ByteString
    forall a r. (a -> ByteString -> r) -> m a -> m r
    forall (m :: * -> *) a r.
    DeltaParsing m =>
    (a -> ByteString -> r) -> m a -> m r
    slicedWith (\a
    _ ByteString
    bs -> ByteString
    bs)
    {-# inlinable sliced #-}

    -- | Grab a 'Caret' pointing to the current location.
    careting :: DeltaParsing m => m Caret
    careting :: forall (m :: * -> *). DeltaParsing m => m Caret
    careting = Delta -> ByteString -> Caret
    Caret (Delta -> ByteString -> Caret)
    -> m Delta -> m (ByteString -> Caret)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position m (ByteString -> Caret) -> m ByteString -> m Caret
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line
    {-# inlinable careting #-}

    -- | Parse a 'Careted' result. Pointing the 'Caret' to where you start.
    careted :: DeltaParsing m => m a -> m (Careted a)
    careted :: forall (m :: * -> *) a. DeltaParsing m => m a -> m (Careted a)
    careted m a
    p = (\Delta
    m ByteString
    l a
    a -> a
    a a -> Caret -> Careted a
    forall a. a -> Caret -> Careted a
    :^ Delta -> ByteString -> Caret
    Caret Delta
    m ByteString
    l) (Delta -> ByteString -> a -> Careted a)
    -> m Delta -> m (ByteString -> a -> Careted a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position m (ByteString -> a -> Careted a)
    -> m ByteString -> m (a -> Careted a)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line m (a -> Careted a) -> m a -> m (Careted a)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m a
    p
    {-# inlinable careted #-}

    -- | Discard the result of a parse, returning a 'Span' from where we start to
    -- where it ended parsing.
    spanning :: DeltaParsing m => m a -> m Span
    spanning :: forall (m :: * -> *) a. DeltaParsing m => m a -> m Span
    spanning m a
    p = (\Delta
    s ByteString
    l Delta
    e -> Delta -> Delta -> ByteString -> Span
    Span Delta
    s Delta
    e ByteString
    l) (Delta -> ByteString -> Delta -> Span)
    -> m Delta -> m (ByteString -> Delta -> Span)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position m (ByteString -> Delta -> Span)
    -> m ByteString -> m (Delta -> Span)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line m (Delta -> Span) -> m Delta -> m Span
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (m a
    p m a -> m Delta -> m Delta
    forall a b. m a -> m b -> m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position)
    {-# inlinable spanning #-}

    -- | Parse a 'Spanned' result. The 'Span' starts here and runs to the last
    -- position parsed.
    spanned :: DeltaParsing m => m a -> m (Spanned a)
    spanned :: forall (m :: * -> *) a. DeltaParsing m => m a -> m (Spanned a)
    spanned m a
    p = (\Delta
    s ByteString
    l a
    a Delta
    e -> a
    a a -> Span -> Spanned a
    forall a. a -> Span -> Spanned a
    :~ Delta -> Delta -> ByteString -> Span
    Span Delta
    s Delta
    e ByteString
    l) (Delta -> ByteString -> a -> Delta -> Spanned a)
    -> m Delta -> m (ByteString -> a -> Delta -> Spanned a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position m (ByteString -> a -> Delta -> Spanned a)
    -> m ByteString -> m (a -> Delta -> Spanned a)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m ByteString
    forall (m :: * -> *). DeltaParsing m => m ByteString
    line m (a -> Delta -> Spanned a) -> m a -> m (Delta -> Spanned a)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m a
    p m (Delta -> Spanned a) -> m Delta -> m (Spanned a)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m Delta
    forall (m :: * -> *). DeltaParsing m => m Delta
    position
    {-# inlinable spanned #-}

    -- | Grab a fixit.
    fixiting :: DeltaParsing m => m Strict.ByteString -> m Fixit
    fixiting :: forall (m :: * -> *). DeltaParsing m => m ByteString -> m Fixit
    fixiting m ByteString
    p = (\(ByteString
    r :~ Span
    s) -> Span -> ByteString -> Fixit
    Fixit Span
    s ByteString
    r) (Spanned ByteString -> Fixit) -> m (Spanned ByteString) -> m Fixit
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m ByteString -> m (Spanned ByteString)
    forall (m :: * -> *) a. DeltaParsing m => m a -> m (Spanned a)
    spanned m ByteString
    p
    {-# inlinable fixiting #-}

    -- | This class is a refinement of 'DeltaParsing' that adds the ability to mark
    -- your position in the input and return there for further parsing later.
    class (DeltaParsing m, HasDelta d) => MarkParsing d m | m -> d where
      -- | mark the current location so it can be used in constructing a span, or
      -- for later seeking
      mark :: m d
      -- | Seek a previously marked location
      release :: d -> m ()

    instance (MonadPlus m, MarkParsing d m) => MarkParsing d (Lazy.StateT s m) where
      mark :: StateT s m d
    mark = m d -> StateT s m d
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m d
    forall d (m :: * -> *). MarkParsing d m => m d
    mark
      {-# inlinable mark #-}
      release :: d -> StateT s m ()
    release = m () -> StateT s m ()
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> StateT s m ()) -> (d -> m ()) -> d -> StateT s m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> m ()
    forall d (m :: * -> *). MarkParsing d m => d -> m ()
    release
      {-# inlinable release #-}

    instance (MonadPlus m, MarkParsing d m) => MarkParsing d (Strict.StateT s m) where
      mark :: StateT s m d
    mark = m d -> StateT s m d
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m d
    forall d (m :: * -> *). MarkParsing d m => m d
    mark
      {-# inlinable mark #-}
      release :: d -> StateT s m ()
    release = m () -> StateT s m ()
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> StateT s m ()) -> (d -> m ()) -> d -> StateT s m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> m ()
    forall d (m :: * -> *). MarkParsing d m => d -> m ()
    release
      {-# inlinable release #-}

    instance (MonadPlus m, MarkParsing d m) => MarkParsing d (ReaderT e m) where
      mark :: ReaderT e m d
    mark = m d -> ReaderT e m d
    forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m d
    forall d (m :: * -> *). MarkParsing d m => m d
    mark
      {-# inlinable mark #-}
      release :: d -> ReaderT e m ()
    release = m () -> ReaderT e m ()
    forall (m :: * -> *) a. Monad m => m a -> ReaderT e m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> ReaderT e m ()) -> (d -> m ()) -> d -> ReaderT e m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> m ()
    forall d (m :: * -> *). MarkParsing d m => d -> m ()
    release
      {-# inlinable release #-}

    instance (MonadPlus m, MarkParsing d m, Monoid w) => MarkParsing d (Strict.WriterT w m) where
      mark :: WriterT w m d
    mark = m d -> WriterT w m d
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m d
    forall d (m :: * -> *). MarkParsing d m => m d
    mark
      {-# inlinable mark #-}
      release :: d -> WriterT w m ()
    release = m () -> WriterT w m ()
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> WriterT w m ()) -> (d -> m ()) -> d -> WriterT w m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> m ()
    forall d (m :: * -> *). MarkParsing d m => d -> m ()
    release
      {-# inlinable release #-}

    instance (MonadPlus m, MarkParsing d m, Monoid w) => MarkParsing d (Lazy.WriterT w m) where
      mark :: WriterT w m d
    mark = m d -> WriterT w m d
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m d
    forall d (m :: * -> *). MarkParsing d m => m d
    mark
      {-# inlinable mark #-}
      release :: d -> WriterT w m ()
    release = m () -> WriterT w m ()
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> WriterT w m ()) -> (d -> m ()) -> d -> WriterT w m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> m ()
    forall d (m :: * -> *). MarkParsing d m => d -> m ()
    release
      {-# inlinable release #-}

    instance (MonadPlus m, MarkParsing d m, Monoid w) => MarkParsing d (Lazy.RWST r w s m) where
      mark :: RWST r w s m d
    mark = m d -> RWST r w s m d
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m d
    forall d (m :: * -> *). MarkParsing d m => m d
    mark
      {-# inlinable mark #-}
      release :: d -> RWST r w s m ()
    release = m () -> RWST r w s m ()
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> RWST r w s m ()) -> (d -> m ()) -> d -> RWST r w s m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> m ()
    forall d (m :: * -> *). MarkParsing d m => d -> m ()
    release
      {-# inlinable release #-}

    instance (MonadPlus m, MarkParsing d m, Monoid w) => MarkParsing d (Strict.RWST r w s m) where
      mark :: RWST r w s m d
    mark = m d -> RWST r w s m d
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m d
    forall d (m :: * -> *). MarkParsing d m => m d
    mark
      {-# inlinable mark #-}
      release :: d -> RWST r w s m ()
    release = m () -> RWST r w s m ()
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> RWST r w s m ()) -> (d -> m ()) -> d -> RWST r w s m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> m ()
    forall d (m :: * -> *). MarkParsing d m => d -> m ()
    release
      {-# inlinable release #-}

    instance (MonadPlus m, MarkParsing d m) => MarkParsing d (IdentityT m) where
      mark :: IdentityT m d
    mark = m d -> IdentityT m d
    forall (m :: * -> *) a. Monad m => m a -> IdentityT m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m d
    forall d (m :: * -> *). MarkParsing d m => m d
    mark
      {-# inlinable mark #-}
      release :: d -> IdentityT m ()
    release = m () -> IdentityT m ()
    forall (m :: * -> *) a. Monad m => m a -> IdentityT m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> IdentityT m ()) -> (d -> m ()) -> d -> IdentityT m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> m ()
    forall d (m :: * -> *). MarkParsing d m => d -> m ()
    release
      {-# inlinable release #-}