    {-# LANGUAGE CPP                #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveGeneric      #-}

    #include "version-compatibility-macros.h"

    -- | Conversion of the linked-list-like 'SimpleDocStream' to a tree-like
    -- 'SimpleDocTree'.
    module Prettyprinter.Render.Util.SimpleDocTree (

        -- * Type and conversion
        SimpleDocTree(..),
        treeForm,

        -- * Manipulating annotations
        unAnnotateST,
        reAnnotateST,
        alterAnnotationsST,

        -- * Common use case shortcut definitions
        renderSimplyDecorated,
        renderSimplyDecoratedA,
    ) where

    import           Control.Applicative
    import           Data.Text           (Text)
    import qualified Data.Text           as T
    import           Data.Typeable       (Typeable)
    import           GHC.Generics

    import Prettyprinter
    import Prettyprinter.Internal
    import Prettyprinter.Render.Util.Panic

    import qualified Control.Monad.Fail as Fail

    #if !(MONOID_IN_PRELUDE)
    import Data.Monoid (Monoid (..))
    #endif

    #if !(FOLDABLE_TRAVERSABLE_IN_PRELUDE)
    import Data.Foldable    (Foldable (..))
    import Data.Traversable (Traversable (..))
    #endif

    -- $setup
    --
    -- (Definitions for the doctests)
    --
    -- >>> import Prettyprinter hiding ((<>))
    -- >>> import qualified Data.Text.IO as T

    -- | Simplest possible tree-based renderer.
    --
    -- For example, here is a document annotated with @()@, and the behaviour is to
    -- surround annotated regions with »>>>« and »<<<«:
    --
    -- >>> let doc = "hello" <+> annotate () "world" <> "!"
    -- >>> let stdoc = treeForm (layoutPretty defaultLayoutOptions doc)
    -- >>> T.putStrLn (renderSimplyDecorated id (\() x -> ">>>" <> x <> "<<<") stdoc)
    -- hello >>>world<<<!
    renderSimplyDecorated
        :: Monoid out
        => (Text -> out)       -- ^ Render plain 'Text'
        -> (ann -> out -> out) -- ^ How to modify an element with an annotation
        -> SimpleDocTree ann
        -> out
    renderSimplyDecorated :: forall out ann.
    Monoid out =>
    (Text -> out) -> (ann -> out -> out) -> SimpleDocTree ann -> out
    renderSimplyDecorated Text -> out
    text ann -> out -> out
    renderAnn = SimpleDocTree ann -> out
    go
      where
        go :: SimpleDocTree ann -> out
    go = \SimpleDocTree ann
    sdt -> case SimpleDocTree ann
    sdt of
            SimpleDocTree ann
    STEmpty        -> out
    forall a. Monoid a => a
    mempty
            STChar Char
    c       -> Text -> out
    text (Char -> Text
    T.singleton Char
    c)
            STText Int
    _ Text
    t     -> Text -> out
    text Text
    t
            STLine Int
    i       -> Text -> out
    text (Char -> Text
    T.singleton Char
    '\n') out -> out -> out
    forall a. Monoid a => a -> a -> a
    `mappend` Text -> out
    text (Int -> Text
    textSpaces Int
    i)
            STAnn ann
    ann SimpleDocTree ann
    rest -> ann -> out -> out
    renderAnn ann
    ann (SimpleDocTree ann -> out
    go SimpleDocTree ann
    rest)
            STConcat [SimpleDocTree ann]
    xs    -> (SimpleDocTree ann -> out) -> [SimpleDocTree ann] -> out
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap SimpleDocTree ann -> out
    go [SimpleDocTree ann]
    xs
    {-# INLINE renderSimplyDecorated #-}

    -- | Version of 'renderSimplyDecoratedA' that allows for 'Applicative' effects.
    renderSimplyDecoratedA
        :: (Applicative f, Monoid out)
        => (Text -> f out)         -- ^ Render plain 'Text'
        -> (ann -> f out -> f out) -- ^ How to modify an element with an annotation
        -> SimpleDocTree ann
        -> f out
    renderSimplyDecoratedA :: forall (f :: * -> *) out ann.
    (Applicative f, Monoid out) =>
    (Text -> f out)
    -> (ann -> f out -> f out) -> SimpleDocTree ann -> f out
    renderSimplyDecoratedA Text -> f out
    text ann -> f out -> f out
    renderAnn = SimpleDocTree ann -> f out
    go
      where
        go :: SimpleDocTree ann -> f out
    go = \SimpleDocTree ann
    sdt -> case SimpleDocTree ann
    sdt of
            SimpleDocTree ann
    STEmpty        -> out -> f out
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure out
    forall a. Monoid a => a
    mempty
            STChar Char
    c       -> Text -> f out
    text (Char -> Text
    T.singleton Char
    c)
            STText Int
    _ Text
    t     -> Text -> f out
    text Text
    t
            STLine Int
    i       -> Text -> f out
    text (Char -> Text -> Text
    T.cons Char
    '\n' (Int -> Text
    textSpaces Int
    i))
            STAnn ann
    ann SimpleDocTree ann
    rest -> ann -> f out -> f out
    renderAnn ann
    ann (SimpleDocTree ann -> f out
    go SimpleDocTree ann
    rest)
            STConcat [SimpleDocTree ann]
    xs    -> ([out] -> out) -> f [out] -> f out
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [out] -> out
    forall a. Monoid a => [a] -> a
    mconcat ((SimpleDocTree ann -> f out) -> [SimpleDocTree ann] -> f [out]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse SimpleDocTree ann -> f out
    go [SimpleDocTree ann]
    xs)
    {-# INLINE renderSimplyDecoratedA #-}

    -- | A type for parsers of unique results. Token stream »s«, results »a«.
    --
    -- Hand-written to avoid a dependency on a parser lib.
    newtype UniqueParser s a = UniqueParser { forall s a. UniqueParser s a -> s -> Maybe (a, s)
    runParser :: s -> Maybe (a, s) }
      deriving Typeable

    instance Functor (UniqueParser s) where
        fmap :: forall a b. (a -> b) -> UniqueParser s a -> UniqueParser s b
    fmap a -> b
    f (UniqueParser s -> Maybe (a, s)
    mx) = (s -> Maybe (b, s)) -> UniqueParser s b
    forall s a. (s -> Maybe (a, s)) -> UniqueParser s a
    UniqueParser (\s
    s ->
            ((a, s) -> (b, s)) -> Maybe (a, s) -> Maybe (b, s)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\(a
    x,s
    s') -> (a -> b
    f a
    x, s
    s')) (s -> Maybe (a, s)
    mx s
    s))

    instance Applicative (UniqueParser s) where
        pure :: forall a. a -> UniqueParser s a
    pure a
    x = (s -> Maybe (a, s)) -> UniqueParser s a
    forall s a. (s -> Maybe (a, s)) -> UniqueParser s a
    UniqueParser (\s
    rest -> (a, s) -> Maybe (a, s)
    forall a. a -> Maybe a
    Just (a
    x, s
    rest))
        UniqueParser s -> Maybe (a -> b, s)
    mf <*> :: forall a b.
    UniqueParser s (a -> b) -> UniqueParser s a -> UniqueParser s b
    <*> UniqueParser s -> Maybe (a, s)
    mx = (s -> Maybe (b, s)) -> UniqueParser s b
    forall s a. (s -> Maybe (a, s)) -> UniqueParser s a
    UniqueParser (\s
    s -> do
            (a -> b
    f, s
    s') <- s -> Maybe (a -> b, s)
    mf s
    s
            (a
    x, s
    s'') <- s -> Maybe (a, s)
    mx s
    s'
            (b, s) -> Maybe (b, s)
    forall a. a -> Maybe a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (a -> b
    f a
    x, s
    s'') )

    instance Monad (UniqueParser s) where
        UniqueParser s -> Maybe (a, s)
    p >>= :: forall a b.
    UniqueParser s a -> (a -> UniqueParser s b) -> UniqueParser s b
    >>= a -> UniqueParser s b
    f = (s -> Maybe (b, s)) -> UniqueParser s b
    forall s a. (s -> Maybe (a, s)) -> UniqueParser s a
    UniqueParser (\s
    s -> do
            (a
    a', s
    s') <- s -> Maybe (a, s)
    p s
    s
            let UniqueParser s -> Maybe (b, s)
    p' = a -> UniqueParser s b
    f a
    a'
            s -> Maybe (b, s)
    p' s
    s' )

    #if !(APPLICATIVE_MONAD)
        return = pure
    #endif
    #if FAIL_IN_MONAD
        fail = Fail.fail
    #endif

    instance Fail.MonadFail (UniqueParser s) where
        fail :: forall a. String -> UniqueParser s a
    fail String
    _err = UniqueParser s a
    forall a. UniqueParser s a
    forall (f :: * -> *) a. Alternative f => f a
    empty

    instance Alternative (UniqueParser s) where
        empty :: forall a. UniqueParser s a
    empty = (s -> Maybe (a, s)) -> UniqueParser s a
    forall s a. (s -> Maybe (a, s)) -> UniqueParser s a
    UniqueParser (Maybe (a, s) -> s -> Maybe (a, s)
    forall a b. a -> b -> a
    const Maybe (a, s)
    forall a. Maybe a
    forall (f :: * -> *) a. Alternative f => f a
    empty)
        UniqueParser s -> Maybe (a, s)
    p <|> :: forall a. UniqueParser s a -> UniqueParser s a -> UniqueParser s a
    <|> UniqueParser s -> Maybe (a, s)
    q = (s -> Maybe (a, s)) -> UniqueParser s a
    forall s a. (s -> Maybe (a, s)) -> UniqueParser s a
    UniqueParser (\s
    s -> s -> Maybe (a, s)
    p s
    s Maybe (a, s) -> Maybe (a, s) -> Maybe (a, s)
    forall a. Maybe a -> Maybe a -> Maybe a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> s -> Maybe (a, s)
    q s
    s)

    data SimpleDocTok ann
        = TokEmpty
        | TokChar Char
        | TokText !Int Text
        | TokLine Int
        | TokAnnPush ann
        | TokAnnPop
        deriving (SimpleDocTok ann -> SimpleDocTok ann -> Bool
    (SimpleDocTok ann -> SimpleDocTok ann -> Bool)
    -> (SimpleDocTok ann -> SimpleDocTok ann -> Bool)
    -> Eq (SimpleDocTok ann)
    forall ann. Eq ann => SimpleDocTok ann -> SimpleDocTok ann -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall ann. Eq ann => SimpleDocTok ann -> SimpleDocTok ann -> Bool
    == :: SimpleDocTok ann -> SimpleDocTok ann -> Bool
    $c/= :: forall ann. Eq ann => SimpleDocTok ann -> SimpleDocTok ann -> Bool
    /= :: SimpleDocTok ann -> SimpleDocTok ann -> Bool
    Eq, Eq (SimpleDocTok ann)
    Eq (SimpleDocTok ann) =>
    (SimpleDocTok ann -> SimpleDocTok ann -> Ordering)
    -> (SimpleDocTok ann -> SimpleDocTok ann -> Bool)
    -> (SimpleDocTok ann -> SimpleDocTok ann -> Bool)
    -> (SimpleDocTok ann -> SimpleDocTok ann -> Bool)
    -> (SimpleDocTok ann -> SimpleDocTok ann -> Bool)
    -> (SimpleDocTok ann -> SimpleDocTok ann -> SimpleDocTok ann)
    -> (SimpleDocTok ann -> SimpleDocTok ann -> SimpleDocTok ann)
    -> Ord (SimpleDocTok ann)
    SimpleDocTok ann -> SimpleDocTok ann -> Bool
    SimpleDocTok ann -> SimpleDocTok ann -> Ordering
    SimpleDocTok ann -> SimpleDocTok ann -> SimpleDocTok ann
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall ann. Ord ann => Eq (SimpleDocTok ann)
    forall ann. Ord ann => SimpleDocTok ann -> SimpleDocTok ann -> Bool
    forall ann.
    Ord ann =>
    SimpleDocTok ann -> SimpleDocTok ann -> Ordering
    forall ann.
    Ord ann =>
    SimpleDocTok ann -> SimpleDocTok ann -> SimpleDocTok ann
    $ccompare :: forall ann.
    Ord ann =>
    SimpleDocTok ann -> SimpleDocTok ann -> Ordering
    compare :: SimpleDocTok ann -> SimpleDocTok ann -> Ordering
    $c< :: forall ann. Ord ann => SimpleDocTok ann -> SimpleDocTok ann -> Bool
    < :: SimpleDocTok ann -> SimpleDocTok ann -> Bool
    $c<= :: forall ann. Ord ann => SimpleDocTok ann -> SimpleDocTok ann -> Bool
    <= :: SimpleDocTok ann -> SimpleDocTok ann -> Bool
    $c> :: forall ann. Ord ann => SimpleDocTok ann -> SimpleDocTok ann -> Bool
    > :: SimpleDocTok ann -> SimpleDocTok ann -> Bool
    $c>= :: forall ann. Ord ann => SimpleDocTok ann -> SimpleDocTok ann -> Bool
    >= :: SimpleDocTok ann -> SimpleDocTok ann -> Bool
    $cmax :: forall ann.
    Ord ann =>
    SimpleDocTok ann -> SimpleDocTok ann -> SimpleDocTok ann
    max :: SimpleDocTok ann -> SimpleDocTok ann -> SimpleDocTok ann
    $cmin :: forall ann.
    Ord ann =>
    SimpleDocTok ann -> SimpleDocTok ann -> SimpleDocTok ann
    min :: SimpleDocTok ann -> SimpleDocTok ann -> SimpleDocTok ann
    Ord, Int -> SimpleDocTok ann -> ShowS
    [SimpleDocTok ann] -> ShowS
    SimpleDocTok ann -> String
    (Int -> SimpleDocTok ann -> ShowS)
    -> (SimpleDocTok ann -> String)
    -> ([SimpleDocTok ann] -> ShowS)
    -> Show (SimpleDocTok ann)
    forall ann. Show ann => Int -> SimpleDocTok ann -> ShowS
    forall ann. Show ann => [SimpleDocTok ann] -> ShowS
    forall ann. Show ann => SimpleDocTok ann -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall ann. Show ann => Int -> SimpleDocTok ann -> ShowS
    showsPrec :: Int -> SimpleDocTok ann -> ShowS
    $cshow :: forall ann. Show ann => SimpleDocTok ann -> String
    show :: SimpleDocTok ann -> String
    $cshowList :: forall ann. Show ann => [SimpleDocTok ann] -> ShowS
    showList :: [SimpleDocTok ann] -> ShowS
    Show, Typeable)

    -- | A 'SimpleDocStream' is a linked list of different annotated cons cells
    -- ('SText' and then some further 'SimpleDocStream', 'SLine' and then some
    -- further 'SimpleDocStream', …). This format is very suitable as a target for a
    -- layout engine, but not very useful for rendering to a structured format such
    -- as HTML, where we don’t want to do a lookahead until the end of some markup.
    -- These formats benefit from a tree-like structure that explicitly marks its
    -- contents as annotated. 'SimpleDocTree' is that format.
    data SimpleDocTree ann
        = STEmpty
        | STChar Char

        -- | 'Data.Text.length' is /O(n)/, so we cache it in the 'Int' field.
        | STText !Int Text

        -- | @Int@ = indentation level for the (next) line
        | STLine !Int

        -- | Annotate the contained document.
        | STAnn ann (SimpleDocTree ann)

        -- | Horizontal concatenation of multiple documents.
        | STConcat [SimpleDocTree ann]
        deriving (SimpleDocTree ann -> SimpleDocTree ann -> Bool
    (SimpleDocTree ann -> SimpleDocTree ann -> Bool)
    -> (SimpleDocTree ann -> SimpleDocTree ann -> Bool)
    -> Eq (SimpleDocTree ann)
    forall ann.
    Eq ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall ann.
    Eq ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    == :: SimpleDocTree ann -> SimpleDocTree ann -> Bool
    $c/= :: forall ann.
    Eq ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    /= :: SimpleDocTree ann -> SimpleDocTree ann -> Bool
    Eq, Eq (SimpleDocTree ann)
    Eq (SimpleDocTree ann) =>
    (SimpleDocTree ann -> SimpleDocTree ann -> Ordering)
    -> (SimpleDocTree ann -> SimpleDocTree ann -> Bool)
    -> (SimpleDocTree ann -> SimpleDocTree ann -> Bool)
    -> (SimpleDocTree ann -> SimpleDocTree ann -> Bool)
    -> (SimpleDocTree ann -> SimpleDocTree ann -> Bool)
    -> (SimpleDocTree ann -> SimpleDocTree ann -> SimpleDocTree ann)
    -> (SimpleDocTree ann -> SimpleDocTree ann -> SimpleDocTree ann)
    -> Ord (SimpleDocTree ann)
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    SimpleDocTree ann -> SimpleDocTree ann -> Ordering
    SimpleDocTree ann -> SimpleDocTree ann -> SimpleDocTree ann
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall ann. Ord ann => Eq (SimpleDocTree ann)
    forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Ordering
    forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> SimpleDocTree ann
    $ccompare :: forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Ordering
    compare :: SimpleDocTree ann -> SimpleDocTree ann -> Ordering
    $c< :: forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    < :: SimpleDocTree ann -> SimpleDocTree ann -> Bool
    $c<= :: forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    <= :: SimpleDocTree ann -> SimpleDocTree ann -> Bool
    $c> :: forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    > :: SimpleDocTree ann -> SimpleDocTree ann -> Bool
    $c>= :: forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> Bool
    >= :: SimpleDocTree ann -> SimpleDocTree ann -> Bool
    $cmax :: forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> SimpleDocTree ann
    max :: SimpleDocTree ann -> SimpleDocTree ann -> SimpleDocTree ann
    $cmin :: forall ann.
    Ord ann =>
    SimpleDocTree ann -> SimpleDocTree ann -> SimpleDocTree ann
    min :: SimpleDocTree ann -> SimpleDocTree ann -> SimpleDocTree ann
    Ord, Int -> SimpleDocTree ann -> ShowS
    [SimpleDocTree ann] -> ShowS
    SimpleDocTree ann -> String
    (Int -> SimpleDocTree ann -> ShowS)
    -> (SimpleDocTree ann -> String)
    -> ([SimpleDocTree ann] -> ShowS)
    -> Show (SimpleDocTree ann)
    forall ann. Show ann => Int -> SimpleDocTree ann -> ShowS
    forall ann. Show ann => [SimpleDocTree ann] -> ShowS
    forall ann. Show ann => SimpleDocTree ann -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall ann. Show ann => Int -> SimpleDocTree ann -> ShowS
    showsPrec :: Int -> SimpleDocTree ann -> ShowS
    $cshow :: forall ann. Show ann => SimpleDocTree ann -> String
    show :: SimpleDocTree ann -> String
    $cshowList :: forall ann. Show ann => [SimpleDocTree ann] -> ShowS
    showList :: [SimpleDocTree ann] -> ShowS
    Show, (forall x. SimpleDocTree ann -> Rep (SimpleDocTree ann) x)
    -> (forall x. Rep (SimpleDocTree ann) x -> SimpleDocTree ann)
    -> Generic (SimpleDocTree ann)
    forall x. Rep (SimpleDocTree ann) x -> SimpleDocTree ann
    forall x. SimpleDocTree ann -> Rep (SimpleDocTree ann) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall ann x. Rep (SimpleDocTree ann) x -> SimpleDocTree ann
    forall ann x. SimpleDocTree ann -> Rep (SimpleDocTree ann) x
    $cfrom :: forall ann x. SimpleDocTree ann -> Rep (SimpleDocTree ann) x
    from :: forall x. SimpleDocTree ann -> Rep (SimpleDocTree ann) x
    $cto :: forall ann x. Rep (SimpleDocTree ann) x -> SimpleDocTree ann
    to :: forall x. Rep (SimpleDocTree ann) x -> SimpleDocTree ann
    Generic, Typeable)

    -- | Alter the document’s annotations.
    --
    -- This instance makes 'SimpleDocTree' more flexible (because it can be used in
    -- 'Functor'-polymorphic values), but @'fmap'@ is much less readable compared to
    -- using @'reAnnotateST'@ in code that only works for @'SimpleDocTree'@ anyway.
    -- Consider using the latter when the type does not matter.
    instance Functor SimpleDocTree where
        fmap :: forall a b. (a -> b) -> SimpleDocTree a -> SimpleDocTree b
    fmap = (a -> b) -> SimpleDocTree a -> SimpleDocTree b
    forall a b. (a -> b) -> SimpleDocTree a -> SimpleDocTree b
    reAnnotateST

    -- | Get the next token, consuming it in the process.
    nextToken :: UniqueParser (SimpleDocStream ann) (SimpleDocTok ann)
    nextToken :: forall ann. UniqueParser (SimpleDocStream ann) (SimpleDocTok ann)
    nextToken = (SimpleDocStream ann
     -> Maybe (SimpleDocTok ann, SimpleDocStream ann))
    -> UniqueParser (SimpleDocStream ann) (SimpleDocTok ann)
    forall s a. (s -> Maybe (a, s)) -> UniqueParser s a
    UniqueParser (\SimpleDocStream ann
    sds -> case SimpleDocStream ann
    sds of
        SimpleDocStream ann
    SFail             -> Maybe (SimpleDocTok ann, SimpleDocStream ann)
    forall void. void
    panicUncaughtFail
        SimpleDocStream ann
    SEmpty            -> Maybe (SimpleDocTok ann, SimpleDocStream ann)
    forall a. Maybe a
    forall (f :: * -> *) a. Alternative f => f a
    empty
        SChar Char
    c SimpleDocStream ann
    rest      -> (SimpleDocTok ann, SimpleDocStream ann)
    -> Maybe (SimpleDocTok ann, SimpleDocStream ann)
    forall a. a -> Maybe a
    Just (Char -> SimpleDocTok ann
    forall ann. Char -> SimpleDocTok ann
    TokChar Char
    c      , SimpleDocStream ann
    rest)
        SText Int
    l Text
    t SimpleDocStream ann
    rest    -> (SimpleDocTok ann, SimpleDocStream ann)
    -> Maybe (SimpleDocTok ann, SimpleDocStream ann)
    forall a. a -> Maybe a
    Just (Int -> Text -> SimpleDocTok ann
    forall ann. Int -> Text -> SimpleDocTok ann
    TokText Int
    l Text
    t    , SimpleDocStream ann
    rest)
        SLine Int
    i SimpleDocStream ann
    rest      -> (SimpleDocTok ann, SimpleDocStream ann)
    -> Maybe (SimpleDocTok ann, SimpleDocStream ann)
    forall a. a -> Maybe a
    Just (Int -> SimpleDocTok ann
    forall ann. Int -> SimpleDocTok ann
    TokLine Int
    i      , SimpleDocStream ann
    rest)
        SAnnPush ann
    ann SimpleDocStream ann
    rest -> (SimpleDocTok ann, SimpleDocStream ann)
    -> Maybe (SimpleDocTok ann, SimpleDocStream ann)
    forall a. a -> Maybe a
    Just (ann -> SimpleDocTok ann
    forall ann. ann -> SimpleDocTok ann
    TokAnnPush ann
    ann , SimpleDocStream ann
    rest)
        SAnnPop SimpleDocStream ann
    rest      -> (SimpleDocTok ann, SimpleDocStream ann)
    -> Maybe (SimpleDocTok ann, SimpleDocStream ann)
    forall a. a -> Maybe a
    Just (SimpleDocTok ann
    forall ann. SimpleDocTok ann
    TokAnnPop      , SimpleDocStream ann
    rest) )

    sdocToTreeParser :: UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    sdocToTreeParser :: forall ann. UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    sdocToTreeParser = ([SimpleDocTree ann] -> SimpleDocTree ann)
    -> UniqueParser (SimpleDocStream ann) [SimpleDocTree ann]
    -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall a b.
    (a -> b)
    -> UniqueParser (SimpleDocStream ann) a
    -> UniqueParser (SimpleDocStream ann) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [SimpleDocTree ann] -> SimpleDocTree ann
    forall ann. [SimpleDocTree ann] -> SimpleDocTree ann
    wrap (UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    -> UniqueParser (SimpleDocStream ann) [SimpleDocTree ann]
    forall a.
    UniqueParser (SimpleDocStream ann) a
    -> UniqueParser (SimpleDocStream ann) [a]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall ann. UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    contentPiece)

      where

        wrap :: [SimpleDocTree ann] -> SimpleDocTree ann
        wrap :: forall ann. [SimpleDocTree ann] -> SimpleDocTree ann
    wrap = \[SimpleDocTree ann]
    sdts -> case [SimpleDocTree ann]
    sdts of
            []  -> SimpleDocTree ann
    forall ann. SimpleDocTree ann
    STEmpty
            [SimpleDocTree ann
    x] -> SimpleDocTree ann
    x
            [SimpleDocTree ann]
    xs  -> [SimpleDocTree ann] -> SimpleDocTree ann
    forall ann. [SimpleDocTree ann] -> SimpleDocTree ann
    STConcat [SimpleDocTree ann]
    xs

        contentPiece :: UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    contentPiece = UniqueParser (SimpleDocStream ann) (SimpleDocTok ann)
    forall ann. UniqueParser (SimpleDocStream ann) (SimpleDocTok ann)
    nextToken UniqueParser (SimpleDocStream ann) (SimpleDocTok ann)
    -> (SimpleDocTok ann
        -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann))
    -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall a b.
    UniqueParser (SimpleDocStream ann) a
    -> (a -> UniqueParser (SimpleDocStream ann) b)
    -> UniqueParser (SimpleDocStream ann) b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \SimpleDocTok ann
    tok -> case SimpleDocTok ann
    tok of
            SimpleDocTok ann
    TokEmpty       -> SimpleDocTree ann
    -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall a. a -> UniqueParser (SimpleDocStream ann) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SimpleDocTree ann
    forall ann. SimpleDocTree ann
    STEmpty
            TokChar Char
    c      -> SimpleDocTree ann
    -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall a. a -> UniqueParser (SimpleDocStream ann) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Char -> SimpleDocTree ann
    forall ann. Char -> SimpleDocTree ann
    STChar Char
    c)
            TokText Int
    l Text
    t    -> SimpleDocTree ann
    -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall a. a -> UniqueParser (SimpleDocStream ann) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Int -> Text -> SimpleDocTree ann
    forall ann. Int -> Text -> SimpleDocTree ann
    STText Int
    l Text
    t)
            TokLine Int
    i      -> SimpleDocTree ann
    -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall a. a -> UniqueParser (SimpleDocStream ann) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Int -> SimpleDocTree ann
    forall ann. Int -> SimpleDocTree ann
    STLine Int
    i)
            SimpleDocTok ann
    TokAnnPop      -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall a. UniqueParser (SimpleDocStream ann) a
    forall (f :: * -> *) a. Alternative f => f a
    empty
            TokAnnPush ann
    ann -> do SimpleDocTree ann
    annotatedContents <- UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall ann. UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    sdocToTreeParser
                                 SimpleDocTok ann
    TokAnnPop <- UniqueParser (SimpleDocStream ann) (SimpleDocTok ann)
    forall ann. UniqueParser (SimpleDocStream ann) (SimpleDocTok ann)
    nextToken
                                 SimpleDocTree ann
    -> UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall a. a -> UniqueParser (SimpleDocStream ann) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ann -> SimpleDocTree ann -> SimpleDocTree ann
    forall ann. ann -> SimpleDocTree ann -> SimpleDocTree ann
    STAnn ann
    ann SimpleDocTree ann
    annotatedContents)

    -- | Convert a 'SimpleDocStream' to its 'SimpleDocTree' representation.
    treeForm :: SimpleDocStream ann -> SimpleDocTree ann
    treeForm :: forall ann. SimpleDocStream ann -> SimpleDocTree ann
    treeForm SimpleDocStream ann
    sdoc = case UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    -> SimpleDocStream ann
    -> Maybe (SimpleDocTree ann, SimpleDocStream ann)
    forall s a. UniqueParser s a -> s -> Maybe (a, s)
    runParser UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    forall ann. UniqueParser (SimpleDocStream ann) (SimpleDocTree ann)
    sdocToTreeParser SimpleDocStream ann
    sdoc of
        Maybe (SimpleDocTree ann, SimpleDocStream ann)
    Nothing               -> SimpleDocTree ann
    forall void. void
    panicSimpleDocTreeConversionFailed
        Just (SimpleDocTree ann
    sdoct, SimpleDocStream ann
    SEmpty)  -> SimpleDocTree ann
    sdoct
        Just (SimpleDocTree ann
    _, SimpleDocStream ann
    _unconsumed) -> SimpleDocTree ann
    forall void. void
    panicInputNotFullyConsumed

    -- $
    --
    -- >>> :set -XOverloadedStrings
    -- >>> treeForm (layoutPretty defaultLayoutOptions ("lorem" <+> "ipsum" <+> annotate True ("TRUE" <+> annotate False "FALSE") <+> "dolor"))
    -- STConcat [STText 5 "lorem",STChar ' ',STText 5 "ipsum",STChar ' ',STAnn True (STConcat [STText 4 "TRUE",STChar ' ',STAnn False (STText 5 "FALSE")]),STChar ' ',STText 5 "dolor"]

    -- | Remove all annotations. 'unAnnotate' for 'SimpleDocTree'.
    unAnnotateST :: SimpleDocTree ann -> SimpleDocTree xxx
    unAnnotateST :: forall ann xxx. SimpleDocTree ann -> SimpleDocTree xxx
    unAnnotateST = (ann -> [xxx]) -> SimpleDocTree ann -> SimpleDocTree xxx
    forall ann ann'.
    (ann -> [ann']) -> SimpleDocTree ann -> SimpleDocTree ann'
    alterAnnotationsST ([xxx] -> ann -> [xxx]
    forall a b. a -> b -> a
    const [])

    -- | Change the annotation of a document. 'reAnnotate' for 'SimpleDocTree'.
    reAnnotateST :: (ann -> ann') -> SimpleDocTree ann -> SimpleDocTree ann'
    reAnnotateST :: forall a b. (a -> b) -> SimpleDocTree a -> SimpleDocTree b
    reAnnotateST ann -> ann'
    f = (ann -> [ann']) -> SimpleDocTree ann -> SimpleDocTree ann'
    forall ann ann'.
    (ann -> [ann']) -> SimpleDocTree ann -> SimpleDocTree ann'
    alterAnnotationsST (ann' -> [ann']
    forall a. a -> [a]
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ann' -> [ann']) -> (ann -> ann') -> ann -> [ann']
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ann -> ann'
    f)

    -- | Change the annotation of a document to a different annotation, or none at
    -- all. 'alterAnnotations' for 'SimpleDocTree'.
    --
    -- Note that this is as powerful as 'alterAnnotations', allowing one annotation
    -- to become multiple ones, contrary to 'alterAnnotationsS', which cannot do
    -- this.
    alterAnnotationsST :: (ann -> [ann']) -> SimpleDocTree ann -> SimpleDocTree ann'
    alterAnnotationsST :: forall ann ann'.
    (ann -> [ann']) -> SimpleDocTree ann -> SimpleDocTree ann'
    alterAnnotationsST ann -> [ann']
    re = SimpleDocTree ann -> SimpleDocTree ann'
    go
      where
        go :: SimpleDocTree ann -> SimpleDocTree ann'
    go = \SimpleDocTree ann
    sdt -> case SimpleDocTree ann
    sdt of
            SimpleDocTree ann
    STEmpty        -> SimpleDocTree ann'
    forall ann. SimpleDocTree ann
    STEmpty
            STChar Char
    c       -> Char -> SimpleDocTree ann'
    forall ann. Char -> SimpleDocTree ann
    STChar Char
    c
            STText Int
    l Text
    t     -> Int -> Text -> SimpleDocTree ann'
    forall ann. Int -> Text -> SimpleDocTree ann
    STText Int
    l Text
    t
            STLine Int
    i       -> Int -> SimpleDocTree ann'
    forall ann. Int -> SimpleDocTree ann
    STLine Int
    i
            STConcat [SimpleDocTree ann]
    xs    -> [SimpleDocTree ann'] -> SimpleDocTree ann'
    forall ann. [SimpleDocTree ann] -> SimpleDocTree ann
    STConcat ((SimpleDocTree ann -> SimpleDocTree ann')
    -> [SimpleDocTree ann] -> [SimpleDocTree ann']
    forall a b. (a -> b) -> [a] -> [b]
    map SimpleDocTree ann -> SimpleDocTree ann'
    go [SimpleDocTree ann]
    xs)
            STAnn ann
    ann SimpleDocTree ann
    rest -> (ann' -> SimpleDocTree ann' -> SimpleDocTree ann')
    -> SimpleDocTree ann' -> [ann'] -> SimpleDocTree ann'
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    Prelude.foldr ann' -> SimpleDocTree ann' -> SimpleDocTree ann'
    forall ann. ann -> SimpleDocTree ann -> SimpleDocTree ann
    STAnn (SimpleDocTree ann -> SimpleDocTree ann'
    go SimpleDocTree ann
    rest) (ann -> [ann']
    re ann
    ann)

    -- | Collect all annotations from a document.
    instance Foldable SimpleDocTree where
        foldMap :: forall m a. Monoid m => (a -> m) -> SimpleDocTree a -> m
    foldMap a -> m
    f = SimpleDocTree a -> m
    go
          where
            go :: SimpleDocTree a -> m
    go = \SimpleDocTree a
    sdt -> case SimpleDocTree a
    sdt of
                SimpleDocTree a
    STEmpty        -> m
    forall a. Monoid a => a
    mempty
                STChar Char
    _       -> m
    forall a. Monoid a => a
    mempty
                STText Int
    _ Text
    _     -> m
    forall a. Monoid a => a
    mempty
                STLine Int
    _       -> m
    forall a. Monoid a => a
    mempty
                STAnn a
    ann SimpleDocTree a
    rest -> a -> m
    f a
    ann m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` SimpleDocTree a -> m
    go SimpleDocTree a
    rest
                STConcat [SimpleDocTree a]
    xs    -> [m] -> m
    forall a. Monoid a => [a] -> a
    mconcat ((SimpleDocTree a -> m) -> [SimpleDocTree a] -> [m]
    forall a b. (a -> b) -> [a] -> [b]
    map SimpleDocTree a -> m
    go [SimpleDocTree a]
    xs)

    -- | Transform a document based on its annotations, possibly leveraging
    -- 'Applicative' effects.
    instance Traversable SimpleDocTree where
        traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SimpleDocTree a -> f (SimpleDocTree b)
    traverse a -> f b
    f = SimpleDocTree a -> f (SimpleDocTree b)
    go
          where
            go :: SimpleDocTree a -> f (SimpleDocTree b)
    go = \SimpleDocTree a
    sdt -> case SimpleDocTree a
    sdt of
                SimpleDocTree a
    STEmpty        -> SimpleDocTree b -> f (SimpleDocTree b)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SimpleDocTree b
    forall ann. SimpleDocTree ann
    STEmpty
                STChar Char
    c       -> SimpleDocTree b -> f (SimpleDocTree b)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Char -> SimpleDocTree b
    forall ann. Char -> SimpleDocTree ann
    STChar Char
    c)
                STText Int
    l Text
    t     -> SimpleDocTree b -> f (SimpleDocTree b)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Int -> Text -> SimpleDocTree b
    forall ann. Int -> Text -> SimpleDocTree ann
    STText Int
    l Text
    t)
                STLine Int
    i       -> SimpleDocTree b -> f (SimpleDocTree b)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Int -> SimpleDocTree b
    forall ann. Int -> SimpleDocTree ann
    STLine Int
    i)
                STAnn a
    ann SimpleDocTree a
    rest -> b -> SimpleDocTree b -> SimpleDocTree b
    forall ann. ann -> SimpleDocTree ann -> SimpleDocTree ann
    STAnn (b -> SimpleDocTree b -> SimpleDocTree b)
    -> f b -> f (SimpleDocTree b -> SimpleDocTree b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f b
    f a
    ann f (SimpleDocTree b -> SimpleDocTree b)
    -> f (SimpleDocTree b) -> f (SimpleDocTree b)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SimpleDocTree a -> f (SimpleDocTree b)
    go SimpleDocTree a
    rest
                STConcat [SimpleDocTree a]
    xs    -> [SimpleDocTree b] -> SimpleDocTree b
    forall ann. [SimpleDocTree ann] -> SimpleDocTree ann
    STConcat ([SimpleDocTree b] -> SimpleDocTree b)
    -> f [SimpleDocTree b] -> f (SimpleDocTree b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (SimpleDocTree a -> f (SimpleDocTree b))
    -> [SimpleDocTree a] -> f [SimpleDocTree b]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse SimpleDocTree a -> f (SimpleDocTree b)
    go [SimpleDocTree a]
    xs