    {-# LANGUAGE CPP, DeriveTraversable #-}

    -- |
    -- Module      :  Documentation.Haddock.Types
    -- Copyright   :  (c) Simon Marlow      2003-2006,
    --                    David Waern       2006-2009,
    --                    Mateusz Kowalczyk 2013
    -- License     :  BSD-like
    --
    -- Maintainer  :  haddock@projects.haskellorg
    -- Stability   :  experimental
    -- Portability :  portable
    --
    -- Exposes documentation data types used for (some) of Haddock.
    module Documentation.Haddock.Types where

    #if !MIN_VERSION_base(4,8,0)
    import Control.Applicative
    import Data.Foldable
    import Data.Traversable
    #endif

    #if MIN_VERSION_base(4,8,0)
    import Control.Arrow ((***))
    import Data.Bifunctor
    #endif

    #if MIN_VERSION_base(4,10,0)
    import Data.Bifoldable
    import Data.Bitraversable
    #endif

    -- | With the advent of 'Version', we may want to start attaching more
    -- meta-data to comments. We make a structure for this ahead of time
    -- so we don't have to gut half the core each time we want to add such
    -- info.
    data Meta = Meta { Meta -> Maybe Version
    _version :: Maybe Version
                     , Meta -> Maybe Package
    _package :: Maybe Package
                     } deriving (Meta -> Meta -> Bool
    (Meta -> Meta -> Bool) -> (Meta -> Meta -> Bool) -> Eq Meta
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Meta -> Meta -> Bool
    == :: Meta -> Meta -> Bool
    $c/= :: Meta -> Meta -> Bool
    /= :: Meta -> Meta -> Bool
    Eq, Int -> Meta -> ShowS
    [Meta] -> ShowS
    Meta -> Package
    (Int -> Meta -> ShowS)
    -> (Meta -> Package) -> ([Meta] -> ShowS) -> Show Meta
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Meta -> ShowS
    showsPrec :: Int -> Meta -> ShowS
    $cshow :: Meta -> Package
    show :: Meta -> Package
    $cshowList :: [Meta] -> ShowS
    showList :: [Meta] -> ShowS
    Show)

    data MetaDoc mod id =
      MetaDoc { forall mod id. MetaDoc mod id -> Meta
    _meta :: Meta
              , forall mod id. MetaDoc mod id -> DocH mod id
    _doc :: DocH mod id
              } deriving (MetaDoc mod id -> MetaDoc mod id -> Bool
    (MetaDoc mod id -> MetaDoc mod id -> Bool)
    -> (MetaDoc mod id -> MetaDoc mod id -> Bool)
    -> Eq (MetaDoc mod id)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall mod id.
    (Eq id, Eq mod) =>
    MetaDoc mod id -> MetaDoc mod id -> Bool
    $c== :: forall mod id.
    (Eq id, Eq mod) =>
    MetaDoc mod id -> MetaDoc mod id -> Bool
    == :: MetaDoc mod id -> MetaDoc mod id -> Bool
    $c/= :: forall mod id.
    (Eq id, Eq mod) =>
    MetaDoc mod id -> MetaDoc mod id -> Bool
    /= :: MetaDoc mod id -> MetaDoc mod id -> Bool
    Eq, Int -> MetaDoc mod id -> ShowS
    [MetaDoc mod id] -> ShowS
    MetaDoc mod id -> Package
    (Int -> MetaDoc mod id -> ShowS)
    -> (MetaDoc mod id -> Package)
    -> ([MetaDoc mod id] -> ShowS)
    -> Show (MetaDoc mod id)
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    forall mod id.
    (Show id, Show mod) =>
    Int -> MetaDoc mod id -> ShowS
    forall mod id. (Show id, Show mod) => [MetaDoc mod id] -> ShowS
    forall mod id. (Show id, Show mod) => MetaDoc mod id -> Package
    $cshowsPrec :: forall mod id.
    (Show id, Show mod) =>
    Int -> MetaDoc mod id -> ShowS
    showsPrec :: Int -> MetaDoc mod id -> ShowS
    $cshow :: forall mod id. (Show id, Show mod) => MetaDoc mod id -> Package
    show :: MetaDoc mod id -> Package
    $cshowList :: forall mod id. (Show id, Show mod) => [MetaDoc mod id] -> ShowS
    showList :: [MetaDoc mod id] -> ShowS
    Show, (forall a b. (a -> b) -> MetaDoc mod a -> MetaDoc mod b)
    -> (forall a b. a -> MetaDoc mod b -> MetaDoc mod a)
    -> Functor (MetaDoc mod)
    forall a b. a -> MetaDoc mod b -> MetaDoc mod a
    forall a b. (a -> b) -> MetaDoc mod a -> MetaDoc mod b
    forall mod a b. a -> MetaDoc mod b -> MetaDoc mod a
    forall mod a b. (a -> b) -> MetaDoc mod a -> MetaDoc mod b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall mod a b. (a -> b) -> MetaDoc mod a -> MetaDoc mod b
    fmap :: forall a b. (a -> b) -> MetaDoc mod a -> MetaDoc mod b
    $c<$ :: forall mod a b. a -> MetaDoc mod b -> MetaDoc mod a
    <$ :: forall a b. a -> MetaDoc mod b -> MetaDoc mod a
    Functor, (forall m. Monoid m => MetaDoc mod m -> m)
    -> (forall m a. Monoid m => (a -> m) -> MetaDoc mod a -> m)
    -> (forall m a. Monoid m => (a -> m) -> MetaDoc mod a -> m)
    -> (forall a b. (a -> b -> b) -> b -> MetaDoc mod a -> b)
    -> (forall a b. (a -> b -> b) -> b -> MetaDoc mod a -> b)
    -> (forall b a. (b -> a -> b) -> b -> MetaDoc mod a -> b)
    -> (forall b a. (b -> a -> b) -> b -> MetaDoc mod a -> b)
    -> (forall a. (a -> a -> a) -> MetaDoc mod a -> a)
    -> (forall a. (a -> a -> a) -> MetaDoc mod a -> a)
    -> (forall a. MetaDoc mod a -> [a])
    -> (forall a. MetaDoc mod a -> Bool)
    -> (forall a. MetaDoc mod a -> Int)
    -> (forall a. Eq a => a -> MetaDoc mod a -> Bool)
    -> (forall a. Ord a => MetaDoc mod a -> a)
    -> (forall a. Ord a => MetaDoc mod a -> a)
    -> (forall a. Num a => MetaDoc mod a -> a)
    -> (forall a. Num a => MetaDoc mod a -> a)
    -> Foldable (MetaDoc mod)
    forall a. Eq a => a -> MetaDoc mod a -> Bool
    forall a. Num a => MetaDoc mod a -> a
    forall a. Ord a => MetaDoc mod a -> a
    forall m. Monoid m => MetaDoc mod m -> m
    forall a. MetaDoc mod a -> Bool
    forall a. MetaDoc mod a -> Int
    forall a. MetaDoc mod a -> [a]
    forall a. (a -> a -> a) -> MetaDoc mod a -> a
    forall mod a. Eq a => a -> MetaDoc mod a -> Bool
    forall mod a. Num a => MetaDoc mod a -> a
    forall mod a. Ord a => MetaDoc mod a -> a
    forall mod m. Monoid m => MetaDoc mod m -> m
    forall m a. Monoid m => (a -> m) -> MetaDoc mod a -> m
    forall mod a. MetaDoc mod a -> Bool
    forall mod a. MetaDoc mod a -> Int
    forall mod a. MetaDoc mod a -> [a]
    forall b a. (b -> a -> b) -> b -> MetaDoc mod a -> b
    forall a b. (a -> b -> b) -> b -> MetaDoc mod a -> b
    forall mod a. (a -> a -> a) -> MetaDoc mod a -> a
    forall mod m a. Monoid m => (a -> m) -> MetaDoc mod a -> m
    forall mod b a. (b -> a -> b) -> b -> MetaDoc mod a -> b
    forall mod a b. (a -> b -> b) -> b -> MetaDoc mod a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall mod m. Monoid m => MetaDoc mod m -> m
    fold :: forall m. Monoid m => MetaDoc mod m -> m
    $cfoldMap :: forall mod m a. Monoid m => (a -> m) -> MetaDoc mod a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> MetaDoc mod a -> m
    $cfoldMap' :: forall mod m a. Monoid m => (a -> m) -> MetaDoc mod a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> MetaDoc mod a -> m
    $cfoldr :: forall mod a b. (a -> b -> b) -> b -> MetaDoc mod a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> MetaDoc mod a -> b
    $cfoldr' :: forall mod a b. (a -> b -> b) -> b -> MetaDoc mod a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> MetaDoc mod a -> b
    $cfoldl :: forall mod b a. (b -> a -> b) -> b -> MetaDoc mod a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> MetaDoc mod a -> b
    $cfoldl' :: forall mod b a. (b -> a -> b) -> b -> MetaDoc mod a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> MetaDoc mod a -> b
    $cfoldr1 :: forall mod a. (a -> a -> a) -> MetaDoc mod a -> a
    foldr1 :: forall a. (a -> a -> a) -> MetaDoc mod a -> a
    $cfoldl1 :: forall mod a. (a -> a -> a) -> MetaDoc mod a -> a
    foldl1 :: forall a. (a -> a -> a) -> MetaDoc mod a -> a
    $ctoList :: forall mod a. MetaDoc mod a -> [a]
    toList :: forall a. MetaDoc mod a -> [a]
    $cnull :: forall mod a. MetaDoc mod a -> Bool
    null :: forall a. MetaDoc mod a -> Bool
    $clength :: forall mod a. MetaDoc mod a -> Int
    length :: forall a. MetaDoc mod a -> Int
    $celem :: forall mod a. Eq a => a -> MetaDoc mod a -> Bool
    elem :: forall a. Eq a => a -> MetaDoc mod a -> Bool
    $cmaximum :: forall mod a. Ord a => MetaDoc mod a -> a
    maximum :: forall a. Ord a => MetaDoc mod a -> a
    $cminimum :: forall mod a. Ord a => MetaDoc mod a -> a
    minimum :: forall a. Ord a => MetaDoc mod a -> a
    $csum :: forall mod a. Num a => MetaDoc mod a -> a
    sum :: forall a. Num a => MetaDoc mod a -> a
    $cproduct :: forall mod a. Num a => MetaDoc mod a -> a
    product :: forall a. Num a => MetaDoc mod a -> a
    Foldable, Functor (MetaDoc mod)
    Foldable (MetaDoc mod)
    (Functor (MetaDoc mod), Foldable (MetaDoc mod)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> MetaDoc mod a -> f (MetaDoc mod b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        MetaDoc mod (f a) -> f (MetaDoc mod a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> MetaDoc mod a -> m (MetaDoc mod b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        MetaDoc mod (m a) -> m (MetaDoc mod a))
    -> Traversable (MetaDoc mod)
    forall mod. Functor (MetaDoc mod)
    forall mod. Foldable (MetaDoc mod)
    forall mod (m :: * -> *) a.
    Monad m =>
    MetaDoc mod (m a) -> m (MetaDoc mod a)
    forall mod (f :: * -> *) a.
    Applicative f =>
    MetaDoc mod (f a) -> f (MetaDoc mod a)
    forall mod (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MetaDoc mod a -> m (MetaDoc mod b)
    forall mod (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MetaDoc mod a -> f (MetaDoc mod b)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    MetaDoc mod (m a) -> m (MetaDoc mod a)
    forall (f :: * -> *) a.
    Applicative f =>
    MetaDoc mod (f a) -> f (MetaDoc mod a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MetaDoc mod a -> m (MetaDoc mod b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MetaDoc mod a -> f (MetaDoc mod b)
    $ctraverse :: forall mod (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MetaDoc mod a -> f (MetaDoc mod b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MetaDoc mod a -> f (MetaDoc mod b)
    $csequenceA :: forall mod (f :: * -> *) a.
    Applicative f =>
    MetaDoc mod (f a) -> f (MetaDoc mod a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    MetaDoc mod (f a) -> f (MetaDoc mod a)
    $cmapM :: forall mod (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MetaDoc mod a -> m (MetaDoc mod b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MetaDoc mod a -> m (MetaDoc mod b)
    $csequence :: forall mod (m :: * -> *) a.
    Monad m =>
    MetaDoc mod (m a) -> m (MetaDoc mod a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    MetaDoc mod (m a) -> m (MetaDoc mod a)
    Traversable)

    #if MIN_VERSION_base(4,8,0)
    -- | __NOTE__: Only defined for @base >= 4.8.0@
    instance Bifunctor MetaDoc where
      bimap :: forall a b c d. (a -> b) -> (c -> d) -> MetaDoc a c -> MetaDoc b d
    bimap a -> b
    f c -> d
    g (MetaDoc Meta
    m DocH a c
    d) = Meta -> DocH b d -> MetaDoc b d
    forall mod id. Meta -> DocH mod id -> MetaDoc mod id
    MetaDoc Meta
    m ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    d)
    #endif

    #if MIN_VERSION_base(4,10,0)
    -- | __NOTE__: Only defined for @base >= 4.10.0@
    instance Bifoldable MetaDoc where
      bifoldr :: forall a c b.
    (a -> c -> c) -> (b -> c -> c) -> c -> MetaDoc a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z MetaDoc a b
    d = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (MetaDoc a b -> DocH a b
    forall mod id. MetaDoc mod id -> DocH mod id
    _doc MetaDoc a b
    d)

    -- | __NOTE__: Only defined for @base >= 4.10.0@
    instance Bitraversable MetaDoc where
      bitraverse :: forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> MetaDoc a b -> f (MetaDoc c d)
    bitraverse a -> f c
    f b -> f d
    g (MetaDoc Meta
    m DocH a b
    d) = Meta -> DocH c d -> MetaDoc c d
    forall mod id. Meta -> DocH mod id -> MetaDoc mod id
    MetaDoc Meta
    m (DocH c d -> MetaDoc c d) -> f (DocH c d) -> f (MetaDoc c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    d
    #endif

    overDoc :: (DocH a b -> DocH c d) -> MetaDoc a b -> MetaDoc c d
    overDoc :: forall a b c d.
    (DocH a b -> DocH c d) -> MetaDoc a b -> MetaDoc c d
    overDoc DocH a b -> DocH c d
    f MetaDoc a b
    d = MetaDoc a b
    d { _doc = f $ _doc d }

    overDocF :: Functor f => (DocH a b -> f (DocH c d)) -> MetaDoc a b -> f (MetaDoc c d)
    overDocF :: forall (f :: * -> *) a b c d.
    Functor f =>
    (DocH a b -> f (DocH c d)) -> MetaDoc a b -> f (MetaDoc c d)
    overDocF DocH a b -> f (DocH c d)
    f MetaDoc a b
    d = (\DocH c d
    x -> MetaDoc a b
    d { _doc = x }) (DocH c d -> MetaDoc c d) -> f (DocH c d) -> f (MetaDoc c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> DocH a b -> f (DocH c d)
    f (MetaDoc a b -> DocH a b
    forall mod id. MetaDoc mod id -> DocH mod id
    _doc MetaDoc a b
    d)

    type Version = [Int]
    type Package = String

    data Hyperlink id = Hyperlink
      { forall id. Hyperlink id -> Package
    hyperlinkUrl   :: String
      , forall id. Hyperlink id -> Maybe id
    hyperlinkLabel :: Maybe id
      } deriving (Hyperlink id -> Hyperlink id -> Bool
    (Hyperlink id -> Hyperlink id -> Bool)
    -> (Hyperlink id -> Hyperlink id -> Bool) -> Eq (Hyperlink id)
    forall id. Eq id => Hyperlink id -> Hyperlink id -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall id. Eq id => Hyperlink id -> Hyperlink id -> Bool
    == :: Hyperlink id -> Hyperlink id -> Bool
    $c/= :: forall id. Eq id => Hyperlink id -> Hyperlink id -> Bool
    /= :: Hyperlink id -> Hyperlink id -> Bool
    Eq, Int -> Hyperlink id -> ShowS
    [Hyperlink id] -> ShowS
    Hyperlink id -> Package
    (Int -> Hyperlink id -> ShowS)
    -> (Hyperlink id -> Package)
    -> ([Hyperlink id] -> ShowS)
    -> Show (Hyperlink id)
    forall id. Show id => Int -> Hyperlink id -> ShowS
    forall id. Show id => [Hyperlink id] -> ShowS
    forall id. Show id => Hyperlink id -> Package
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall id. Show id => Int -> Hyperlink id -> ShowS
    showsPrec :: Int -> Hyperlink id -> ShowS
    $cshow :: forall id. Show id => Hyperlink id -> Package
    show :: Hyperlink id -> Package
    $cshowList :: forall id. Show id => [Hyperlink id] -> ShowS
    showList :: [Hyperlink id] -> ShowS
    Show, (forall a b. (a -> b) -> Hyperlink a -> Hyperlink b)
    -> (forall a b. a -> Hyperlink b -> Hyperlink a)
    -> Functor Hyperlink
    forall a b. a -> Hyperlink b -> Hyperlink a
    forall a b. (a -> b) -> Hyperlink a -> Hyperlink b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Hyperlink a -> Hyperlink b
    fmap :: forall a b. (a -> b) -> Hyperlink a -> Hyperlink b
    $c<$ :: forall a b. a -> Hyperlink b -> Hyperlink a
    <$ :: forall a b. a -> Hyperlink b -> Hyperlink a
    Functor, (forall m. Monoid m => Hyperlink m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Hyperlink a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Hyperlink a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Hyperlink a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Hyperlink a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Hyperlink a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Hyperlink a -> b)
    -> (forall a. (a -> a -> a) -> Hyperlink a -> a)
    -> (forall a. (a -> a -> a) -> Hyperlink a -> a)
    -> (forall a. Hyperlink a -> [a])
    -> (forall a. Hyperlink a -> Bool)
    -> (forall a. Hyperlink a -> Int)
    -> (forall a. Eq a => a -> Hyperlink a -> Bool)
    -> (forall a. Ord a => Hyperlink a -> a)
    -> (forall a. Ord a => Hyperlink a -> a)
    -> (forall a. Num a => Hyperlink a -> a)
    -> (forall a. Num a => Hyperlink a -> a)
    -> Foldable Hyperlink
    forall a. Eq a => a -> Hyperlink a -> Bool
    forall a. Num a => Hyperlink a -> a
    forall a. Ord a => Hyperlink a -> a
    forall m. Monoid m => Hyperlink m -> m
    forall a. Hyperlink a -> Bool
    forall a. Hyperlink a -> Int
    forall a. Hyperlink a -> [a]
    forall a. (a -> a -> a) -> Hyperlink a -> a
    forall m a. Monoid m => (a -> m) -> Hyperlink a -> m
    forall b a. (b -> a -> b) -> b -> Hyperlink a -> b
    forall a b. (a -> b -> b) -> b -> Hyperlink a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Hyperlink m -> m
    fold :: forall m. Monoid m => Hyperlink m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Hyperlink a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Hyperlink a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Hyperlink a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Hyperlink a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Hyperlink a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Hyperlink a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Hyperlink a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Hyperlink a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Hyperlink a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Hyperlink a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Hyperlink a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Hyperlink a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Hyperlink a -> a
    foldr1 :: forall a. (a -> a -> a) -> Hyperlink a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Hyperlink a -> a
    foldl1 :: forall a. (a -> a -> a) -> Hyperlink a -> a
    $ctoList :: forall a. Hyperlink a -> [a]
    toList :: forall a. Hyperlink a -> [a]
    $cnull :: forall a. Hyperlink a -> Bool
    null :: forall a. Hyperlink a -> Bool
    $clength :: forall a. Hyperlink a -> Int
    length :: forall a. Hyperlink a -> Int
    $celem :: forall a. Eq a => a -> Hyperlink a -> Bool
    elem :: forall a. Eq a => a -> Hyperlink a -> Bool
    $cmaximum :: forall a. Ord a => Hyperlink a -> a
    maximum :: forall a. Ord a => Hyperlink a -> a
    $cminimum :: forall a. Ord a => Hyperlink a -> a
    minimum :: forall a. Ord a => Hyperlink a -> a
    $csum :: forall a. Num a => Hyperlink a -> a
    sum :: forall a. Num a => Hyperlink a -> a
    $cproduct :: forall a. Num a => Hyperlink a -> a
    product :: forall a. Num a => Hyperlink a -> a
    Foldable, Functor Hyperlink
    Foldable Hyperlink
    (Functor Hyperlink, Foldable Hyperlink) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Hyperlink a -> f (Hyperlink b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Hyperlink (f a) -> f (Hyperlink a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Hyperlink a -> m (Hyperlink b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Hyperlink (m a) -> m (Hyperlink a))
    -> Traversable Hyperlink
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    Hyperlink (m a) -> m (Hyperlink a)
    forall (f :: * -> *) a.
    Applicative f =>
    Hyperlink (f a) -> f (Hyperlink a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Hyperlink a -> m (Hyperlink b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Hyperlink a -> f (Hyperlink b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Hyperlink a -> f (Hyperlink b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Hyperlink a -> f (Hyperlink b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Hyperlink (f a) -> f (Hyperlink a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Hyperlink (f a) -> f (Hyperlink a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Hyperlink a -> m (Hyperlink b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Hyperlink a -> m (Hyperlink b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    Hyperlink (m a) -> m (Hyperlink a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Hyperlink (m a) -> m (Hyperlink a)
    Traversable)

    data ModLink id = ModLink
      { forall id. ModLink id -> Package
    modLinkName   :: String
      , forall id. ModLink id -> Maybe id
    modLinkLabel :: Maybe id
      } deriving (ModLink id -> ModLink id -> Bool
    (ModLink id -> ModLink id -> Bool)
    -> (ModLink id -> ModLink id -> Bool) -> Eq (ModLink id)
    forall id. Eq id => ModLink id -> ModLink id -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall id. Eq id => ModLink id -> ModLink id -> Bool
    == :: ModLink id -> ModLink id -> Bool
    $c/= :: forall id. Eq id => ModLink id -> ModLink id -> Bool
    /= :: ModLink id -> ModLink id -> Bool
    Eq, Int -> ModLink id -> ShowS
    [ModLink id] -> ShowS
    ModLink id -> Package
    (Int -> ModLink id -> ShowS)
    -> (ModLink id -> Package)
    -> ([ModLink id] -> ShowS)
    -> Show (ModLink id)
    forall id. Show id => Int -> ModLink id -> ShowS
    forall id. Show id => [ModLink id] -> ShowS
    forall id. Show id => ModLink id -> Package
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall id. Show id => Int -> ModLink id -> ShowS
    showsPrec :: Int -> ModLink id -> ShowS
    $cshow :: forall id. Show id => ModLink id -> Package
    show :: ModLink id -> Package
    $cshowList :: forall id. Show id => [ModLink id] -> ShowS
    showList :: [ModLink id] -> ShowS
    Show, (forall a b. (a -> b) -> ModLink a -> ModLink b)
    -> (forall a b. a -> ModLink b -> ModLink a) -> Functor ModLink
    forall a b. a -> ModLink b -> ModLink a
    forall a b. (a -> b) -> ModLink a -> ModLink b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ModLink a -> ModLink b
    fmap :: forall a b. (a -> b) -> ModLink a -> ModLink b
    $c<$ :: forall a b. a -> ModLink b -> ModLink a
    <$ :: forall a b. a -> ModLink b -> ModLink a
    Functor, (forall m. Monoid m => ModLink m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ModLink a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ModLink a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ModLink a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ModLink a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ModLink a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ModLink a -> b)
    -> (forall a. (a -> a -> a) -> ModLink a -> a)
    -> (forall a. (a -> a -> a) -> ModLink a -> a)
    -> (forall a. ModLink a -> [a])
    -> (forall a. ModLink a -> Bool)
    -> (forall a. ModLink a -> Int)
    -> (forall a. Eq a => a -> ModLink a -> Bool)
    -> (forall a. Ord a => ModLink a -> a)
    -> (forall a. Ord a => ModLink a -> a)
    -> (forall a. Num a => ModLink a -> a)
    -> (forall a. Num a => ModLink a -> a)
    -> Foldable ModLink
    forall a. Eq a => a -> ModLink a -> Bool
    forall a. Num a => ModLink a -> a
    forall a. Ord a => ModLink a -> a
    forall m. Monoid m => ModLink m -> m
    forall a. ModLink a -> Bool
    forall a. ModLink a -> Int
    forall a. ModLink a -> [a]
    forall a. (a -> a -> a) -> ModLink a -> a
    forall m a. Monoid m => (a -> m) -> ModLink a -> m
    forall b a. (b -> a -> b) -> b -> ModLink a -> b
    forall a b. (a -> b -> b) -> b -> ModLink a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ModLink m -> m
    fold :: forall m. Monoid m => ModLink m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ModLink a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ModLink a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ModLink a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ModLink a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ModLink a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ModLink a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ModLink a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ModLink a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ModLink a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ModLink a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ModLink a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ModLink a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ModLink a -> a
    foldr1 :: forall a. (a -> a -> a) -> ModLink a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ModLink a -> a
    foldl1 :: forall a. (a -> a -> a) -> ModLink a -> a
    $ctoList :: forall a. ModLink a -> [a]
    toList :: forall a. ModLink a -> [a]
    $cnull :: forall a. ModLink a -> Bool
    null :: forall a. ModLink a -> Bool
    $clength :: forall a. ModLink a -> Int
    length :: forall a. ModLink a -> Int
    $celem :: forall a. Eq a => a -> ModLink a -> Bool
    elem :: forall a. Eq a => a -> ModLink a -> Bool
    $cmaximum :: forall a. Ord a => ModLink a -> a
    maximum :: forall a. Ord a => ModLink a -> a
    $cminimum :: forall a. Ord a => ModLink a -> a
    minimum :: forall a. Ord a => ModLink a -> a
    $csum :: forall a. Num a => ModLink a -> a
    sum :: forall a. Num a => ModLink a -> a
    $cproduct :: forall a. Num a => ModLink a -> a
    product :: forall a. Num a => ModLink a -> a
    Foldable, Functor ModLink
    Foldable ModLink
    (Functor ModLink, Foldable ModLink) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ModLink a -> f (ModLink b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ModLink (f a) -> f (ModLink a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ModLink a -> m (ModLink b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ModLink (m a) -> m (ModLink a))
    -> Traversable ModLink
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => ModLink (m a) -> m (ModLink a)
    forall (f :: * -> *) a.
    Applicative f =>
    ModLink (f a) -> f (ModLink a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModLink a -> m (ModLink b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModLink a -> f (ModLink b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModLink a -> f (ModLink b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModLink a -> f (ModLink b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ModLink (f a) -> f (ModLink a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ModLink (f a) -> f (ModLink a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModLink a -> m (ModLink b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModLink a -> m (ModLink b)
    $csequence :: forall (m :: * -> *) a. Monad m => ModLink (m a) -> m (ModLink a)
    sequence :: forall (m :: * -> *) a. Monad m => ModLink (m a) -> m (ModLink a)
    Traversable)

    data Picture = Picture
      { Picture -> Package
    pictureUri   :: String
      , Picture -> Maybe Package
    pictureTitle :: Maybe String
      } deriving (Picture -> Picture -> Bool
    (Picture -> Picture -> Bool)
    -> (Picture -> Picture -> Bool) -> Eq Picture
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Picture -> Picture -> Bool
    == :: Picture -> Picture -> Bool
    $c/= :: Picture -> Picture -> Bool
    /= :: Picture -> Picture -> Bool
    Eq, Int -> Picture -> ShowS
    [Picture] -> ShowS
    Picture -> Package
    (Int -> Picture -> ShowS)
    -> (Picture -> Package) -> ([Picture] -> ShowS) -> Show Picture
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Picture -> ShowS
    showsPrec :: Int -> Picture -> ShowS
    $cshow :: Picture -> Package
    show :: Picture -> Package
    $cshowList :: [Picture] -> ShowS
    showList :: [Picture] -> ShowS
    Show)

    data Header id = Header
      { forall id. Header id -> Int
    headerLevel :: Int  -- ^ between 1 and 6 inclusive
      , forall id. Header id -> id
    headerTitle :: id
      } deriving (Header id -> Header id -> Bool
    (Header id -> Header id -> Bool)
    -> (Header id -> Header id -> Bool) -> Eq (Header id)
    forall id. Eq id => Header id -> Header id -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall id. Eq id => Header id -> Header id -> Bool
    == :: Header id -> Header id -> Bool
    $c/= :: forall id. Eq id => Header id -> Header id -> Bool
    /= :: Header id -> Header id -> Bool
    Eq, Int -> Header id -> ShowS
    [Header id] -> ShowS
    Header id -> Package
    (Int -> Header id -> ShowS)
    -> (Header id -> Package)
    -> ([Header id] -> ShowS)
    -> Show (Header id)
    forall id. Show id => Int -> Header id -> ShowS
    forall id. Show id => [Header id] -> ShowS
    forall id. Show id => Header id -> Package
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall id. Show id => Int -> Header id -> ShowS
    showsPrec :: Int -> Header id -> ShowS
    $cshow :: forall id. Show id => Header id -> Package
    show :: Header id -> Package
    $cshowList :: forall id. Show id => [Header id] -> ShowS
    showList :: [Header id] -> ShowS
    Show, (forall a b. (a -> b) -> Header a -> Header b)
    -> (forall a b. a -> Header b -> Header a) -> Functor Header
    forall a b. a -> Header b -> Header a
    forall a b. (a -> b) -> Header a -> Header b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Header a -> Header b
    fmap :: forall a b. (a -> b) -> Header a -> Header b
    $c<$ :: forall a b. a -> Header b -> Header a
    <$ :: forall a b. a -> Header b -> Header a
    Functor, (forall m. Monoid m => Header m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Header a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Header a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Header a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Header a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Header a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Header a -> b)
    -> (forall a. (a -> a -> a) -> Header a -> a)
    -> (forall a. (a -> a -> a) -> Header a -> a)
    -> (forall a. Header a -> [a])
    -> (forall a. Header a -> Bool)
    -> (forall id. Header id -> Int)
    -> (forall a. Eq a => a -> Header a -> Bool)
    -> (forall a. Ord a => Header a -> a)
    -> (forall a. Ord a => Header a -> a)
    -> (forall a. Num a => Header a -> a)
    -> (forall a. Num a => Header a -> a)
    -> Foldable Header
    forall a. Eq a => a -> Header a -> Bool
    forall a. Num a => Header a -> a
    forall a. Ord a => Header a -> a
    forall m. Monoid m => Header m -> m
    forall a. Header a -> Bool
    forall id. Header id -> Int
    forall a. Header a -> [a]
    forall a. (a -> a -> a) -> Header a -> a
    forall m a. Monoid m => (a -> m) -> Header a -> m
    forall b a. (b -> a -> b) -> b -> Header a -> b
    forall a b. (a -> b -> b) -> b -> Header a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Header m -> m
    fold :: forall m. Monoid m => Header m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Header a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Header a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Header a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Header a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Header a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Header a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Header a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Header a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Header a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Header a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Header a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Header a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Header a -> a
    foldr1 :: forall a. (a -> a -> a) -> Header a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Header a -> a
    foldl1 :: forall a. (a -> a -> a) -> Header a -> a
    $ctoList :: forall a. Header a -> [a]
    toList :: forall a. Header a -> [a]
    $cnull :: forall a. Header a -> Bool
    null :: forall a. Header a -> Bool
    $clength :: forall id. Header id -> Int
    length :: forall id. Header id -> Int
    $celem :: forall a. Eq a => a -> Header a -> Bool
    elem :: forall a. Eq a => a -> Header a -> Bool
    $cmaximum :: forall a. Ord a => Header a -> a
    maximum :: forall a. Ord a => Header a -> a
    $cminimum :: forall a. Ord a => Header a -> a
    minimum :: forall a. Ord a => Header a -> a
    $csum :: forall a. Num a => Header a -> a
    sum :: forall a. Num a => Header a -> a
    $cproduct :: forall a. Num a => Header a -> a
    product :: forall a. Num a => Header a -> a
    Foldable, Functor Header
    Foldable Header
    (Functor Header, Foldable Header) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Header a -> f (Header b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Header (f a) -> f (Header a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Header a -> m (Header b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Header (m a) -> m (Header a))
    -> Traversable Header
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Header (m a) -> m (Header a)
    forall (f :: * -> *) a.
    Applicative f =>
    Header (f a) -> f (Header a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Header a -> m (Header b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Header a -> f (Header b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Header a -> f (Header b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Header a -> f (Header b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Header (f a) -> f (Header a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Header (f a) -> f (Header a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Header a -> m (Header b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Header a -> m (Header b)
    $csequence :: forall (m :: * -> *) a. Monad m => Header (m a) -> m (Header a)
    sequence :: forall (m :: * -> *) a. Monad m => Header (m a) -> m (Header a)
    Traversable)

    data Example = Example
      { Example -> Package
    exampleExpression :: String
      , Example -> [Package]
    exampleResult     :: [String]
      } deriving (Example -> Example -> Bool
    (Example -> Example -> Bool)
    -> (Example -> Example -> Bool) -> Eq Example
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Example -> Example -> Bool
    == :: Example -> Example -> Bool
    $c/= :: Example -> Example -> Bool
    /= :: Example -> Example -> Bool
    Eq, Int -> Example -> ShowS
    [Example] -> ShowS
    Example -> Package
    (Int -> Example -> ShowS)
    -> (Example -> Package) -> ([Example] -> ShowS) -> Show Example
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Example -> ShowS
    showsPrec :: Int -> Example -> ShowS
    $cshow :: Example -> Package
    show :: Example -> Package
    $cshowList :: [Example] -> ShowS
    showList :: [Example] -> ShowS
    Show)

    data TableCell id = TableCell
      { forall id. TableCell id -> Int
    tableCellColspan  :: Int
      , forall id. TableCell id -> Int
    tableCellRowspan  :: Int
      , forall id. TableCell id -> id
    tableCellContents :: id
      } deriving (TableCell id -> TableCell id -> Bool
    (TableCell id -> TableCell id -> Bool)
    -> (TableCell id -> TableCell id -> Bool) -> Eq (TableCell id)
    forall id. Eq id => TableCell id -> TableCell id -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall id. Eq id => TableCell id -> TableCell id -> Bool
    == :: TableCell id -> TableCell id -> Bool
    $c/= :: forall id. Eq id => TableCell id -> TableCell id -> Bool
    /= :: TableCell id -> TableCell id -> Bool
    Eq, Int -> TableCell id -> ShowS
    [TableCell id] -> ShowS
    TableCell id -> Package
    (Int -> TableCell id -> ShowS)
    -> (TableCell id -> Package)
    -> ([TableCell id] -> ShowS)
    -> Show (TableCell id)
    forall id. Show id => Int -> TableCell id -> ShowS
    forall id. Show id => [TableCell id] -> ShowS
    forall id. Show id => TableCell id -> Package
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall id. Show id => Int -> TableCell id -> ShowS
    showsPrec :: Int -> TableCell id -> ShowS
    $cshow :: forall id. Show id => TableCell id -> Package
    show :: TableCell id -> Package
    $cshowList :: forall id. Show id => [TableCell id] -> ShowS
    showList :: [TableCell id] -> ShowS
    Show, (forall a b. (a -> b) -> TableCell a -> TableCell b)
    -> (forall a b. a -> TableCell b -> TableCell a)
    -> Functor TableCell
    forall a b. a -> TableCell b -> TableCell a
    forall a b. (a -> b) -> TableCell a -> TableCell b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> TableCell a -> TableCell b
    fmap :: forall a b. (a -> b) -> TableCell a -> TableCell b
    $c<$ :: forall a b. a -> TableCell b -> TableCell a
    <$ :: forall a b. a -> TableCell b -> TableCell a
    Functor, (forall m. Monoid m => TableCell m -> m)
    -> (forall m a. Monoid m => (a -> m) -> TableCell a -> m)
    -> (forall m a. Monoid m => (a -> m) -> TableCell a -> m)
    -> (forall a b. (a -> b -> b) -> b -> TableCell a -> b)
    -> (forall a b. (a -> b -> b) -> b -> TableCell a -> b)
    -> (forall b a. (b -> a -> b) -> b -> TableCell a -> b)
    -> (forall b a. (b -> a -> b) -> b -> TableCell a -> b)
    -> (forall a. (a -> a -> a) -> TableCell a -> a)
    -> (forall a. (a -> a -> a) -> TableCell a -> a)
    -> (forall a. TableCell a -> [a])
    -> (forall a. TableCell a -> Bool)
    -> (forall id. TableCell id -> Int)
    -> (forall a. Eq a => a -> TableCell a -> Bool)
    -> (forall a. Ord a => TableCell a -> a)
    -> (forall a. Ord a => TableCell a -> a)
    -> (forall a. Num a => TableCell a -> a)
    -> (forall a. Num a => TableCell a -> a)
    -> Foldable TableCell
    forall a. Eq a => a -> TableCell a -> Bool
    forall a. Num a => TableCell a -> a
    forall a. Ord a => TableCell a -> a
    forall m. Monoid m => TableCell m -> m
    forall a. TableCell a -> Bool
    forall id. TableCell id -> Int
    forall a. TableCell a -> [a]
    forall a. (a -> a -> a) -> TableCell a -> a
    forall m a. Monoid m => (a -> m) -> TableCell a -> m
    forall b a. (b -> a -> b) -> b -> TableCell a -> b
    forall a b. (a -> b -> b) -> b -> TableCell a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => TableCell m -> m
    fold :: forall m. Monoid m => TableCell m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> TableCell a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> TableCell a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> TableCell a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> TableCell a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> TableCell a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> TableCell a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> TableCell a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> TableCell a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> TableCell a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> TableCell a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> TableCell a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> TableCell a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> TableCell a -> a
    foldr1 :: forall a. (a -> a -> a) -> TableCell a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> TableCell a -> a
    foldl1 :: forall a. (a -> a -> a) -> TableCell a -> a
    $ctoList :: forall a. TableCell a -> [a]
    toList :: forall a. TableCell a -> [a]
    $cnull :: forall a. TableCell a -> Bool
    null :: forall a. TableCell a -> Bool
    $clength :: forall id. TableCell id -> Int
    length :: forall id. TableCell id -> Int
    $celem :: forall a. Eq a => a -> TableCell a -> Bool
    elem :: forall a. Eq a => a -> TableCell a -> Bool
    $cmaximum :: forall a. Ord a => TableCell a -> a
    maximum :: forall a. Ord a => TableCell a -> a
    $cminimum :: forall a. Ord a => TableCell a -> a
    minimum :: forall a. Ord a => TableCell a -> a
    $csum :: forall a. Num a => TableCell a -> a
    sum :: forall a. Num a => TableCell a -> a
    $cproduct :: forall a. Num a => TableCell a -> a
    product :: forall a. Num a => TableCell a -> a
    Foldable, Functor TableCell
    Foldable TableCell
    (Functor TableCell, Foldable TableCell) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> TableCell a -> f (TableCell b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        TableCell (f a) -> f (TableCell a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> TableCell a -> m (TableCell b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        TableCell (m a) -> m (TableCell a))
    -> Traversable TableCell
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    TableCell (m a) -> m (TableCell a)
    forall (f :: * -> *) a.
    Applicative f =>
    TableCell (f a) -> f (TableCell a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TableCell a -> m (TableCell b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TableCell a -> f (TableCell b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TableCell a -> f (TableCell b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TableCell a -> f (TableCell b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    TableCell (f a) -> f (TableCell a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    TableCell (f a) -> f (TableCell a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TableCell a -> m (TableCell b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TableCell a -> m (TableCell b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    TableCell (m a) -> m (TableCell a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    TableCell (m a) -> m (TableCell a)
    Traversable)

    newtype TableRow id = TableRow
      { forall id. TableRow id -> [TableCell id]
    tableRowCells :: [TableCell id]
      } deriving (TableRow id -> TableRow id -> Bool
    (TableRow id -> TableRow id -> Bool)
    -> (TableRow id -> TableRow id -> Bool) -> Eq (TableRow id)
    forall id. Eq id => TableRow id -> TableRow id -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall id. Eq id => TableRow id -> TableRow id -> Bool
    == :: TableRow id -> TableRow id -> Bool
    $c/= :: forall id. Eq id => TableRow id -> TableRow id -> Bool
    /= :: TableRow id -> TableRow id -> Bool
    Eq, Int -> TableRow id -> ShowS
    [TableRow id] -> ShowS
    TableRow id -> Package
    (Int -> TableRow id -> ShowS)
    -> (TableRow id -> Package)
    -> ([TableRow id] -> ShowS)
    -> Show (TableRow id)
    forall id. Show id => Int -> TableRow id -> ShowS
    forall id. Show id => [TableRow id] -> ShowS
    forall id. Show id => TableRow id -> Package
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall id. Show id => Int -> TableRow id -> ShowS
    showsPrec :: Int -> TableRow id -> ShowS
    $cshow :: forall id. Show id => TableRow id -> Package
    show :: TableRow id -> Package
    $cshowList :: forall id. Show id => [TableRow id] -> ShowS
    showList :: [TableRow id] -> ShowS
    Show, (forall a b. (a -> b) -> TableRow a -> TableRow b)
    -> (forall a b. a -> TableRow b -> TableRow a) -> Functor TableRow
    forall a b. a -> TableRow b -> TableRow a
    forall a b. (a -> b) -> TableRow a -> TableRow b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> TableRow a -> TableRow b
    fmap :: forall a b. (a -> b) -> TableRow a -> TableRow b
    $c<$ :: forall a b. a -> TableRow b -> TableRow a
    <$ :: forall a b. a -> TableRow b -> TableRow a
    Functor, (forall m. Monoid m => TableRow m -> m)
    -> (forall m a. Monoid m => (a -> m) -> TableRow a -> m)
    -> (forall m a. Monoid m => (a -> m) -> TableRow a -> m)
    -> (forall a b. (a -> b -> b) -> b -> TableRow a -> b)
    -> (forall a b. (a -> b -> b) -> b -> TableRow a -> b)
    -> (forall b a. (b -> a -> b) -> b -> TableRow a -> b)
    -> (forall b a. (b -> a -> b) -> b -> TableRow a -> b)
    -> (forall a. (a -> a -> a) -> TableRow a -> a)
    -> (forall a. (a -> a -> a) -> TableRow a -> a)
    -> (forall a. TableRow a -> [a])
    -> (forall a. TableRow a -> Bool)
    -> (forall a. TableRow a -> Int)
    -> (forall a. Eq a => a -> TableRow a -> Bool)
    -> (forall a. Ord a => TableRow a -> a)
    -> (forall a. Ord a => TableRow a -> a)
    -> (forall a. Num a => TableRow a -> a)
    -> (forall a. Num a => TableRow a -> a)
    -> Foldable TableRow
    forall a. Eq a => a -> TableRow a -> Bool
    forall a. Num a => TableRow a -> a
    forall a. Ord a => TableRow a -> a
    forall m. Monoid m => TableRow m -> m
    forall a. TableRow a -> Bool
    forall a. TableRow a -> Int
    forall a. TableRow a -> [a]
    forall a. (a -> a -> a) -> TableRow a -> a
    forall m a. Monoid m => (a -> m) -> TableRow a -> m
    forall b a. (b -> a -> b) -> b -> TableRow a -> b
    forall a b. (a -> b -> b) -> b -> TableRow a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => TableRow m -> m
    fold :: forall m. Monoid m => TableRow m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> TableRow a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> TableRow a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> TableRow a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> TableRow a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> TableRow a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> TableRow a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> TableRow a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> TableRow a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> TableRow a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> TableRow a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> TableRow a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> TableRow a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> TableRow a -> a
    foldr1 :: forall a. (a -> a -> a) -> TableRow a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> TableRow a -> a
    foldl1 :: forall a. (a -> a -> a) -> TableRow a -> a
    $ctoList :: forall a. TableRow a -> [a]
    toList :: forall a. TableRow a -> [a]
    $cnull :: forall a. TableRow a -> Bool
    null :: forall a. TableRow a -> Bool
    $clength :: forall a. TableRow a -> Int
    length :: forall a. TableRow a -> Int
    $celem :: forall a. Eq a => a -> TableRow a -> Bool
    elem :: forall a. Eq a => a -> TableRow a -> Bool
    $cmaximum :: forall a. Ord a => TableRow a -> a
    maximum :: forall a. Ord a => TableRow a -> a
    $cminimum :: forall a. Ord a => TableRow a -> a
    minimum :: forall a. Ord a => TableRow a -> a
    $csum :: forall a. Num a => TableRow a -> a
    sum :: forall a. Num a => TableRow a -> a
    $cproduct :: forall a. Num a => TableRow a -> a
    product :: forall a. Num a => TableRow a -> a
    Foldable, Functor TableRow
    Foldable TableRow
    (Functor TableRow, Foldable TableRow) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> TableRow a -> f (TableRow b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        TableRow (f a) -> f (TableRow a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> TableRow a -> m (TableRow b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        TableRow (m a) -> m (TableRow a))
    -> Traversable TableRow
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => TableRow (m a) -> m (TableRow a)
    forall (f :: * -> *) a.
    Applicative f =>
    TableRow (f a) -> f (TableRow a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TableRow a -> m (TableRow b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TableRow a -> f (TableRow b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TableRow a -> f (TableRow b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TableRow a -> f (TableRow b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    TableRow (f a) -> f (TableRow a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    TableRow (f a) -> f (TableRow a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TableRow a -> m (TableRow b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TableRow a -> m (TableRow b)
    $csequence :: forall (m :: * -> *) a. Monad m => TableRow (m a) -> m (TableRow a)
    sequence :: forall (m :: * -> *) a. Monad m => TableRow (m a) -> m (TableRow a)
    Traversable)

    data Table id = Table
      { forall id. Table id -> [TableRow id]
    tableHeaderRows :: [TableRow id]
      , forall id. Table id -> [TableRow id]
    tableBodyRows   :: [TableRow id]
      } deriving (Table id -> Table id -> Bool
    (Table id -> Table id -> Bool)
    -> (Table id -> Table id -> Bool) -> Eq (Table id)
    forall id. Eq id => Table id -> Table id -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall id. Eq id => Table id -> Table id -> Bool
    == :: Table id -> Table id -> Bool
    $c/= :: forall id. Eq id => Table id -> Table id -> Bool
    /= :: Table id -> Table id -> Bool
    Eq, Int -> Table id -> ShowS
    [Table id] -> ShowS
    Table id -> Package
    (Int -> Table id -> ShowS)
    -> (Table id -> Package)
    -> ([Table id] -> ShowS)
    -> Show (Table id)
    forall id. Show id => Int -> Table id -> ShowS
    forall id. Show id => [Table id] -> ShowS
    forall id. Show id => Table id -> Package
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall id. Show id => Int -> Table id -> ShowS
    showsPrec :: Int -> Table id -> ShowS
    $cshow :: forall id. Show id => Table id -> Package
    show :: Table id -> Package
    $cshowList :: forall id. Show id => [Table id] -> ShowS
    showList :: [Table id] -> ShowS
    Show, (forall a b. (a -> b) -> Table a -> Table b)
    -> (forall a b. a -> Table b -> Table a) -> Functor Table
    forall a b. a -> Table b -> Table a
    forall a b. (a -> b) -> Table a -> Table b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Table a -> Table b
    fmap :: forall a b. (a -> b) -> Table a -> Table b
    $c<$ :: forall a b. a -> Table b -> Table a
    <$ :: forall a b. a -> Table b -> Table a
    Functor, (forall m. Monoid m => Table m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Table a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Table a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Table a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Table a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Table a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Table a -> b)
    -> (forall a. (a -> a -> a) -> Table a -> a)
    -> (forall a. (a -> a -> a) -> Table a -> a)
    -> (forall a. Table a -> [a])
    -> (forall a. Table a -> Bool)
    -> (forall a. Table a -> Int)
    -> (forall a. Eq a => a -> Table a -> Bool)
    -> (forall a. Ord a => Table a -> a)
    -> (forall a. Ord a => Table a -> a)
    -> (forall a. Num a => Table a -> a)
    -> (forall a. Num a => Table a -> a)
    -> Foldable Table
    forall a. Eq a => a -> Table a -> Bool
    forall a. Num a => Table a -> a
    forall a. Ord a => Table a -> a
    forall m. Monoid m => Table m -> m
    forall a. Table a -> Bool
    forall a. Table a -> Int
    forall a. Table a -> [a]
    forall a. (a -> a -> a) -> Table a -> a
    forall m a. Monoid m => (a -> m) -> Table a -> m
    forall b a. (b -> a -> b) -> b -> Table a -> b
    forall a b. (a -> b -> b) -> b -> Table a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Table m -> m
    fold :: forall m. Monoid m => Table m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Table a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Table a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Table a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Table a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Table a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Table a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Table a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Table a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Table a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Table a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Table a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Table a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Table a -> a
    foldr1 :: forall a. (a -> a -> a) -> Table a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Table a -> a
    foldl1 :: forall a. (a -> a -> a) -> Table a -> a
    $ctoList :: forall a. Table a -> [a]
    toList :: forall a. Table a -> [a]
    $cnull :: forall a. Table a -> Bool
    null :: forall a. Table a -> Bool
    $clength :: forall a. Table a -> Int
    length :: forall a. Table a -> Int
    $celem :: forall a. Eq a => a -> Table a -> Bool
    elem :: forall a. Eq a => a -> Table a -> Bool
    $cmaximum :: forall a. Ord a => Table a -> a
    maximum :: forall a. Ord a => Table a -> a
    $cminimum :: forall a. Ord a => Table a -> a
    minimum :: forall a. Ord a => Table a -> a
    $csum :: forall a. Num a => Table a -> a
    sum :: forall a. Num a => Table a -> a
    $cproduct :: forall a. Num a => Table a -> a
    product :: forall a. Num a => Table a -> a
    Foldable, Functor Table
    Foldable Table
    (Functor Table, Foldable Table) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Table a -> f (Table b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Table (f a) -> f (Table a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Table a -> m (Table b))
    -> (forall (m :: * -> *) a. Monad m => Table (m a) -> m (Table a))
    -> Traversable Table
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Table (m a) -> m (Table a)
    forall (f :: * -> *) a. Applicative f => Table (f a) -> f (Table a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Table a -> m (Table b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Table a -> f (Table b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Table a -> f (Table b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Table a -> f (Table b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Table (f a) -> f (Table a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Table (f a) -> f (Table a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Table a -> m (Table b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Table a -> m (Table b)
    $csequence :: forall (m :: * -> *) a. Monad m => Table (m a) -> m (Table a)
    sequence :: forall (m :: * -> *) a. Monad m => Table (m a) -> m (Table a)
    Traversable)

    data DocH mod id
      = DocEmpty
      | DocAppend (DocH mod id) (DocH mod id)
      | DocString String
      | DocParagraph (DocH mod id)
      | DocIdentifier id
      | DocIdentifierUnchecked mod
      -- ^ A qualified identifier that couldn't be resolved.
      | DocModule (ModLink (DocH mod id))
      -- ^ A link to a module, with an optional label.
      | DocWarning (DocH mod id)
      -- ^ This constructor has no counterpart in Haddock markup.
      | DocEmphasis (DocH mod id)
      | DocMonospaced (DocH mod id)
      | DocBold (DocH mod id)
      | DocUnorderedList [DocH mod id]
      | DocOrderedList [(Int, DocH mod id)]
      | DocDefList [(DocH mod id, DocH mod id)]
      | DocCodeBlock (DocH mod id)
      | DocHyperlink (Hyperlink (DocH mod id))
      | DocPic Picture
      | DocMathInline String
      | DocMathDisplay String
      | DocAName String
      -- ^ A (HTML) anchor. It must not contain any spaces.
      | DocProperty String
      | DocExamples [Example]
      | DocHeader (Header (DocH mod id))
      | DocTable (Table (DocH mod id))
      deriving (DocH mod id -> DocH mod id -> Bool
    (DocH mod id -> DocH mod id -> Bool)
    -> (DocH mod id -> DocH mod id -> Bool) -> Eq (DocH mod id)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall mod id.
    (Eq id, Eq mod) =>
    DocH mod id -> DocH mod id -> Bool
    $c== :: forall mod id.
    (Eq id, Eq mod) =>
    DocH mod id -> DocH mod id -> Bool
    == :: DocH mod id -> DocH mod id -> Bool
    $c/= :: forall mod id.
    (Eq id, Eq mod) =>
    DocH mod id -> DocH mod id -> Bool
    /= :: DocH mod id -> DocH mod id -> Bool
    Eq, Int -> DocH mod id -> ShowS
    [DocH mod id] -> ShowS
    DocH mod id -> Package
    (Int -> DocH mod id -> ShowS)
    -> (DocH mod id -> Package)
    -> ([DocH mod id] -> ShowS)
    -> Show (DocH mod id)
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    forall mod id. (Show id, Show mod) => Int -> DocH mod id -> ShowS
    forall mod id. (Show id, Show mod) => [DocH mod id] -> ShowS
    forall mod id. (Show id, Show mod) => DocH mod id -> Package
    $cshowsPrec :: forall mod id. (Show id, Show mod) => Int -> DocH mod id -> ShowS
    showsPrec :: Int -> DocH mod id -> ShowS
    $cshow :: forall mod id. (Show id, Show mod) => DocH mod id -> Package
    show :: DocH mod id -> Package
    $cshowList :: forall mod id. (Show id, Show mod) => [DocH mod id] -> ShowS
    showList :: [DocH mod id] -> ShowS
    Show, (forall a b. (a -> b) -> DocH mod a -> DocH mod b)
    -> (forall a b. a -> DocH mod b -> DocH mod a)
    -> Functor (DocH mod)
    forall a b. a -> DocH mod b -> DocH mod a
    forall a b. (a -> b) -> DocH mod a -> DocH mod b
    forall mod a b. a -> DocH mod b -> DocH mod a
    forall mod a b. (a -> b) -> DocH mod a -> DocH mod b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall mod a b. (a -> b) -> DocH mod a -> DocH mod b
    fmap :: forall a b. (a -> b) -> DocH mod a -> DocH mod b
    $c<$ :: forall mod a b. a -> DocH mod b -> DocH mod a
    <$ :: forall a b. a -> DocH mod b -> DocH mod a
    Functor, (forall m. Monoid m => DocH mod m -> m)
    -> (forall m a. Monoid m => (a -> m) -> DocH mod a -> m)
    -> (forall m a. Monoid m => (a -> m) -> DocH mod a -> m)
    -> (forall a b. (a -> b -> b) -> b -> DocH mod a -> b)
    -> (forall a b. (a -> b -> b) -> b -> DocH mod a -> b)
    -> (forall b a. (b -> a -> b) -> b -> DocH mod a -> b)
    -> (forall b a. (b -> a -> b) -> b -> DocH mod a -> b)
    -> (forall a. (a -> a -> a) -> DocH mod a -> a)
    -> (forall a. (a -> a -> a) -> DocH mod a -> a)
    -> (forall a. DocH mod a -> [a])
    -> (forall a. DocH mod a -> Bool)
    -> (forall a. DocH mod a -> Int)
    -> (forall a. Eq a => a -> DocH mod a -> Bool)
    -> (forall a. Ord a => DocH mod a -> a)
    -> (forall a. Ord a => DocH mod a -> a)
    -> (forall a. Num a => DocH mod a -> a)
    -> (forall a. Num a => DocH mod a -> a)
    -> Foldable (DocH mod)
    forall a. Eq a => a -> DocH mod a -> Bool
    forall a. Num a => DocH mod a -> a
    forall a. Ord a => DocH mod a -> a
    forall m. Monoid m => DocH mod m -> m
    forall a. DocH mod a -> Bool
    forall a. DocH mod a -> Int
    forall a. DocH mod a -> [a]
    forall a. (a -> a -> a) -> DocH mod a -> a
    forall mod a. Eq a => a -> DocH mod a -> Bool
    forall mod a. Num a => DocH mod a -> a
    forall mod a. Ord a => DocH mod a -> a
    forall mod m. Monoid m => DocH mod m -> m
    forall m a. Monoid m => (a -> m) -> DocH mod a -> m
    forall mod a. DocH mod a -> Bool
    forall mod a. DocH mod a -> Int
    forall mod a. DocH mod a -> [a]
    forall b a. (b -> a -> b) -> b -> DocH mod a -> b
    forall a b. (a -> b -> b) -> b -> DocH mod a -> b
    forall mod a. (a -> a -> a) -> DocH mod a -> a
    forall mod m a. Monoid m => (a -> m) -> DocH mod a -> m
    forall mod b a. (b -> a -> b) -> b -> DocH mod a -> b
    forall mod a b. (a -> b -> b) -> b -> DocH mod a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall mod m. Monoid m => DocH mod m -> m
    fold :: forall m. Monoid m => DocH mod m -> m
    $cfoldMap :: forall mod m a. Monoid m => (a -> m) -> DocH mod a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> DocH mod a -> m
    $cfoldMap' :: forall mod m a. Monoid m => (a -> m) -> DocH mod a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> DocH mod a -> m
    $cfoldr :: forall mod a b. (a -> b -> b) -> b -> DocH mod a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> DocH mod a -> b
    $cfoldr' :: forall mod a b. (a -> b -> b) -> b -> DocH mod a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> DocH mod a -> b
    $cfoldl :: forall mod b a. (b -> a -> b) -> b -> DocH mod a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> DocH mod a -> b
    $cfoldl' :: forall mod b a. (b -> a -> b) -> b -> DocH mod a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> DocH mod a -> b
    $cfoldr1 :: forall mod a. (a -> a -> a) -> DocH mod a -> a
    foldr1 :: forall a. (a -> a -> a) -> DocH mod a -> a
    $cfoldl1 :: forall mod a. (a -> a -> a) -> DocH mod a -> a
    foldl1 :: forall a. (a -> a -> a) -> DocH mod a -> a
    $ctoList :: forall mod a. DocH mod a -> [a]
    toList :: forall a. DocH mod a -> [a]
    $cnull :: forall mod a. DocH mod a -> Bool
    null :: forall a. DocH mod a -> Bool
    $clength :: forall mod a. DocH mod a -> Int
    length :: forall a. DocH mod a -> Int
    $celem :: forall mod a. Eq a => a -> DocH mod a -> Bool
    elem :: forall a. Eq a => a -> DocH mod a -> Bool
    $cmaximum :: forall mod a. Ord a => DocH mod a -> a
    maximum :: forall a. Ord a => DocH mod a -> a
    $cminimum :: forall mod a. Ord a => DocH mod a -> a
    minimum :: forall a. Ord a => DocH mod a -> a
    $csum :: forall mod a. Num a => DocH mod a -> a
    sum :: forall a. Num a => DocH mod a -> a
    $cproduct :: forall mod a. Num a => DocH mod a -> a
    product :: forall a. Num a => DocH mod a -> a
    Foldable, Functor (DocH mod)
    Foldable (DocH mod)
    (Functor (DocH mod), Foldable (DocH mod)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> DocH mod a -> f (DocH mod b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        DocH mod (f a) -> f (DocH mod a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> DocH mod a -> m (DocH mod b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        DocH mod (m a) -> m (DocH mod a))
    -> Traversable (DocH mod)
    forall mod. Functor (DocH mod)
    forall mod. Foldable (DocH mod)
    forall mod (m :: * -> *) a.
    Monad m =>
    DocH mod (m a) -> m (DocH mod a)
    forall mod (f :: * -> *) a.
    Applicative f =>
    DocH mod (f a) -> f (DocH mod a)
    forall mod (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DocH mod a -> m (DocH mod b)
    forall mod (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DocH mod a -> f (DocH mod b)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => DocH mod (m a) -> m (DocH mod a)
    forall (f :: * -> *) a.
    Applicative f =>
    DocH mod (f a) -> f (DocH mod a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DocH mod a -> m (DocH mod b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DocH mod a -> f (DocH mod b)
    $ctraverse :: forall mod (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DocH mod a -> f (DocH mod b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DocH mod a -> f (DocH mod b)
    $csequenceA :: forall mod (f :: * -> *) a.
    Applicative f =>
    DocH mod (f a) -> f (DocH mod a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    DocH mod (f a) -> f (DocH mod a)
    $cmapM :: forall mod (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DocH mod a -> m (DocH mod b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DocH mod a -> m (DocH mod b)
    $csequence :: forall mod (m :: * -> *) a.
    Monad m =>
    DocH mod (m a) -> m (DocH mod a)
    sequence :: forall (m :: * -> *) a. Monad m => DocH mod (m a) -> m (DocH mod a)
    Traversable)

    #if MIN_VERSION_base(4,8,0)
    -- | __NOTE__: Only defined for @base >= 4.8.0@
    instance Bifunctor DocH where
      bimap :: forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    bimap a -> b
    _ c -> d
    _ DocH a c
    DocEmpty = DocH b d
    forall mod id. DocH mod id
    DocEmpty
      bimap a -> b
    f c -> d
    g (DocAppend DocH a c
    docA DocH a c
    docB) = DocH b d -> DocH b d -> DocH b d
    forall mod id. DocH mod id -> DocH mod id -> DocH mod id
    DocAppend ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    docA) ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    docB)
      bimap a -> b
    _ c -> d
    _ (DocString Package
    s) = Package -> DocH b d
    forall mod id. Package -> DocH mod id
    DocString Package
    s
      bimap a -> b
    f c -> d
    g (DocParagraph DocH a c
    doc) = DocH b d -> DocH b d
    forall mod id. DocH mod id -> DocH mod id
    DocParagraph ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    doc)
      bimap a -> b
    _ c -> d
    g (DocIdentifier c
    i) = d -> DocH b d
    forall mod id. id -> DocH mod id
    DocIdentifier (c -> d
    g c
    i)
      bimap a -> b
    f c -> d
    _ (DocIdentifierUnchecked a
    m) = b -> DocH b d
    forall mod id. mod -> DocH mod id
    DocIdentifierUnchecked (a -> b
    f a
    m)
      bimap a -> b
    f c -> d
    g (DocModule (ModLink Package
    m Maybe (DocH a c)
    lbl)) = ModLink (DocH b d) -> DocH b d
    forall mod id. ModLink (DocH mod id) -> DocH mod id
    DocModule (Package -> Maybe (DocH b d) -> ModLink (DocH b d)
    forall id. Package -> Maybe id -> ModLink id
    ModLink Package
    m ((DocH a c -> DocH b d) -> Maybe (DocH a c) -> Maybe (DocH b d)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g) Maybe (DocH a c)
    lbl))
      bimap a -> b
    f c -> d
    g (DocWarning DocH a c
    doc) = DocH b d -> DocH b d
    forall mod id. DocH mod id -> DocH mod id
    DocWarning ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    doc)
      bimap a -> b
    f c -> d
    g (DocEmphasis DocH a c
    doc) = DocH b d -> DocH b d
    forall mod id. DocH mod id -> DocH mod id
    DocEmphasis ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    doc)
      bimap a -> b
    f c -> d
    g (DocMonospaced DocH a c
    doc) = DocH b d -> DocH b d
    forall mod id. DocH mod id -> DocH mod id
    DocMonospaced ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    doc)
      bimap a -> b
    f c -> d
    g (DocBold DocH a c
    doc) = DocH b d -> DocH b d
    forall mod id. DocH mod id -> DocH mod id
    DocBold ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    doc)
      bimap a -> b
    f c -> d
    g (DocUnorderedList [DocH a c]
    docs) = [DocH b d] -> DocH b d
    forall mod id. [DocH mod id] -> DocH mod id
    DocUnorderedList ((DocH a c -> DocH b d) -> [DocH a c] -> [DocH b d]
    forall a b. (a -> b) -> [a] -> [b]
    map ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g) [DocH a c]
    docs)
      bimap a -> b
    f c -> d
    g (DocOrderedList [(Int, DocH a c)]
    docs) = [(Int, DocH b d)] -> DocH b d
    forall mod id. [(Int, DocH mod id)] -> DocH mod id
    DocOrderedList (((Int, DocH a c) -> (Int, DocH b d))
    -> [(Int, DocH a c)] -> [(Int, DocH b d)]
    forall a b. (a -> b) -> [a] -> [b]
    map (\(Int
    index, DocH a c
    a) -> (Int
    index, (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    a)) [(Int, DocH a c)]
    docs)
      bimap a -> b
    f c -> d
    g (DocDefList [(DocH a c, DocH a c)]
    docs) = [(DocH b d, DocH b d)] -> DocH b d
    forall mod id. [(DocH mod id, DocH mod id)] -> DocH mod id
    DocDefList (((DocH a c, DocH a c) -> (DocH b d, DocH b d))
    -> [(DocH a c, DocH a c)] -> [(DocH b d, DocH b d)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g (DocH a c -> DocH b d)
    -> (DocH a c -> DocH b d)
    -> (DocH a c, DocH a c)
    -> (DocH b d, DocH b d)
    forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
    forall (a :: * -> * -> *) b c b' c'.
    Arrow a =>
    a b c -> a b' c' -> a (b, b') (c, c')
    *** (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g) [(DocH a c, DocH a c)]
    docs)
      bimap a -> b
    f c -> d
    g (DocCodeBlock DocH a c
    doc) = DocH b d -> DocH b d
    forall mod id. DocH mod id -> DocH mod id
    DocCodeBlock ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    doc)
      bimap a -> b
    f c -> d
    g (DocHyperlink (Hyperlink Package
    url Maybe (DocH a c)
    lbl)) = Hyperlink (DocH b d) -> DocH b d
    forall mod id. Hyperlink (DocH mod id) -> DocH mod id
    DocHyperlink (Package -> Maybe (DocH b d) -> Hyperlink (DocH b d)
    forall id. Package -> Maybe id -> Hyperlink id
    Hyperlink Package
    url ((DocH a c -> DocH b d) -> Maybe (DocH a c) -> Maybe (DocH b d)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g) Maybe (DocH a c)
    lbl))
      bimap a -> b
    _ c -> d
    _ (DocPic Picture
    picture) = Picture -> DocH b d
    forall mod id. Picture -> DocH mod id
    DocPic Picture
    picture
      bimap a -> b
    _ c -> d
    _ (DocMathInline Package
    s) = Package -> DocH b d
    forall mod id. Package -> DocH mod id
    DocMathInline Package
    s
      bimap a -> b
    _ c -> d
    _ (DocMathDisplay Package
    s) = Package -> DocH b d
    forall mod id. Package -> DocH mod id
    DocMathDisplay Package
    s
      bimap a -> b
    _ c -> d
    _ (DocAName Package
    s) = Package -> DocH b d
    forall mod id. Package -> DocH mod id
    DocAName Package
    s
      bimap a -> b
    _ c -> d
    _ (DocProperty Package
    s) = Package -> DocH b d
    forall mod id. Package -> DocH mod id
    DocProperty Package
    s
      bimap a -> b
    _ c -> d
    _ (DocExamples [Example]
    examples) = [Example] -> DocH b d
    forall mod id. [Example] -> DocH mod id
    DocExamples [Example]
    examples
      bimap a -> b
    f c -> d
    g (DocHeader (Header Int
    level DocH a c
    title)) = Header (DocH b d) -> DocH b d
    forall mod id. Header (DocH mod id) -> DocH mod id
    DocHeader (Int -> DocH b d -> Header (DocH b d)
    forall id. Int -> id -> Header id
    Header Int
    level ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g DocH a c
    title))
      bimap a -> b
    f c -> d
    g (DocTable (Table [TableRow (DocH a c)]
    header [TableRow (DocH a c)]
    body)) = Table (DocH b d) -> DocH b d
    forall mod id. Table (DocH mod id) -> DocH mod id
    DocTable ([TableRow (DocH b d)] -> [TableRow (DocH b d)] -> Table (DocH b d)
    forall id. [TableRow id] -> [TableRow id] -> Table id
    Table ((TableRow (DocH a c) -> TableRow (DocH b d))
    -> [TableRow (DocH a c)] -> [TableRow (DocH b d)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((DocH a c -> DocH b d)
    -> TableRow (DocH a c) -> TableRow (DocH b d)
    forall a b. (a -> b) -> TableRow a -> TableRow b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g)) [TableRow (DocH a c)]
    header) ((TableRow (DocH a c) -> TableRow (DocH b d))
    -> [TableRow (DocH a c)] -> [TableRow (DocH b d)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((DocH a c -> DocH b d)
    -> TableRow (DocH a c) -> TableRow (DocH b d)
    forall a b. (a -> b) -> TableRow a -> TableRow b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall a b c d. (a -> b) -> (c -> d) -> DocH a c -> DocH b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> b
    f c -> d
    g)) [TableRow (DocH a c)]
    body))
    #endif

    #if MIN_VERSION_base(4,10,0)
    -- | __NOTE__: Only defined for @base >= 4.10.0@
    instance Bifoldable DocH where
      bifoldr :: forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocAppend DocH a b
    docA DocH a b
    docB) = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g ((a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z DocH a b
    docA) DocH a b
    docB
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocParagraph DocH a b
    doc) = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z DocH a b
    doc
      bifoldr a -> c -> c
    _ b -> c -> c
    g c
    z (DocIdentifier b
    i) = b -> c -> c
    g b
    i c
    z
      bifoldr a -> c -> c
    f b -> c -> c
    _ c
    z (DocIdentifierUnchecked a
    m) = a -> c -> c
    f a
    m c
    z
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocWarning DocH a b
    doc) = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z DocH a b
    doc
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocEmphasis DocH a b
    doc) = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z DocH a b
    doc
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocMonospaced DocH a b
    doc) = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z DocH a b
    doc
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocBold DocH a b
    doc) = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z DocH a b
    doc
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocUnorderedList [DocH a b]
    docs) = (DocH a b -> c -> c) -> c -> [DocH a b] -> c
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr ((c -> DocH a b -> c) -> DocH a b -> c -> c
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g)) c
    z [DocH a b]
    docs
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocOrderedList [(Int, DocH a b)]
    docs) = (DocH a b -> c -> c) -> c -> [DocH a b] -> c
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr ((c -> DocH a b -> c) -> DocH a b -> c -> c
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g)) c
    z (((Int, DocH a b) -> DocH a b) -> [(Int, DocH a b)] -> [DocH a b]
    forall a b. (a -> b) -> [a] -> [b]
    map (Int, DocH a b) -> DocH a b
    forall a b. (a, b) -> b
    snd [(Int, DocH a b)]
    docs)
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocDefList [(DocH a b, DocH a b)]
    docs) = ((DocH a b, DocH a b) -> c -> c)
    -> c -> [(DocH a b, DocH a b)] -> c
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\(DocH a b
    l, DocH a b
    r) c
    acc -> (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g ((a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    acc DocH a b
    l) DocH a b
    r) c
    z [(DocH a b, DocH a b)]
    docs
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocCodeBlock DocH a b
    doc) = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z DocH a b
    doc
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocHeader (Header Int
    _ DocH a b
    title)) = (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z DocH a b
    title
      bifoldr a -> c -> c
    f b -> c -> c
    g c
    z (DocTable (Table [TableRow (DocH a b)]
    header [TableRow (DocH a b)]
    body)) = (TableRow (DocH a b) -> c -> c) -> c -> [TableRow (DocH a b)] -> c
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\TableRow (DocH a b)
    r c
    acc -> (DocH a b -> c -> c) -> c -> TableRow (DocH a b) -> c
    forall a b. (a -> b -> b) -> b -> TableRow a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr ((c -> DocH a b -> c) -> DocH a b -> c -> c
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g)) c
    acc TableRow (DocH a b)
    r) ((TableRow (DocH a b) -> c -> c) -> c -> [TableRow (DocH a b)] -> c
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\TableRow (DocH a b)
    r c
    acc -> (DocH a b -> c -> c) -> c -> TableRow (DocH a b) -> c
    forall a b. (a -> b -> b) -> b -> TableRow a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr ((c -> DocH a b -> c) -> DocH a b -> c -> c
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> DocH a b -> c
    forall (p :: * -> * -> *) a c b.
    Bifoldable p =>
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g)) c
    acc TableRow (DocH a b)
    r) c
    z [TableRow (DocH a b)]
    body) [TableRow (DocH a b)]
    header
      bifoldr a -> c -> c
    _ b -> c -> c
    _ c
    z DocH a b
    _ = c
    z

    -- | __NOTE__: Only defined for @base >= 4.10.0@
    instance Bitraversable DocH where
      bitraverse :: forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    bitraverse a -> f c
    _ b -> f d
    _ DocH a b
    DocEmpty = DocH c d -> f (DocH c d)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure DocH c d
    forall mod id. DocH mod id
    DocEmpty
      bitraverse a -> f c
    f b -> f d
    g (DocAppend DocH a b
    docA DocH a b
    docB) = DocH c d -> DocH c d -> DocH c d
    forall mod id. DocH mod id -> DocH mod id -> DocH mod id
    DocAppend (DocH c d -> DocH c d -> DocH c d)
    -> f (DocH c d) -> f (DocH c d -> DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    docA f (DocH c d -> DocH c d) -> f (DocH c d) -> f (DocH c d)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    docB
      bitraverse a -> f c
    _ b -> f d
    _ (DocString Package
    s) = DocH c d -> f (DocH c d)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Package -> DocH c d
    forall mod id. Package -> DocH mod id
    DocString Package
    s)
      bitraverse a -> f c
    f b -> f d
    g (DocParagraph DocH a b
    doc) = DocH c d -> DocH c d
    forall mod id. DocH mod id -> DocH mod id
    DocParagraph (DocH c d -> DocH c d) -> f (DocH c d) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    doc
      bitraverse a -> f c
    _ b -> f d
    g (DocIdentifier b
    i) = d -> DocH c d
    forall mod id. id -> DocH mod id
    DocIdentifier (d -> DocH c d) -> f d -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> b -> f d
    g b
    i
      bitraverse a -> f c
    f b -> f d
    _ (DocIdentifierUnchecked a
    m) = c -> DocH c d
    forall mod id. mod -> DocH mod id
    DocIdentifierUnchecked (c -> DocH c d) -> f c -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f c
    f a
    m
      bitraverse a -> f c
    f b -> f d
    g (DocModule (ModLink Package
    m Maybe (DocH a b)
    lbl)) = ModLink (DocH c d) -> DocH c d
    forall mod id. ModLink (DocH mod id) -> DocH mod id
    DocModule (ModLink (DocH c d) -> DocH c d)
    -> f (ModLink (DocH c d)) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Package -> Maybe (DocH c d) -> ModLink (DocH c d)
    forall id. Package -> Maybe id -> ModLink id
    ModLink Package
    m (Maybe (DocH c d) -> ModLink (DocH c d))
    -> f (Maybe (DocH c d)) -> f (ModLink (DocH c d))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (DocH a b -> f (DocH c d))
    -> Maybe (DocH a b) -> f (Maybe (DocH c d))
    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) -> Maybe a -> f (Maybe b)
    traverse ((a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g) Maybe (DocH a b)
    lbl)
      bitraverse a -> f c
    f b -> f d
    g (DocWarning DocH a b
    doc) = DocH c d -> DocH c d
    forall mod id. DocH mod id -> DocH mod id
    DocWarning (DocH c d -> DocH c d) -> f (DocH c d) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    doc
      bitraverse a -> f c
    f b -> f d
    g (DocEmphasis DocH a b
    doc) = DocH c d -> DocH c d
    forall mod id. DocH mod id -> DocH mod id
    DocEmphasis (DocH c d -> DocH c d) -> f (DocH c d) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    doc
      bitraverse a -> f c
    f b -> f d
    g (DocMonospaced DocH a b
    doc) = DocH c d -> DocH c d
    forall mod id. DocH mod id -> DocH mod id
    DocMonospaced (DocH c d -> DocH c d) -> f (DocH c d) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    doc
      bitraverse a -> f c
    f b -> f d
    g (DocBold DocH a b
    doc) = DocH c d -> DocH c d
    forall mod id. DocH mod id -> DocH mod id
    DocBold (DocH c d -> DocH c d) -> f (DocH c d) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    doc
      bitraverse a -> f c
    f b -> f d
    g (DocUnorderedList [DocH a b]
    docs) = [DocH c d] -> DocH c d
    forall mod id. [DocH mod id] -> DocH mod id
    DocUnorderedList ([DocH c d] -> DocH c d) -> f [DocH c d] -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (DocH a b -> f (DocH c d)) -> [DocH a b] -> f [DocH c d]
    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 ((a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g) [DocH a b]
    docs
      bitraverse a -> f c
    f b -> f d
    g (DocOrderedList [(Int, DocH a b)]
    docs) = [(Int, DocH c d)] -> DocH c d
    forall mod id. [(Int, DocH mod id)] -> DocH mod id
    DocOrderedList ([(Int, DocH c d)] -> DocH c d)
    -> f [(Int, DocH c d)] -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (DocH a b -> f (DocH c d))
    -> [(Int, DocH a b)] -> f [(Int, DocH c d)]
    forall {t :: * -> *} {f :: * -> *} {t} {b} {a}.
    (Traversable t, Applicative f) =>
    (t -> f b) -> t (a, t) -> f (t (a, b))
    traverseSnd ((a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g) [(Int, DocH a b)]
    docs
        where traverseSnd :: (t -> f b) -> t (a, t) -> f (t (a, b))
    traverseSnd t -> f b
    f' = ((a, t) -> f (a, b)) -> t (a, t) -> f (t (a, 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) -> t a -> f (t b)
    traverse (\(a
    x, t
    a) -> (\b
    b -> (a
    x, b
    b)) (b -> (a, b)) -> f b -> f (a, b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> t -> f b
    f' t
    a)
      bitraverse a -> f c
    f b -> f d
    g (DocDefList [(DocH a b, DocH a b)]
    docs) = [(DocH c d, DocH c d)] -> DocH c d
    forall mod id. [(DocH mod id, DocH mod id)] -> DocH mod id
    DocDefList ([(DocH c d, DocH c d)] -> DocH c d)
    -> f [(DocH c d, DocH c d)] -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((DocH a b, DocH a b) -> f (DocH c d, DocH c d))
    -> [(DocH a b, DocH a b)] -> f [(DocH c d, DocH c d)]
    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 ((DocH a b -> f (DocH c d))
    -> (DocH a b -> f (DocH c d))
    -> (DocH a b, DocH a b)
    -> f (DocH c d, DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> (a, b) -> f (c, d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse ((a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g) ((a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g)) [(DocH a b, DocH a b)]
    docs
      bitraverse a -> f c
    f b -> f d
    g (DocCodeBlock DocH a b
    doc) = DocH c d -> DocH c d
    forall mod id. DocH mod id -> DocH mod id
    DocCodeBlock (DocH c d -> DocH c d) -> f (DocH c d) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    doc
      bitraverse a -> f c
    f b -> f d
    g (DocHyperlink (Hyperlink Package
    url Maybe (DocH a b)
    lbl)) = Hyperlink (DocH c d) -> DocH c d
    forall mod id. Hyperlink (DocH mod id) -> DocH mod id
    DocHyperlink (Hyperlink (DocH c d) -> DocH c d)
    -> f (Hyperlink (DocH c d)) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Package -> Maybe (DocH c d) -> Hyperlink (DocH c d)
    forall id. Package -> Maybe id -> Hyperlink id
    Hyperlink Package
    url (Maybe (DocH c d) -> Hyperlink (DocH c d))
    -> f (Maybe (DocH c d)) -> f (Hyperlink (DocH c d))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (DocH a b -> f (DocH c d))
    -> Maybe (DocH a b) -> f (Maybe (DocH c d))
    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) -> Maybe a -> f (Maybe b)
    traverse ((a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g) Maybe (DocH a b)
    lbl)
      bitraverse a -> f c
    _ b -> f d
    _ (DocPic Picture
    picture) = DocH c d -> f (DocH c d)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Picture -> DocH c d
    forall mod id. Picture -> DocH mod id
    DocPic Picture
    picture)
      bitraverse a -> f c
    _ b -> f d
    _ (DocMathInline Package
    s) = DocH c d -> f (DocH c d)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Package -> DocH c d
    forall mod id. Package -> DocH mod id
    DocMathInline Package
    s)
      bitraverse a -> f c
    _ b -> f d
    _ (DocMathDisplay Package
    s) = DocH c d -> f (DocH c d)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Package -> DocH c d
    forall mod id. Package -> DocH mod id
    DocMathDisplay Package
    s)
      bitraverse a -> f c
    _ b -> f d
    _ (DocAName Package
    s) = DocH c d -> f (DocH c d)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Package -> DocH c d
    forall mod id. Package -> DocH mod id
    DocAName Package
    s)
      bitraverse a -> f c
    _ b -> f d
    _ (DocProperty Package
    s) = DocH c d -> f (DocH c d)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Package -> DocH c d
    forall mod id. Package -> DocH mod id
    DocProperty Package
    s)
      bitraverse a -> f c
    _ b -> f d
    _ (DocExamples [Example]
    examples) = DocH c d -> f (DocH c d)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ([Example] -> DocH c d
    forall mod id. [Example] -> DocH mod id
    DocExamples [Example]
    examples)
      bitraverse a -> f c
    f b -> f d
    g (DocHeader (Header Int
    level DocH a b
    title)) = (Header (DocH c d) -> DocH c d
    forall mod id. Header (DocH mod id) -> DocH mod id
    DocHeader (Header (DocH c d) -> DocH c d)
    -> (DocH c d -> Header (DocH c d)) -> DocH c d -> DocH c d
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> DocH c d -> Header (DocH c d)
    forall id. Int -> id -> Header id
    Header Int
    level) (DocH c d -> DocH c d) -> f (DocH c d) -> f (DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g DocH a b
    title
      bitraverse a -> f c
    f b -> f d
    g (DocTable (Table [TableRow (DocH a b)]
    header [TableRow (DocH a b)]
    body)) = (\[TableRow (DocH c d)]
    h [TableRow (DocH c d)]
    b -> Table (DocH c d) -> DocH c d
    forall mod id. Table (DocH mod id) -> DocH mod id
    DocTable ([TableRow (DocH c d)] -> [TableRow (DocH c d)] -> Table (DocH c d)
    forall id. [TableRow id] -> [TableRow id] -> Table id
    Table [TableRow (DocH c d)]
    h [TableRow (DocH c d)]
    b)) ([TableRow (DocH c d)] -> [TableRow (DocH c d)] -> DocH c d)
    -> f [TableRow (DocH c d)] -> f ([TableRow (DocH c d)] -> DocH c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (TableRow (DocH a b) -> f (TableRow (DocH c d)))
    -> [TableRow (DocH a b)] -> f [TableRow (DocH c d)]
    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 ((DocH a b -> f (DocH c d))
    -> TableRow (DocH a b) -> f (TableRow (DocH c d))
    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) -> TableRow a -> f (TableRow b)
    traverse ((a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g)) [TableRow (DocH a b)]
    header f ([TableRow (DocH c d)] -> DocH c d)
    -> f [TableRow (DocH c d)] -> f (DocH c d)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (TableRow (DocH a b) -> f (TableRow (DocH c d)))
    -> [TableRow (DocH a b)] -> f [TableRow (DocH c d)]
    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 ((DocH a b -> f (DocH c d))
    -> TableRow (DocH a b) -> f (TableRow (DocH c d))
    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) -> TableRow a -> f (TableRow b)
    traverse ((a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> DocH a b -> f (DocH c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse a -> f c
    f b -> f d
    g)) [TableRow (DocH a b)]
    body
    #endif

    -- | The namespace qualification for an identifier.
    data Namespace = Value | Type | None deriving (Namespace -> Namespace -> Bool
    (Namespace -> Namespace -> Bool)
    -> (Namespace -> Namespace -> Bool) -> Eq Namespace
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Namespace -> Namespace -> Bool
    == :: Namespace -> Namespace -> Bool
    $c/= :: Namespace -> Namespace -> Bool
    /= :: Namespace -> Namespace -> Bool
    Eq, Eq Namespace
    Eq Namespace =>
    (Namespace -> Namespace -> Ordering)
    -> (Namespace -> Namespace -> Bool)
    -> (Namespace -> Namespace -> Bool)
    -> (Namespace -> Namespace -> Bool)
    -> (Namespace -> Namespace -> Bool)
    -> (Namespace -> Namespace -> Namespace)
    -> (Namespace -> Namespace -> Namespace)
    -> Ord Namespace
    Namespace -> Namespace -> Bool
    Namespace -> Namespace -> Ordering
    Namespace -> Namespace -> Namespace
    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
    $ccompare :: Namespace -> Namespace -> Ordering
    compare :: Namespace -> Namespace -> Ordering
    $c< :: Namespace -> Namespace -> Bool
    < :: Namespace -> Namespace -> Bool
    $c<= :: Namespace -> Namespace -> Bool
    <= :: Namespace -> Namespace -> Bool
    $c> :: Namespace -> Namespace -> Bool
    > :: Namespace -> Namespace -> Bool
    $c>= :: Namespace -> Namespace -> Bool
    >= :: Namespace -> Namespace -> Bool
    $cmax :: Namespace -> Namespace -> Namespace
    max :: Namespace -> Namespace -> Namespace
    $cmin :: Namespace -> Namespace -> Namespace
    min :: Namespace -> Namespace -> Namespace
    Ord, Int -> Namespace
    Namespace -> Int
    Namespace -> [Namespace]
    Namespace -> Namespace
    Namespace -> Namespace -> [Namespace]
    Namespace -> Namespace -> Namespace -> [Namespace]
    (Namespace -> Namespace)
    -> (Namespace -> Namespace)
    -> (Int -> Namespace)
    -> (Namespace -> Int)
    -> (Namespace -> [Namespace])
    -> (Namespace -> Namespace -> [Namespace])
    -> (Namespace -> Namespace -> [Namespace])
    -> (Namespace -> Namespace -> Namespace -> [Namespace])
    -> Enum Namespace
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Namespace -> Namespace
    succ :: Namespace -> Namespace
    $cpred :: Namespace -> Namespace
    pred :: Namespace -> Namespace
    $ctoEnum :: Int -> Namespace
    toEnum :: Int -> Namespace
    $cfromEnum :: Namespace -> Int
    fromEnum :: Namespace -> Int
    $cenumFrom :: Namespace -> [Namespace]
    enumFrom :: Namespace -> [Namespace]
    $cenumFromThen :: Namespace -> Namespace -> [Namespace]
    enumFromThen :: Namespace -> Namespace -> [Namespace]
    $cenumFromTo :: Namespace -> Namespace -> [Namespace]
    enumFromTo :: Namespace -> Namespace -> [Namespace]
    $cenumFromThenTo :: Namespace -> Namespace -> Namespace -> [Namespace]
    enumFromThenTo :: Namespace -> Namespace -> Namespace -> [Namespace]
    Enum, Int -> Namespace -> ShowS
    [Namespace] -> ShowS
    Namespace -> Package
    (Int -> Namespace -> ShowS)
    -> (Namespace -> Package)
    -> ([Namespace] -> ShowS)
    -> Show Namespace
    forall a.
    (Int -> a -> ShowS) -> (a -> Package) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Namespace -> ShowS
    showsPrec :: Int -> Namespace -> ShowS
    $cshow :: Namespace -> Package
    show :: Namespace -> Package
    $cshowList :: [Namespace] -> ShowS
    showList :: [Namespace] -> ShowS
    Show)

    -- | Render the a namespace into the same format it was initially parsed.
    renderNs :: Namespace -> String
    renderNs :: Namespace -> Package
    renderNs Namespace
    Value = Package
    "v"
    renderNs Namespace
    Type = Package
    "t"
    renderNs Namespace
    None = Package
    ""

    -- | 'DocMarkupH' is a set of instructions for marking up documentation.
    -- In fact, it's really just a mapping from 'Doc' to some other
    -- type [a], where [a] is usually the type of the output (HTML, say).
    -- Use 'Documentation.Haddock.Markup.markup' to apply a 'DocMarkupH' to
    -- a 'DocH'.
    --
    -- @since 1.4.5
    --
    data DocMarkupH mod id a = Markup
      { forall mod id a. DocMarkupH mod id a -> a
    markupEmpty                :: a
      , forall mod id a. DocMarkupH mod id a -> Package -> a
    markupString               :: String -> a
      , forall mod id a. DocMarkupH mod id a -> a -> a
    markupParagraph            :: a -> a
      , forall mod id a. DocMarkupH mod id a -> a -> a -> a
    markupAppend               :: a -> a -> a
      , forall mod id a. DocMarkupH mod id a -> id -> a
    markupIdentifier           :: id -> a
      , forall mod id a. DocMarkupH mod id a -> mod -> a
    markupIdentifierUnchecked  :: mod -> a
      , forall mod id a. DocMarkupH mod id a -> ModLink a -> a
    markupModule               :: ModLink a -> a
      , forall mod id a. DocMarkupH mod id a -> a -> a
    markupWarning              :: a -> a
      , forall mod id a. DocMarkupH mod id a -> a -> a
    markupEmphasis             :: a -> a
      , forall mod id a. DocMarkupH mod id a -> a -> a
    markupBold                 :: a -> a
      , forall mod id a. DocMarkupH mod id a -> a -> a
    markupMonospaced           :: a -> a
      , forall mod id a. DocMarkupH mod id a -> [a] -> a
    markupUnorderedList        :: [a] -> a
      , forall mod id a. DocMarkupH mod id a -> [(Int, a)] -> a
    markupOrderedList          :: [(Int,a)] -> a
      , forall mod id a. DocMarkupH mod id a -> [(a, a)] -> a
    markupDefList              :: [(a,a)] -> a
      , forall mod id a. DocMarkupH mod id a -> a -> a
    markupCodeBlock            :: a -> a
      , forall mod id a. DocMarkupH mod id a -> Hyperlink a -> a
    markupHyperlink            :: Hyperlink a -> a
      , forall mod id a. DocMarkupH mod id a -> Package -> a
    markupAName                :: String -> a
      , forall mod id a. DocMarkupH mod id a -> Picture -> a
    markupPic                  :: Picture -> a
      , forall mod id a. DocMarkupH mod id a -> Package -> a
    markupMathInline           :: String -> a
      , forall mod id a. DocMarkupH mod id a -> Package -> a
    markupMathDisplay          :: String -> a
      , forall mod id a. DocMarkupH mod id a -> Package -> a
    markupProperty             :: String -> a
      , forall mod id a. DocMarkupH mod id a -> [Example] -> a
    markupExample              :: [Example] -> a
      , forall mod id a. DocMarkupH mod id a -> Header a -> a
    markupHeader               :: Header a -> a
      , forall mod id a. DocMarkupH mod id a -> Table a -> a
    markupTable                :: Table a -> a
      }