    {-# LANGUAGE OverloadedStrings, DeriveDataTypeable, DeriveGeneric,
        FlexibleContexts, GeneralizedNewtypeDeriving, PatternGuards, CPP,
        TemplateHaskell , PatternSynonyms, ViewPatterns, StrictData #-}

    {-
    Copyright (c) 2006-2023, John MacFarlane

    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:

        * Redistributions of source code must retain the above copyright
          notice, this list of conditions and the following disclaimer.

        * Redistributions in binary form must reproduce the above
          copyright notice, this list of conditions and the following
          disclaimer in the documentation and/or other materials provided
          with the distribution.

        * Neither the name of John MacFarlane nor the names of other
          contributors may be used to endorse or promote products derived
          from this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    -}

    {- |
       Module      : Text.Pandoc.Definition
       Copyright   : Copyright (C) 2006-2023 John MacFarlane
       License     : BSD3

       Maintainer  : John MacFarlane <jgm@berkeley.edu>
       Stability   : alpha
       Portability : portable

    Definition of 'Pandoc' data structure for format-neutral representation
    of documents.
    -}
    module Text.Pandoc.Definition ( Pandoc(..)
                                  , Meta(..)
                                  , MetaValue(..)
                                  , nullMeta
                                  , isNullMeta
                                  , lookupMeta
                                  , docTitle
                                  , docAuthors
                                  , docDate
                                  , Block(..)
                                  , pattern SimpleFigure
                                  , Inline(..)
                                  , ListAttributes
                                  , ListNumberStyle(..)
                                  , ListNumberDelim(..)
                                  , Format(..)
                                  , Attr
                                  , nullAttr
                                  , Caption(..)
                                  , ShortCaption
                                  , RowHeadColumns(..)
                                  , Alignment(..)
                                  , ColWidth(..)
                                  , ColSpec
                                  , Row(..)
                                  , TableHead(..)
                                  , TableBody(..)
                                  , TableFoot(..)
                                  , Cell(..)
                                  , RowSpan(..)
                                  , ColSpan(..)
                                  , QuoteType(..)
                                  , Target
                                  , MathType(..)
                                  , Citation(..)
                                  , CitationMode(..)
                                  , pandocTypesVersion
                                  ) where

    import Data.Generics (Data, Typeable)
    import Data.Ord (comparing)
    import Data.Aeson
    import Data.Aeson.TH (deriveJSON)
    import qualified Data.Aeson.Types as Aeson
    import qualified Data.Map as M
    import Data.Text (Text)
    import qualified Data.Text as T
    import GHC.Generics (Generic)
    import Data.String
    import Control.DeepSeq
    import Paths_pandoc_types (version)
    import Data.Version (Version, versionBranch)
    import Control.Arrow (second)

    data Pandoc = Pandoc Meta [Block]
                  deriving (Pandoc -> Pandoc -> Bool
    (Pandoc -> Pandoc -> Bool)
    -> (Pandoc -> Pandoc -> Bool) -> Eq Pandoc
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Pandoc -> Pandoc -> Bool
    == :: Pandoc -> Pandoc -> Bool
    $c/= :: Pandoc -> Pandoc -> Bool
    /= :: Pandoc -> Pandoc -> Bool
    Eq, Eq Pandoc
    Eq Pandoc =>
    (Pandoc -> Pandoc -> Ordering)
    -> (Pandoc -> Pandoc -> Bool)
    -> (Pandoc -> Pandoc -> Bool)
    -> (Pandoc -> Pandoc -> Bool)
    -> (Pandoc -> Pandoc -> Bool)
    -> (Pandoc -> Pandoc -> Pandoc)
    -> (Pandoc -> Pandoc -> Pandoc)
    -> Ord Pandoc
    Pandoc -> Pandoc -> Bool
    Pandoc -> Pandoc -> Ordering
    Pandoc -> Pandoc -> Pandoc
    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 :: Pandoc -> Pandoc -> Ordering
    compare :: Pandoc -> Pandoc -> Ordering
    $c< :: Pandoc -> Pandoc -> Bool
    < :: Pandoc -> Pandoc -> Bool
    $c<= :: Pandoc -> Pandoc -> Bool
    <= :: Pandoc -> Pandoc -> Bool
    $c> :: Pandoc -> Pandoc -> Bool
    > :: Pandoc -> Pandoc -> Bool
    $c>= :: Pandoc -> Pandoc -> Bool
    >= :: Pandoc -> Pandoc -> Bool
    $cmax :: Pandoc -> Pandoc -> Pandoc
    max :: Pandoc -> Pandoc -> Pandoc
    $cmin :: Pandoc -> Pandoc -> Pandoc
    min :: Pandoc -> Pandoc -> Pandoc
    Ord, ReadPrec [Pandoc]
    ReadPrec Pandoc
    Int -> ReadS Pandoc
    ReadS [Pandoc]
    (Int -> ReadS Pandoc)
    -> ReadS [Pandoc]
    -> ReadPrec Pandoc
    -> ReadPrec [Pandoc]
    -> Read Pandoc
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Pandoc
    readsPrec :: Int -> ReadS Pandoc
    $creadList :: ReadS [Pandoc]
    readList :: ReadS [Pandoc]
    $creadPrec :: ReadPrec Pandoc
    readPrec :: ReadPrec Pandoc
    $creadListPrec :: ReadPrec [Pandoc]
    readListPrec :: ReadPrec [Pandoc]
    Read, Int -> Pandoc -> ShowS
    [Pandoc] -> ShowS
    Pandoc -> String
    (Int -> Pandoc -> ShowS)
    -> (Pandoc -> String) -> ([Pandoc] -> ShowS) -> Show Pandoc
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Pandoc -> ShowS
    showsPrec :: Int -> Pandoc -> ShowS
    $cshow :: Pandoc -> String
    show :: Pandoc -> String
    $cshowList :: [Pandoc] -> ShowS
    showList :: [Pandoc] -> ShowS
    Show, Typeable, Typeable Pandoc
    Typeable Pandoc =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Pandoc -> c Pandoc)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Pandoc)
    -> (Pandoc -> Constr)
    -> (Pandoc -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Pandoc))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pandoc))
    -> ((forall b. Data b => b -> b) -> Pandoc -> Pandoc)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Pandoc -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Pandoc -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Pandoc -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Pandoc -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc)
    -> Data Pandoc
    Pandoc -> Constr
    Pandoc -> DataType
    (forall b. Data b => b -> b) -> Pandoc -> Pandoc
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Pandoc -> u
    forall u. (forall d. Data d => d -> u) -> Pandoc -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pandoc -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pandoc -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pandoc
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pandoc -> c Pandoc
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pandoc)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pandoc)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pandoc -> c Pandoc
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pandoc -> c Pandoc
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pandoc
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pandoc
    $ctoConstr :: Pandoc -> Constr
    toConstr :: Pandoc -> Constr
    $cdataTypeOf :: Pandoc -> DataType
    dataTypeOf :: Pandoc -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pandoc)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pandoc)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pandoc)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pandoc)
    $cgmapT :: (forall b. Data b => b -> b) -> Pandoc -> Pandoc
    gmapT :: (forall b. Data b => b -> b) -> Pandoc -> Pandoc
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pandoc -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pandoc -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pandoc -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pandoc -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pandoc -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Pandoc -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pandoc -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pandoc -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pandoc -> m Pandoc
    Data, (forall x. Pandoc -> Rep Pandoc x)
    -> (forall x. Rep Pandoc x -> Pandoc) -> Generic Pandoc
    forall x. Rep Pandoc x -> Pandoc
    forall x. Pandoc -> Rep Pandoc x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Pandoc -> Rep Pandoc x
    from :: forall x. Pandoc -> Rep Pandoc x
    $cto :: forall x. Rep Pandoc x -> Pandoc
    to :: forall x. Rep Pandoc x -> Pandoc
    Generic)

    instance Semigroup Pandoc where
      (Pandoc Meta
    m1 [Block]
    bs1) <> :: Pandoc -> Pandoc -> Pandoc
    <> (Pandoc Meta
    m2 [Block]
    bs2) =
        Meta -> [Block] -> Pandoc
    Pandoc (Meta
    m1 Meta -> Meta -> Meta
    forall a. Semigroup a => a -> a -> a
    <> Meta
    m2) ([Block]
    bs1 [Block] -> [Block] -> [Block]
    forall a. Semigroup a => a -> a -> a
    <> [Block]
    bs2)
    instance Monoid Pandoc where
      mempty :: Pandoc
    mempty = Meta -> [Block] -> Pandoc
    Pandoc Meta
    forall a. Monoid a => a
    mempty [Block]
    forall a. Monoid a => a
    mempty
      mappend :: Pandoc -> Pandoc -> Pandoc
    mappend = Pandoc -> Pandoc -> Pandoc
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | Metadata for the document:  title, authors, date.
    newtype Meta = Meta { Meta -> Map Text MetaValue
    unMeta :: M.Map Text MetaValue }
                   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, Eq Meta
    Eq Meta =>
    (Meta -> Meta -> Ordering)
    -> (Meta -> Meta -> Bool)
    -> (Meta -> Meta -> Bool)
    -> (Meta -> Meta -> Bool)
    -> (Meta -> Meta -> Bool)
    -> (Meta -> Meta -> Meta)
    -> (Meta -> Meta -> Meta)
    -> Ord Meta
    Meta -> Meta -> Bool
    Meta -> Meta -> Ordering
    Meta -> Meta -> Meta
    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 :: Meta -> Meta -> Ordering
    compare :: Meta -> Meta -> Ordering
    $c< :: Meta -> Meta -> Bool
    < :: Meta -> Meta -> Bool
    $c<= :: Meta -> Meta -> Bool
    <= :: Meta -> Meta -> Bool
    $c> :: Meta -> Meta -> Bool
    > :: Meta -> Meta -> Bool
    $c>= :: Meta -> Meta -> Bool
    >= :: Meta -> Meta -> Bool
    $cmax :: Meta -> Meta -> Meta
    max :: Meta -> Meta -> Meta
    $cmin :: Meta -> Meta -> Meta
    min :: Meta -> Meta -> Meta
    Ord, Int -> Meta -> ShowS
    [Meta] -> ShowS
    Meta -> String
    (Int -> Meta -> ShowS)
    -> (Meta -> String) -> ([Meta] -> ShowS) -> Show Meta
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Meta -> ShowS
    showsPrec :: Int -> Meta -> ShowS
    $cshow :: Meta -> String
    show :: Meta -> String
    $cshowList :: [Meta] -> ShowS
    showList :: [Meta] -> ShowS
    Show, ReadPrec [Meta]
    ReadPrec Meta
    Int -> ReadS Meta
    ReadS [Meta]
    (Int -> ReadS Meta)
    -> ReadS [Meta] -> ReadPrec Meta -> ReadPrec [Meta] -> Read Meta
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Meta
    readsPrec :: Int -> ReadS Meta
    $creadList :: ReadS [Meta]
    readList :: ReadS [Meta]
    $creadPrec :: ReadPrec Meta
    readPrec :: ReadPrec Meta
    $creadListPrec :: ReadPrec [Meta]
    readListPrec :: ReadPrec [Meta]
    Read, Typeable, Typeable Meta
    Typeable Meta =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Meta -> c Meta)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Meta)
    -> (Meta -> Constr)
    -> (Meta -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Meta))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Meta))
    -> ((forall b. Data b => b -> b) -> Meta -> Meta)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Meta -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Meta -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Meta -> m Meta)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Meta -> m Meta)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Meta -> m Meta)
    -> Data Meta
    Meta -> Constr
    Meta -> DataType
    (forall b. Data b => b -> b) -> Meta -> Meta
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Meta -> u
    forall u. (forall d. Data d => d -> u) -> Meta -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Meta
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Meta -> c Meta
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Meta)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Meta)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Meta -> c Meta
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Meta -> c Meta
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Meta
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Meta
    $ctoConstr :: Meta -> Constr
    toConstr :: Meta -> Constr
    $cdataTypeOf :: Meta -> DataType
    dataTypeOf :: Meta -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Meta)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Meta)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Meta)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Meta)
    $cgmapT :: (forall b. Data b => b -> b) -> Meta -> Meta
    gmapT :: (forall b. Data b => b -> b) -> Meta -> Meta
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Meta -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Meta -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Meta -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Meta -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    Data, (forall x. Meta -> Rep Meta x)
    -> (forall x. Rep Meta x -> Meta) -> Generic Meta
    forall x. Rep Meta x -> Meta
    forall x. Meta -> Rep Meta x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Meta -> Rep Meta x
    from :: forall x. Meta -> Rep Meta x
    $cto :: forall x. Rep Meta x -> Meta
    to :: forall x. Rep Meta x -> Meta
    Generic)

    instance Semigroup Meta where
      (Meta Map Text MetaValue
    m1) <> :: Meta -> Meta -> Meta
    <> (Meta Map Text MetaValue
    m2) = Map Text MetaValue -> Meta
    Meta (Map Text MetaValue -> Map Text MetaValue -> Map Text MetaValue
    forall k a. Ord k => Map k a -> Map k a -> Map k a
    M.union Map Text MetaValue
    m2 Map Text MetaValue
    m1)
      -- note: M.union is left-biased, so if there are fields in both m2
      -- and m1, m2 wins.
    instance Monoid Meta where
      mempty :: Meta
    mempty = Map Text MetaValue -> Meta
    Meta Map Text MetaValue
    forall k a. Map k a
    M.empty
      mappend :: Meta -> Meta -> Meta
    mappend = Meta -> Meta -> Meta
    forall a. Semigroup a => a -> a -> a
    (<>)

    data MetaValue = MetaMap (M.Map Text MetaValue)
                   | MetaList [MetaValue]
                   | MetaBool Bool
                   | MetaString Text
                   | MetaInlines [Inline]
                   | MetaBlocks [Block]
                   deriving (MetaValue -> MetaValue -> Bool
    (MetaValue -> MetaValue -> Bool)
    -> (MetaValue -> MetaValue -> Bool) -> Eq MetaValue
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MetaValue -> MetaValue -> Bool
    == :: MetaValue -> MetaValue -> Bool
    $c/= :: MetaValue -> MetaValue -> Bool
    /= :: MetaValue -> MetaValue -> Bool
    Eq, Eq MetaValue
    Eq MetaValue =>
    (MetaValue -> MetaValue -> Ordering)
    -> (MetaValue -> MetaValue -> Bool)
    -> (MetaValue -> MetaValue -> Bool)
    -> (MetaValue -> MetaValue -> Bool)
    -> (MetaValue -> MetaValue -> Bool)
    -> (MetaValue -> MetaValue -> MetaValue)
    -> (MetaValue -> MetaValue -> MetaValue)
    -> Ord MetaValue
    MetaValue -> MetaValue -> Bool
    MetaValue -> MetaValue -> Ordering
    MetaValue -> MetaValue -> MetaValue
    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 :: MetaValue -> MetaValue -> Ordering
    compare :: MetaValue -> MetaValue -> Ordering
    $c< :: MetaValue -> MetaValue -> Bool
    < :: MetaValue -> MetaValue -> Bool
    $c<= :: MetaValue -> MetaValue -> Bool
    <= :: MetaValue -> MetaValue -> Bool
    $c> :: MetaValue -> MetaValue -> Bool
    > :: MetaValue -> MetaValue -> Bool
    $c>= :: MetaValue -> MetaValue -> Bool
    >= :: MetaValue -> MetaValue -> Bool
    $cmax :: MetaValue -> MetaValue -> MetaValue
    max :: MetaValue -> MetaValue -> MetaValue
    $cmin :: MetaValue -> MetaValue -> MetaValue
    min :: MetaValue -> MetaValue -> MetaValue
    Ord, Int -> MetaValue -> ShowS
    [MetaValue] -> ShowS
    MetaValue -> String
    (Int -> MetaValue -> ShowS)
    -> (MetaValue -> String)
    -> ([MetaValue] -> ShowS)
    -> Show MetaValue
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MetaValue -> ShowS
    showsPrec :: Int -> MetaValue -> ShowS
    $cshow :: MetaValue -> String
    show :: MetaValue -> String
    $cshowList :: [MetaValue] -> ShowS
    showList :: [MetaValue] -> ShowS
    Show, ReadPrec [MetaValue]
    ReadPrec MetaValue
    Int -> ReadS MetaValue
    ReadS [MetaValue]
    (Int -> ReadS MetaValue)
    -> ReadS [MetaValue]
    -> ReadPrec MetaValue
    -> ReadPrec [MetaValue]
    -> Read MetaValue
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS MetaValue
    readsPrec :: Int -> ReadS MetaValue
    $creadList :: ReadS [MetaValue]
    readList :: ReadS [MetaValue]
    $creadPrec :: ReadPrec MetaValue
    readPrec :: ReadPrec MetaValue
    $creadListPrec :: ReadPrec [MetaValue]
    readListPrec :: ReadPrec [MetaValue]
    Read, Typeable, Typeable MetaValue
    Typeable MetaValue =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> MetaValue -> c MetaValue)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c MetaValue)
    -> (MetaValue -> Constr)
    -> (MetaValue -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c MetaValue))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaValue))
    -> ((forall b. Data b => b -> b) -> MetaValue -> MetaValue)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> MetaValue -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> MetaValue -> r)
    -> (forall u. (forall d. Data d => d -> u) -> MetaValue -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> MetaValue -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue)
    -> Data MetaValue
    MetaValue -> Constr
    MetaValue -> DataType
    (forall b. Data b => b -> b) -> MetaValue -> MetaValue
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> MetaValue -> u
    forall u. (forall d. Data d => d -> u) -> MetaValue -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaValue -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaValue -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaValue
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MetaValue -> c MetaValue
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaValue)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaValue)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MetaValue -> c MetaValue
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MetaValue -> c MetaValue
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaValue
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaValue
    $ctoConstr :: MetaValue -> Constr
    toConstr :: MetaValue -> Constr
    $cdataTypeOf :: MetaValue -> DataType
    dataTypeOf :: MetaValue -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaValue)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaValue)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaValue)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaValue)
    $cgmapT :: (forall b. Data b => b -> b) -> MetaValue -> MetaValue
    gmapT :: (forall b. Data b => b -> b) -> MetaValue -> MetaValue
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaValue -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaValue -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaValue -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaValue -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> MetaValue -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> MetaValue -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MetaValue -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MetaValue -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaValue -> m MetaValue
    Data, (forall x. MetaValue -> Rep MetaValue x)
    -> (forall x. Rep MetaValue x -> MetaValue) -> Generic MetaValue
    forall x. Rep MetaValue x -> MetaValue
    forall x. MetaValue -> Rep MetaValue x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. MetaValue -> Rep MetaValue x
    from :: forall x. MetaValue -> Rep MetaValue x
    $cto :: forall x. Rep MetaValue x -> MetaValue
    to :: forall x. Rep MetaValue x -> MetaValue
    Generic)

    nullMeta :: Meta
    nullMeta :: Meta
    nullMeta = Map Text MetaValue -> Meta
    Meta Map Text MetaValue
    forall k a. Map k a
    M.empty

    isNullMeta :: Meta -> Bool
    isNullMeta :: Meta -> Bool
    isNullMeta (Meta Map Text MetaValue
    m) = Map Text MetaValue -> Bool
    forall k a. Map k a -> Bool
    M.null Map Text MetaValue
    m

    -- Helper functions to extract metadata

    -- | Retrieve the metadata value for a given @key@.
    lookupMeta :: Text -> Meta -> Maybe MetaValue
    lookupMeta :: Text -> Meta -> Maybe MetaValue
    lookupMeta Text
    key (Meta Map Text MetaValue
    m) = Text -> Map Text MetaValue -> Maybe MetaValue
    forall k a. Ord k => k -> Map k a -> Maybe a
    M.lookup Text
    key Map Text MetaValue
    m

    -- | Extract document title from metadata; works just like the old @docTitle@.
    docTitle :: Meta -> [Inline]
    docTitle :: Meta -> [Inline]
    docTitle Meta
    meta =
      case Text -> Meta -> Maybe MetaValue
    lookupMeta Text
    "title" Meta
    meta of
             Just (MetaString Text
    s)           -> [Text -> Inline
    Str Text
    s]
             Just (MetaInlines [Inline]
    ils)        -> [Inline]
    ils
             Just (MetaBlocks [Plain [Inline]
    ils]) -> [Inline]
    ils
             Just (MetaBlocks [Para [Inline]
    ils])  -> [Inline]
    ils
             Maybe MetaValue
    _                             -> []

    -- | Extract document authors from metadata; works just like the old
    -- @docAuthors@.
    docAuthors :: Meta -> [[Inline]]
    docAuthors :: Meta -> [[Inline]]
    docAuthors Meta
    meta =
      case Text -> Meta -> Maybe MetaValue
    lookupMeta Text
    "author" Meta
    meta of
            Just (MetaString Text
    s)    -> [[Text -> Inline
    Str Text
    s]]
            Just (MetaInlines [Inline]
    ils) -> [[Inline]
    ils]
            Just (MetaList   [MetaValue]
    ms)   -> [[Inline]
    ils | MetaInlines [Inline]
    ils <- [MetaValue]
    ms] [[Inline]] -> [[Inline]] -> [[Inline]]
    forall a. [a] -> [a] -> [a]
    ++
                                      [[Inline]
    ils | MetaBlocks [Plain [Inline]
    ils] <- [MetaValue]
    ms] [[Inline]] -> [[Inline]] -> [[Inline]]
    forall a. [a] -> [a] -> [a]
    ++
                                      [[Inline]
    ils | MetaBlocks [Para [Inline]
    ils]  <- [MetaValue]
    ms] [[Inline]] -> [[Inline]] -> [[Inline]]
    forall a. [a] -> [a] -> [a]
    ++
                                      [[Text -> Inline
    Str Text
    x] | MetaString Text
    x <- [MetaValue]
    ms]
            Maybe MetaValue
    _                      -> []

    -- | Extract date from metadata; works just like the old @docDate@.
    docDate :: Meta -> [Inline]
    docDate :: Meta -> [Inline]
    docDate Meta
    meta =
      case Text -> Meta -> Maybe MetaValue
    lookupMeta Text
    "date" Meta
    meta of
             Just (MetaString Text
    s)           -> [Text -> Inline
    Str Text
    s]
             Just (MetaInlines [Inline]
    ils)        -> [Inline]
    ils
             Just (MetaBlocks [Plain [Inline]
    ils]) -> [Inline]
    ils
             Just (MetaBlocks [Para [Inline]
    ils])  -> [Inline]
    ils
             Maybe MetaValue
    _                             -> []

    -- | List attributes.  The first element of the triple is the
    -- start number of the list.
    type ListAttributes = (Int, ListNumberStyle, ListNumberDelim)

    -- | Style of list numbers.
    data ListNumberStyle = DefaultStyle
                         | Example
                         | Decimal
                         | LowerRoman
                         | UpperRoman
                         | LowerAlpha
                         | UpperAlpha deriving (ListNumberStyle -> ListNumberStyle -> Bool
    (ListNumberStyle -> ListNumberStyle -> Bool)
    -> (ListNumberStyle -> ListNumberStyle -> Bool)
    -> Eq ListNumberStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ListNumberStyle -> ListNumberStyle -> Bool
    == :: ListNumberStyle -> ListNumberStyle -> Bool
    $c/= :: ListNumberStyle -> ListNumberStyle -> Bool
    /= :: ListNumberStyle -> ListNumberStyle -> Bool
    Eq, Eq ListNumberStyle
    Eq ListNumberStyle =>
    (ListNumberStyle -> ListNumberStyle -> Ordering)
    -> (ListNumberStyle -> ListNumberStyle -> Bool)
    -> (ListNumberStyle -> ListNumberStyle -> Bool)
    -> (ListNumberStyle -> ListNumberStyle -> Bool)
    -> (ListNumberStyle -> ListNumberStyle -> Bool)
    -> (ListNumberStyle -> ListNumberStyle -> ListNumberStyle)
    -> (ListNumberStyle -> ListNumberStyle -> ListNumberStyle)
    -> Ord ListNumberStyle
    ListNumberStyle -> ListNumberStyle -> Bool
    ListNumberStyle -> ListNumberStyle -> Ordering
    ListNumberStyle -> ListNumberStyle -> ListNumberStyle
    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 :: ListNumberStyle -> ListNumberStyle -> Ordering
    compare :: ListNumberStyle -> ListNumberStyle -> Ordering
    $c< :: ListNumberStyle -> ListNumberStyle -> Bool
    < :: ListNumberStyle -> ListNumberStyle -> Bool
    $c<= :: ListNumberStyle -> ListNumberStyle -> Bool
    <= :: ListNumberStyle -> ListNumberStyle -> Bool
    $c> :: ListNumberStyle -> ListNumberStyle -> Bool
    > :: ListNumberStyle -> ListNumberStyle -> Bool
    $c>= :: ListNumberStyle -> ListNumberStyle -> Bool
    >= :: ListNumberStyle -> ListNumberStyle -> Bool
    $cmax :: ListNumberStyle -> ListNumberStyle -> ListNumberStyle
    max :: ListNumberStyle -> ListNumberStyle -> ListNumberStyle
    $cmin :: ListNumberStyle -> ListNumberStyle -> ListNumberStyle
    min :: ListNumberStyle -> ListNumberStyle -> ListNumberStyle
    Ord, Int -> ListNumberStyle -> ShowS
    [ListNumberStyle] -> ShowS
    ListNumberStyle -> String
    (Int -> ListNumberStyle -> ShowS)
    -> (ListNumberStyle -> String)
    -> ([ListNumberStyle] -> ShowS)
    -> Show ListNumberStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ListNumberStyle -> ShowS
    showsPrec :: Int -> ListNumberStyle -> ShowS
    $cshow :: ListNumberStyle -> String
    show :: ListNumberStyle -> String
    $cshowList :: [ListNumberStyle] -> ShowS
    showList :: [ListNumberStyle] -> ShowS
    Show, ReadPrec [ListNumberStyle]
    ReadPrec ListNumberStyle
    Int -> ReadS ListNumberStyle
    ReadS [ListNumberStyle]
    (Int -> ReadS ListNumberStyle)
    -> ReadS [ListNumberStyle]
    -> ReadPrec ListNumberStyle
    -> ReadPrec [ListNumberStyle]
    -> Read ListNumberStyle
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS ListNumberStyle
    readsPrec :: Int -> ReadS ListNumberStyle
    $creadList :: ReadS [ListNumberStyle]
    readList :: ReadS [ListNumberStyle]
    $creadPrec :: ReadPrec ListNumberStyle
    readPrec :: ReadPrec ListNumberStyle
    $creadListPrec :: ReadPrec [ListNumberStyle]
    readListPrec :: ReadPrec [ListNumberStyle]
    Read, Typeable, Typeable ListNumberStyle
    Typeable ListNumberStyle =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ListNumberStyle -> c ListNumberStyle)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ListNumberStyle)
    -> (ListNumberStyle -> Constr)
    -> (ListNumberStyle -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ListNumberStyle))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ListNumberStyle))
    -> ((forall b. Data b => b -> b)
        -> ListNumberStyle -> ListNumberStyle)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ListNumberStyle -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ListNumberStyle -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> ListNumberStyle -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ListNumberStyle -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> ListNumberStyle -> m ListNumberStyle)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ListNumberStyle -> m ListNumberStyle)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ListNumberStyle -> m ListNumberStyle)
    -> Data ListNumberStyle
    ListNumberStyle -> Constr
    ListNumberStyle -> DataType
    (forall b. Data b => b -> b) -> ListNumberStyle -> ListNumberStyle
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> ListNumberStyle -> u
    forall u. (forall d. Data d => d -> u) -> ListNumberStyle -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberStyle -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberStyle -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ListNumberStyle -> m ListNumberStyle
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberStyle -> m ListNumberStyle
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListNumberStyle
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListNumberStyle -> c ListNumberStyle
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListNumberStyle)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ListNumberStyle)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListNumberStyle -> c ListNumberStyle
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListNumberStyle -> c ListNumberStyle
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListNumberStyle
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListNumberStyle
    $ctoConstr :: ListNumberStyle -> Constr
    toConstr :: ListNumberStyle -> Constr
    $cdataTypeOf :: ListNumberStyle -> DataType
    dataTypeOf :: ListNumberStyle -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListNumberStyle)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListNumberStyle)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ListNumberStyle)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ListNumberStyle)
    $cgmapT :: (forall b. Data b => b -> b) -> ListNumberStyle -> ListNumberStyle
    gmapT :: (forall b. Data b => b -> b) -> ListNumberStyle -> ListNumberStyle
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberStyle -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberStyle -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberStyle -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberStyle -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ListNumberStyle -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ListNumberStyle -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ListNumberStyle -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ListNumberStyle -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ListNumberStyle -> m ListNumberStyle
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ListNumberStyle -> m ListNumberStyle
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberStyle -> m ListNumberStyle
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberStyle -> m ListNumberStyle
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberStyle -> m ListNumberStyle
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberStyle -> m ListNumberStyle
    Data, (forall x. ListNumberStyle -> Rep ListNumberStyle x)
    -> (forall x. Rep ListNumberStyle x -> ListNumberStyle)
    -> Generic ListNumberStyle
    forall x. Rep ListNumberStyle x -> ListNumberStyle
    forall x. ListNumberStyle -> Rep ListNumberStyle x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ListNumberStyle -> Rep ListNumberStyle x
    from :: forall x. ListNumberStyle -> Rep ListNumberStyle x
    $cto :: forall x. Rep ListNumberStyle x -> ListNumberStyle
    to :: forall x. Rep ListNumberStyle x -> ListNumberStyle
    Generic)

    -- | Delimiter of list numbers.
    data ListNumberDelim = DefaultDelim
                         | Period
                         | OneParen
                         | TwoParens deriving (ListNumberDelim -> ListNumberDelim -> Bool
    (ListNumberDelim -> ListNumberDelim -> Bool)
    -> (ListNumberDelim -> ListNumberDelim -> Bool)
    -> Eq ListNumberDelim
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ListNumberDelim -> ListNumberDelim -> Bool
    == :: ListNumberDelim -> ListNumberDelim -> Bool
    $c/= :: ListNumberDelim -> ListNumberDelim -> Bool
    /= :: ListNumberDelim -> ListNumberDelim -> Bool
    Eq, Eq ListNumberDelim
    Eq ListNumberDelim =>
    (ListNumberDelim -> ListNumberDelim -> Ordering)
    -> (ListNumberDelim -> ListNumberDelim -> Bool)
    -> (ListNumberDelim -> ListNumberDelim -> Bool)
    -> (ListNumberDelim -> ListNumberDelim -> Bool)
    -> (ListNumberDelim -> ListNumberDelim -> Bool)
    -> (ListNumberDelim -> ListNumberDelim -> ListNumberDelim)
    -> (ListNumberDelim -> ListNumberDelim -> ListNumberDelim)
    -> Ord ListNumberDelim
    ListNumberDelim -> ListNumberDelim -> Bool
    ListNumberDelim -> ListNumberDelim -> Ordering
    ListNumberDelim -> ListNumberDelim -> ListNumberDelim
    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 :: ListNumberDelim -> ListNumberDelim -> Ordering
    compare :: ListNumberDelim -> ListNumberDelim -> Ordering
    $c< :: ListNumberDelim -> ListNumberDelim -> Bool
    < :: ListNumberDelim -> ListNumberDelim -> Bool
    $c<= :: ListNumberDelim -> ListNumberDelim -> Bool
    <= :: ListNumberDelim -> ListNumberDelim -> Bool
    $c> :: ListNumberDelim -> ListNumberDelim -> Bool
    > :: ListNumberDelim -> ListNumberDelim -> Bool
    $c>= :: ListNumberDelim -> ListNumberDelim -> Bool
    >= :: ListNumberDelim -> ListNumberDelim -> Bool
    $cmax :: ListNumberDelim -> ListNumberDelim -> ListNumberDelim
    max :: ListNumberDelim -> ListNumberDelim -> ListNumberDelim
    $cmin :: ListNumberDelim -> ListNumberDelim -> ListNumberDelim
    min :: ListNumberDelim -> ListNumberDelim -> ListNumberDelim
    Ord, Int -> ListNumberDelim -> ShowS
    [ListNumberDelim] -> ShowS
    ListNumberDelim -> String
    (Int -> ListNumberDelim -> ShowS)
    -> (ListNumberDelim -> String)
    -> ([ListNumberDelim] -> ShowS)
    -> Show ListNumberDelim
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ListNumberDelim -> ShowS
    showsPrec :: Int -> ListNumberDelim -> ShowS
    $cshow :: ListNumberDelim -> String
    show :: ListNumberDelim -> String
    $cshowList :: [ListNumberDelim] -> ShowS
    showList :: [ListNumberDelim] -> ShowS
    Show, ReadPrec [ListNumberDelim]
    ReadPrec ListNumberDelim
    Int -> ReadS ListNumberDelim
    ReadS [ListNumberDelim]
    (Int -> ReadS ListNumberDelim)
    -> ReadS [ListNumberDelim]
    -> ReadPrec ListNumberDelim
    -> ReadPrec [ListNumberDelim]
    -> Read ListNumberDelim
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS ListNumberDelim
    readsPrec :: Int -> ReadS ListNumberDelim
    $creadList :: ReadS [ListNumberDelim]
    readList :: ReadS [ListNumberDelim]
    $creadPrec :: ReadPrec ListNumberDelim
    readPrec :: ReadPrec ListNumberDelim
    $creadListPrec :: ReadPrec [ListNumberDelim]
    readListPrec :: ReadPrec [ListNumberDelim]
    Read, Typeable, Typeable ListNumberDelim
    Typeable ListNumberDelim =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ListNumberDelim -> c ListNumberDelim)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ListNumberDelim)
    -> (ListNumberDelim -> Constr)
    -> (ListNumberDelim -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ListNumberDelim))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ListNumberDelim))
    -> ((forall b. Data b => b -> b)
        -> ListNumberDelim -> ListNumberDelim)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ListNumberDelim -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ListNumberDelim -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> ListNumberDelim -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ListNumberDelim -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> ListNumberDelim -> m ListNumberDelim)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ListNumberDelim -> m ListNumberDelim)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ListNumberDelim -> m ListNumberDelim)
    -> Data ListNumberDelim
    ListNumberDelim -> Constr
    ListNumberDelim -> DataType
    (forall b. Data b => b -> b) -> ListNumberDelim -> ListNumberDelim
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> ListNumberDelim -> u
    forall u. (forall d. Data d => d -> u) -> ListNumberDelim -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberDelim -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberDelim -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ListNumberDelim -> m ListNumberDelim
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberDelim -> m ListNumberDelim
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListNumberDelim
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListNumberDelim -> c ListNumberDelim
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListNumberDelim)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ListNumberDelim)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListNumberDelim -> c ListNumberDelim
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListNumberDelim -> c ListNumberDelim
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListNumberDelim
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListNumberDelim
    $ctoConstr :: ListNumberDelim -> Constr
    toConstr :: ListNumberDelim -> Constr
    $cdataTypeOf :: ListNumberDelim -> DataType
    dataTypeOf :: ListNumberDelim -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListNumberDelim)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListNumberDelim)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ListNumberDelim)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ListNumberDelim)
    $cgmapT :: (forall b. Data b => b -> b) -> ListNumberDelim -> ListNumberDelim
    gmapT :: (forall b. Data b => b -> b) -> ListNumberDelim -> ListNumberDelim
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberDelim -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberDelim -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberDelim -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListNumberDelim -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ListNumberDelim -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ListNumberDelim -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ListNumberDelim -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ListNumberDelim -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ListNumberDelim -> m ListNumberDelim
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ListNumberDelim -> m ListNumberDelim
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberDelim -> m ListNumberDelim
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberDelim -> m ListNumberDelim
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberDelim -> m ListNumberDelim
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListNumberDelim -> m ListNumberDelim
    Data, (forall x. ListNumberDelim -> Rep ListNumberDelim x)
    -> (forall x. Rep ListNumberDelim x -> ListNumberDelim)
    -> Generic ListNumberDelim
    forall x. Rep ListNumberDelim x -> ListNumberDelim
    forall x. ListNumberDelim -> Rep ListNumberDelim x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ListNumberDelim -> Rep ListNumberDelim x
    from :: forall x. ListNumberDelim -> Rep ListNumberDelim x
    $cto :: forall x. Rep ListNumberDelim x -> ListNumberDelim
    to :: forall x. Rep ListNumberDelim x -> ListNumberDelim
    Generic)

    -- | Attributes: identifier, classes, key-value pairs
    type Attr = (Text, [Text], [(Text, Text)])

    nullAttr :: Attr
    nullAttr :: Attr
    nullAttr = (Text
    "",[],[])

    -- | Formats for raw blocks
    newtype Format = Format Text
                   deriving (ReadPrec [Format]
    ReadPrec Format
    Int -> ReadS Format
    ReadS [Format]
    (Int -> ReadS Format)
    -> ReadS [Format]
    -> ReadPrec Format
    -> ReadPrec [Format]
    -> Read Format
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Format
    readsPrec :: Int -> ReadS Format
    $creadList :: ReadS [Format]
    readList :: ReadS [Format]
    $creadPrec :: ReadPrec Format
    readPrec :: ReadPrec Format
    $creadListPrec :: ReadPrec [Format]
    readListPrec :: ReadPrec [Format]
    Read, Int -> Format -> ShowS
    [Format] -> ShowS
    Format -> String
    (Int -> Format -> ShowS)
    -> (Format -> String) -> ([Format] -> ShowS) -> Show Format
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Format -> ShowS
    showsPrec :: Int -> Format -> ShowS
    $cshow :: Format -> String
    show :: Format -> String
    $cshowList :: [Format] -> ShowS
    showList :: [Format] -> ShowS
    Show, Typeable, Typeable Format
    Typeable Format =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Format -> c Format)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Format)
    -> (Format -> Constr)
    -> (Format -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Format))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Format))
    -> ((forall b. Data b => b -> b) -> Format -> Format)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Format -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Format -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Format -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Format -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Format -> m Format)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Format -> m Format)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Format -> m Format)
    -> Data Format
    Format -> Constr
    Format -> DataType
    (forall b. Data b => b -> b) -> Format -> Format
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Format -> u
    forall u. (forall d. Data d => d -> u) -> Format -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Format -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Format -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Format -> m Format
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Format -> m Format
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Format
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Format -> c Format
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Format)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Format)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Format -> c Format
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Format -> c Format
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Format
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Format
    $ctoConstr :: Format -> Constr
    toConstr :: Format -> Constr
    $cdataTypeOf :: Format -> DataType
    dataTypeOf :: Format -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Format)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Format)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Format)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Format)
    $cgmapT :: (forall b. Data b => b -> b) -> Format -> Format
    gmapT :: (forall b. Data b => b -> b) -> Format -> Format
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Format -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Format -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Format -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Format -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Format -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Format -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Format -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Format -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Format -> m Format
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Format -> m Format
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Format -> m Format
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Format -> m Format
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Format -> m Format
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Format -> m Format
    Data, (forall x. Format -> Rep Format x)
    -> (forall x. Rep Format x -> Format) -> Generic Format
    forall x. Rep Format x -> Format
    forall x. Format -> Rep Format x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Format -> Rep Format x
    from :: forall x. Format -> Rep Format x
    $cto :: forall x. Rep Format x -> Format
    to :: forall x. Rep Format x -> Format
    Generic, [Format] -> Value
    [Format] -> Encoding
    Format -> Bool
    Format -> Value
    Format -> Encoding
    (Format -> Value)
    -> (Format -> Encoding)
    -> ([Format] -> Value)
    -> ([Format] -> Encoding)
    -> (Format -> Bool)
    -> ToJSON Format
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> (a -> Bool)
    -> ToJSON a
    $ctoJSON :: Format -> Value
    toJSON :: Format -> Value
    $ctoEncoding :: Format -> Encoding
    toEncoding :: Format -> Encoding
    $ctoJSONList :: [Format] -> Value
    toJSONList :: [Format] -> Value
    $ctoEncodingList :: [Format] -> Encoding
    toEncodingList :: [Format] -> Encoding
    $comitField :: Format -> Bool
    omitField :: Format -> Bool
    ToJSON, Maybe Format
    Value -> Parser [Format]
    Value -> Parser Format
    (Value -> Parser Format)
    -> (Value -> Parser [Format]) -> Maybe Format -> FromJSON Format
    forall a.
    (Value -> Parser a)
    -> (Value -> Parser [a]) -> Maybe a -> FromJSON a
    $cparseJSON :: Value -> Parser Format
    parseJSON :: Value -> Parser Format
    $cparseJSONList :: Value -> Parser [Format]
    parseJSONList :: Value -> Parser [Format]
    $comittedField :: Maybe Format
    omittedField :: Maybe Format
    FromJSON)

    instance IsString Format where
      fromString :: String -> Format
    fromString String
    f = Text -> Format
    Format (Text -> Format) -> Text -> Format
    forall a b. (a -> b) -> a -> b
    $ Text -> Text
    T.toCaseFold (Text -> Text) -> Text -> Text
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack String
    f

    instance Eq Format where
      Format Text
    x == :: Format -> Format -> Bool
    == Format Text
    y = Text -> Text
    T.toCaseFold Text
    x Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    == Text -> Text
    T.toCaseFold Text
    y

    instance Ord Format where
      compare :: Format -> Format -> Ordering
    compare (Format Text
    x) (Format Text
    y) = Text -> Text -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (Text -> Text
    T.toCaseFold Text
    x) (Text -> Text
    T.toCaseFold Text
    y)

    -- | The number of columns taken up by the row head of each row of a
    -- 'TableBody'. The row body takes up the remaining columns.
    newtype RowHeadColumns = RowHeadColumns Int
      deriving (RowHeadColumns -> RowHeadColumns -> Bool
    (RowHeadColumns -> RowHeadColumns -> Bool)
    -> (RowHeadColumns -> RowHeadColumns -> Bool) -> Eq RowHeadColumns
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RowHeadColumns -> RowHeadColumns -> Bool
    == :: RowHeadColumns -> RowHeadColumns -> Bool
    $c/= :: RowHeadColumns -> RowHeadColumns -> Bool
    /= :: RowHeadColumns -> RowHeadColumns -> Bool
    Eq, Eq RowHeadColumns
    Eq RowHeadColumns =>
    (RowHeadColumns -> RowHeadColumns -> Ordering)
    -> (RowHeadColumns -> RowHeadColumns -> Bool)
    -> (RowHeadColumns -> RowHeadColumns -> Bool)
    -> (RowHeadColumns -> RowHeadColumns -> Bool)
    -> (RowHeadColumns -> RowHeadColumns -> Bool)
    -> (RowHeadColumns -> RowHeadColumns -> RowHeadColumns)
    -> (RowHeadColumns -> RowHeadColumns -> RowHeadColumns)
    -> Ord RowHeadColumns
    RowHeadColumns -> RowHeadColumns -> Bool
    RowHeadColumns -> RowHeadColumns -> Ordering
    RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    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 :: RowHeadColumns -> RowHeadColumns -> Ordering
    compare :: RowHeadColumns -> RowHeadColumns -> Ordering
    $c< :: RowHeadColumns -> RowHeadColumns -> Bool
    < :: RowHeadColumns -> RowHeadColumns -> Bool
    $c<= :: RowHeadColumns -> RowHeadColumns -> Bool
    <= :: RowHeadColumns -> RowHeadColumns -> Bool
    $c> :: RowHeadColumns -> RowHeadColumns -> Bool
    > :: RowHeadColumns -> RowHeadColumns -> Bool
    $c>= :: RowHeadColumns -> RowHeadColumns -> Bool
    >= :: RowHeadColumns -> RowHeadColumns -> Bool
    $cmax :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    max :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    $cmin :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    min :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    Ord, Int -> RowHeadColumns -> ShowS
    [RowHeadColumns] -> ShowS
    RowHeadColumns -> String
    (Int -> RowHeadColumns -> ShowS)
    -> (RowHeadColumns -> String)
    -> ([RowHeadColumns] -> ShowS)
    -> Show RowHeadColumns
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RowHeadColumns -> ShowS
    showsPrec :: Int -> RowHeadColumns -> ShowS
    $cshow :: RowHeadColumns -> String
    show :: RowHeadColumns -> String
    $cshowList :: [RowHeadColumns] -> ShowS
    showList :: [RowHeadColumns] -> ShowS
    Show, ReadPrec [RowHeadColumns]
    ReadPrec RowHeadColumns
    Int -> ReadS RowHeadColumns
    ReadS [RowHeadColumns]
    (Int -> ReadS RowHeadColumns)
    -> ReadS [RowHeadColumns]
    -> ReadPrec RowHeadColumns
    -> ReadPrec [RowHeadColumns]
    -> Read RowHeadColumns
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS RowHeadColumns
    readsPrec :: Int -> ReadS RowHeadColumns
    $creadList :: ReadS [RowHeadColumns]
    readList :: ReadS [RowHeadColumns]
    $creadPrec :: ReadPrec RowHeadColumns
    readPrec :: ReadPrec RowHeadColumns
    $creadListPrec :: ReadPrec [RowHeadColumns]
    readListPrec :: ReadPrec [RowHeadColumns]
    Read, Typeable, Typeable RowHeadColumns
    Typeable RowHeadColumns =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> RowHeadColumns -> c RowHeadColumns)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c RowHeadColumns)
    -> (RowHeadColumns -> Constr)
    -> (RowHeadColumns -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c RowHeadColumns))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c RowHeadColumns))
    -> ((forall b. Data b => b -> b)
        -> RowHeadColumns -> RowHeadColumns)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RowHeadColumns -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RowHeadColumns -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> RowHeadColumns -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> RowHeadColumns -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> RowHeadColumns -> m RowHeadColumns)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> RowHeadColumns -> m RowHeadColumns)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> RowHeadColumns -> m RowHeadColumns)
    -> Data RowHeadColumns
    RowHeadColumns -> Constr
    RowHeadColumns -> DataType
    (forall b. Data b => b -> b) -> RowHeadColumns -> RowHeadColumns
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> RowHeadColumns -> u
    forall u. (forall d. Data d => d -> u) -> RowHeadColumns -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RowHeadColumns -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RowHeadColumns -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RowHeadColumns -> m RowHeadColumns
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RowHeadColumns -> m RowHeadColumns
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RowHeadColumns
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RowHeadColumns -> c RowHeadColumns
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RowHeadColumns)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RowHeadColumns)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RowHeadColumns -> c RowHeadColumns
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RowHeadColumns -> c RowHeadColumns
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RowHeadColumns
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RowHeadColumns
    $ctoConstr :: RowHeadColumns -> Constr
    toConstr :: RowHeadColumns -> Constr
    $cdataTypeOf :: RowHeadColumns -> DataType
    dataTypeOf :: RowHeadColumns -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RowHeadColumns)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RowHeadColumns)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RowHeadColumns)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RowHeadColumns)
    $cgmapT :: (forall b. Data b => b -> b) -> RowHeadColumns -> RowHeadColumns
    gmapT :: (forall b. Data b => b -> b) -> RowHeadColumns -> RowHeadColumns
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RowHeadColumns -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RowHeadColumns -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RowHeadColumns -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RowHeadColumns -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> RowHeadColumns -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RowHeadColumns -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> RowHeadColumns -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> RowHeadColumns -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RowHeadColumns -> m RowHeadColumns
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RowHeadColumns -> m RowHeadColumns
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RowHeadColumns -> m RowHeadColumns
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RowHeadColumns -> m RowHeadColumns
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RowHeadColumns -> m RowHeadColumns
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RowHeadColumns -> m RowHeadColumns
    Data, (forall x. RowHeadColumns -> Rep RowHeadColumns x)
    -> (forall x. Rep RowHeadColumns x -> RowHeadColumns)
    -> Generic RowHeadColumns
    forall x. Rep RowHeadColumns x -> RowHeadColumns
    forall x. RowHeadColumns -> Rep RowHeadColumns x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. RowHeadColumns -> Rep RowHeadColumns x
    from :: forall x. RowHeadColumns -> Rep RowHeadColumns x
    $cto :: forall x. Rep RowHeadColumns x -> RowHeadColumns
    to :: forall x. Rep RowHeadColumns x -> RowHeadColumns
    Generic, Integer -> RowHeadColumns
    RowHeadColumns -> RowHeadColumns
    RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    (RowHeadColumns -> RowHeadColumns -> RowHeadColumns)
    -> (RowHeadColumns -> RowHeadColumns -> RowHeadColumns)
    -> (RowHeadColumns -> RowHeadColumns -> RowHeadColumns)
    -> (RowHeadColumns -> RowHeadColumns)
    -> (RowHeadColumns -> RowHeadColumns)
    -> (RowHeadColumns -> RowHeadColumns)
    -> (Integer -> RowHeadColumns)
    -> Num RowHeadColumns
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    + :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    $c- :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    - :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    $c* :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    * :: RowHeadColumns -> RowHeadColumns -> RowHeadColumns
    $cnegate :: RowHeadColumns -> RowHeadColumns
    negate :: RowHeadColumns -> RowHeadColumns
    $cabs :: RowHeadColumns -> RowHeadColumns
    abs :: RowHeadColumns -> RowHeadColumns
    $csignum :: RowHeadColumns -> RowHeadColumns
    signum :: RowHeadColumns -> RowHeadColumns
    $cfromInteger :: Integer -> RowHeadColumns
    fromInteger :: Integer -> RowHeadColumns
    Num, Int -> RowHeadColumns
    RowHeadColumns -> Int
    RowHeadColumns -> [RowHeadColumns]
    RowHeadColumns -> RowHeadColumns
    RowHeadColumns -> RowHeadColumns -> [RowHeadColumns]
    RowHeadColumns
    -> RowHeadColumns -> RowHeadColumns -> [RowHeadColumns]
    (RowHeadColumns -> RowHeadColumns)
    -> (RowHeadColumns -> RowHeadColumns)
    -> (Int -> RowHeadColumns)
    -> (RowHeadColumns -> Int)
    -> (RowHeadColumns -> [RowHeadColumns])
    -> (RowHeadColumns -> RowHeadColumns -> [RowHeadColumns])
    -> (RowHeadColumns -> RowHeadColumns -> [RowHeadColumns])
    -> (RowHeadColumns
        -> RowHeadColumns -> RowHeadColumns -> [RowHeadColumns])
    -> Enum RowHeadColumns
    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 :: RowHeadColumns -> RowHeadColumns
    succ :: RowHeadColumns -> RowHeadColumns
    $cpred :: RowHeadColumns -> RowHeadColumns
    pred :: RowHeadColumns -> RowHeadColumns
    $ctoEnum :: Int -> RowHeadColumns
    toEnum :: Int -> RowHeadColumns
    $cfromEnum :: RowHeadColumns -> Int
    fromEnum :: RowHeadColumns -> Int
    $cenumFrom :: RowHeadColumns -> [RowHeadColumns]
    enumFrom :: RowHeadColumns -> [RowHeadColumns]
    $cenumFromThen :: RowHeadColumns -> RowHeadColumns -> [RowHeadColumns]
    enumFromThen :: RowHeadColumns -> RowHeadColumns -> [RowHeadColumns]
    $cenumFromTo :: RowHeadColumns -> RowHeadColumns -> [RowHeadColumns]
    enumFromTo :: RowHeadColumns -> RowHeadColumns -> [RowHeadColumns]
    $cenumFromThenTo :: RowHeadColumns
    -> RowHeadColumns -> RowHeadColumns -> [RowHeadColumns]
    enumFromThenTo :: RowHeadColumns
    -> RowHeadColumns -> RowHeadColumns -> [RowHeadColumns]
    Enum, [RowHeadColumns] -> Value
    [RowHeadColumns] -> Encoding
    RowHeadColumns -> Bool
    RowHeadColumns -> Value
    RowHeadColumns -> Encoding
    (RowHeadColumns -> Value)
    -> (RowHeadColumns -> Encoding)
    -> ([RowHeadColumns] -> Value)
    -> ([RowHeadColumns] -> Encoding)
    -> (RowHeadColumns -> Bool)
    -> ToJSON RowHeadColumns
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> (a -> Bool)
    -> ToJSON a
    $ctoJSON :: RowHeadColumns -> Value
    toJSON :: RowHeadColumns -> Value
    $ctoEncoding :: RowHeadColumns -> Encoding
    toEncoding :: RowHeadColumns -> Encoding
    $ctoJSONList :: [RowHeadColumns] -> Value
    toJSONList :: [RowHeadColumns] -> Value
    $ctoEncodingList :: [RowHeadColumns] -> Encoding
    toEncodingList :: [RowHeadColumns] -> Encoding
    $comitField :: RowHeadColumns -> Bool
    omitField :: RowHeadColumns -> Bool
    ToJSON, Maybe RowHeadColumns
    Value -> Parser [RowHeadColumns]
    Value -> Parser RowHeadColumns
    (Value -> Parser RowHeadColumns)
    -> (Value -> Parser [RowHeadColumns])
    -> Maybe RowHeadColumns
    -> FromJSON RowHeadColumns
    forall a.
    (Value -> Parser a)
    -> (Value -> Parser [a]) -> Maybe a -> FromJSON a
    $cparseJSON :: Value -> Parser RowHeadColumns
    parseJSON :: Value -> Parser RowHeadColumns
    $cparseJSONList :: Value -> Parser [RowHeadColumns]
    parseJSONList :: Value -> Parser [RowHeadColumns]
    $comittedField :: Maybe RowHeadColumns
    omittedField :: Maybe RowHeadColumns
    FromJSON)

    -- | Alignment of a table column.
    data Alignment = AlignLeft
                   | AlignRight
                   | AlignCenter
                   | AlignDefault deriving (Alignment -> Alignment -> Bool
    (Alignment -> Alignment -> Bool)
    -> (Alignment -> Alignment -> Bool) -> Eq Alignment
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Alignment -> Alignment -> Bool
    == :: Alignment -> Alignment -> Bool
    $c/= :: Alignment -> Alignment -> Bool
    /= :: Alignment -> Alignment -> Bool
    Eq, Eq Alignment
    Eq Alignment =>
    (Alignment -> Alignment -> Ordering)
    -> (Alignment -> Alignment -> Bool)
    -> (Alignment -> Alignment -> Bool)
    -> (Alignment -> Alignment -> Bool)
    -> (Alignment -> Alignment -> Bool)
    -> (Alignment -> Alignment -> Alignment)
    -> (Alignment -> Alignment -> Alignment)
    -> Ord Alignment
    Alignment -> Alignment -> Bool
    Alignment -> Alignment -> Ordering
    Alignment -> Alignment -> Alignment
    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 :: Alignment -> Alignment -> Ordering
    compare :: Alignment -> Alignment -> Ordering
    $c< :: Alignment -> Alignment -> Bool
    < :: Alignment -> Alignment -> Bool
    $c<= :: Alignment -> Alignment -> Bool
    <= :: Alignment -> Alignment -> Bool
    $c> :: Alignment -> Alignment -> Bool
    > :: Alignment -> Alignment -> Bool
    $c>= :: Alignment -> Alignment -> Bool
    >= :: Alignment -> Alignment -> Bool
    $cmax :: Alignment -> Alignment -> Alignment
    max :: Alignment -> Alignment -> Alignment
    $cmin :: Alignment -> Alignment -> Alignment
    min :: Alignment -> Alignment -> Alignment
    Ord, Int -> Alignment -> ShowS
    [Alignment] -> ShowS
    Alignment -> String
    (Int -> Alignment -> ShowS)
    -> (Alignment -> String)
    -> ([Alignment] -> ShowS)
    -> Show Alignment
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Alignment -> ShowS
    showsPrec :: Int -> Alignment -> ShowS
    $cshow :: Alignment -> String
    show :: Alignment -> String
    $cshowList :: [Alignment] -> ShowS
    showList :: [Alignment] -> ShowS
    Show, ReadPrec [Alignment]
    ReadPrec Alignment
    Int -> ReadS Alignment
    ReadS [Alignment]
    (Int -> ReadS Alignment)
    -> ReadS [Alignment]
    -> ReadPrec Alignment
    -> ReadPrec [Alignment]
    -> Read Alignment
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Alignment
    readsPrec :: Int -> ReadS Alignment
    $creadList :: ReadS [Alignment]
    readList :: ReadS [Alignment]
    $creadPrec :: ReadPrec Alignment
    readPrec :: ReadPrec Alignment
    $creadListPrec :: ReadPrec [Alignment]
    readListPrec :: ReadPrec [Alignment]
    Read, Typeable, Typeable Alignment
    Typeable Alignment =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Alignment -> c Alignment)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Alignment)
    -> (Alignment -> Constr)
    -> (Alignment -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Alignment))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alignment))
    -> ((forall b. Data b => b -> b) -> Alignment -> Alignment)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Alignment -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Alignment -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Alignment -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Alignment -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Alignment -> m Alignment)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Alignment -> m Alignment)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Alignment -> m Alignment)
    -> Data Alignment
    Alignment -> Constr
    Alignment -> DataType
    (forall b. Data b => b -> b) -> Alignment -> Alignment
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Alignment -> u
    forall u. (forall d. Data d => d -> u) -> Alignment -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Alignment -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Alignment -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Alignment
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Alignment -> c Alignment
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Alignment)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alignment)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Alignment -> c Alignment
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Alignment -> c Alignment
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Alignment
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Alignment
    $ctoConstr :: Alignment -> Constr
    toConstr :: Alignment -> Constr
    $cdataTypeOf :: Alignment -> DataType
    dataTypeOf :: Alignment -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Alignment)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Alignment)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alignment)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alignment)
    $cgmapT :: (forall b. Data b => b -> b) -> Alignment -> Alignment
    gmapT :: (forall b. Data b => b -> b) -> Alignment -> Alignment
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Alignment -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Alignment -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Alignment -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Alignment -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Alignment -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Alignment -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Alignment -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Alignment -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment
    Data, (forall x. Alignment -> Rep Alignment x)
    -> (forall x. Rep Alignment x -> Alignment) -> Generic Alignment
    forall x. Rep Alignment x -> Alignment
    forall x. Alignment -> Rep Alignment x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Alignment -> Rep Alignment x
    from :: forall x. Alignment -> Rep Alignment x
    $cto :: forall x. Rep Alignment x -> Alignment
    to :: forall x. Rep Alignment x -> Alignment
    Generic)

    -- | The width of a table column, as a percentage of the text width.
    data ColWidth = ColWidth Double
                  | ColWidthDefault deriving (ColWidth -> ColWidth -> Bool
    (ColWidth -> ColWidth -> Bool)
    -> (ColWidth -> ColWidth -> Bool) -> Eq ColWidth
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ColWidth -> ColWidth -> Bool
    == :: ColWidth -> ColWidth -> Bool
    $c/= :: ColWidth -> ColWidth -> Bool
    /= :: ColWidth -> ColWidth -> Bool
    Eq, Eq ColWidth
    Eq ColWidth =>
    (ColWidth -> ColWidth -> Ordering)
    -> (ColWidth -> ColWidth -> Bool)
    -> (ColWidth -> ColWidth -> Bool)
    -> (ColWidth -> ColWidth -> Bool)
    -> (ColWidth -> ColWidth -> Bool)
    -> (ColWidth -> ColWidth -> ColWidth)
    -> (ColWidth -> ColWidth -> ColWidth)
    -> Ord ColWidth
    ColWidth -> ColWidth -> Bool
    ColWidth -> ColWidth -> Ordering
    ColWidth -> ColWidth -> ColWidth
    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 :: ColWidth -> ColWidth -> Ordering
    compare :: ColWidth -> ColWidth -> Ordering
    $c< :: ColWidth -> ColWidth -> Bool
    < :: ColWidth -> ColWidth -> Bool
    $c<= :: ColWidth -> ColWidth -> Bool
    <= :: ColWidth -> ColWidth -> Bool
    $c> :: ColWidth -> ColWidth -> Bool
    > :: ColWidth -> ColWidth -> Bool
    $c>= :: ColWidth -> ColWidth -> Bool
    >= :: ColWidth -> ColWidth -> Bool
    $cmax :: ColWidth -> ColWidth -> ColWidth
    max :: ColWidth -> ColWidth -> ColWidth
    $cmin :: ColWidth -> ColWidth -> ColWidth
    min :: ColWidth -> ColWidth -> ColWidth
    Ord, Int -> ColWidth -> ShowS
    [ColWidth] -> ShowS
    ColWidth -> String
    (Int -> ColWidth -> ShowS)
    -> (ColWidth -> String) -> ([ColWidth] -> ShowS) -> Show ColWidth
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ColWidth -> ShowS
    showsPrec :: Int -> ColWidth -> ShowS
    $cshow :: ColWidth -> String
    show :: ColWidth -> String
    $cshowList :: [ColWidth] -> ShowS
    showList :: [ColWidth] -> ShowS
    Show, ReadPrec [ColWidth]
    ReadPrec ColWidth
    Int -> ReadS ColWidth
    ReadS [ColWidth]
    (Int -> ReadS ColWidth)
    -> ReadS [ColWidth]
    -> ReadPrec ColWidth
    -> ReadPrec [ColWidth]
    -> Read ColWidth
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS ColWidth
    readsPrec :: Int -> ReadS ColWidth
    $creadList :: ReadS [ColWidth]
    readList :: ReadS [ColWidth]
    $creadPrec :: ReadPrec ColWidth
    readPrec :: ReadPrec ColWidth
    $creadListPrec :: ReadPrec [ColWidth]
    readListPrec :: ReadPrec [ColWidth]
    Read, Typeable, Typeable ColWidth
    Typeable ColWidth =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ColWidth -> c ColWidth)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ColWidth)
    -> (ColWidth -> Constr)
    -> (ColWidth -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ColWidth))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColWidth))
    -> ((forall b. Data b => b -> b) -> ColWidth -> ColWidth)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ColWidth -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ColWidth -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ColWidth -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> ColWidth -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth)
    -> Data ColWidth
    ColWidth -> Constr
    ColWidth -> DataType
    (forall b. Data b => b -> b) -> ColWidth -> ColWidth
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ColWidth -> u
    forall u. (forall d. Data d => d -> u) -> ColWidth -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColWidth -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColWidth -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColWidth
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColWidth -> c ColWidth
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColWidth)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColWidth)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColWidth -> c ColWidth
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColWidth -> c ColWidth
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColWidth
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColWidth
    $ctoConstr :: ColWidth -> Constr
    toConstr :: ColWidth -> Constr
    $cdataTypeOf :: ColWidth -> DataType
    dataTypeOf :: ColWidth -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColWidth)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColWidth)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColWidth)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColWidth)
    $cgmapT :: (forall b. Data b => b -> b) -> ColWidth -> ColWidth
    gmapT :: (forall b. Data b => b -> b) -> ColWidth -> ColWidth
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColWidth -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColWidth -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColWidth -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColWidth -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColWidth -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ColWidth -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColWidth -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColWidth -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColWidth -> m ColWidth
    Data, (forall x. ColWidth -> Rep ColWidth x)
    -> (forall x. Rep ColWidth x -> ColWidth) -> Generic ColWidth
    forall x. Rep ColWidth x -> ColWidth
    forall x. ColWidth -> Rep ColWidth x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ColWidth -> Rep ColWidth x
    from :: forall x. ColWidth -> Rep ColWidth x
    $cto :: forall x. Rep ColWidth x -> ColWidth
    to :: forall x. Rep ColWidth x -> ColWidth
    Generic)

    -- | The specification for a single table column.
    type ColSpec = (Alignment, ColWidth)

    -- | A table row.
    data Row = Row Attr [Cell]
      deriving (Row -> Row -> Bool
    (Row -> Row -> Bool) -> (Row -> Row -> Bool) -> Eq Row
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Row -> Row -> Bool
    == :: Row -> Row -> Bool
    $c/= :: Row -> Row -> Bool
    /= :: Row -> Row -> Bool
    Eq, Eq Row
    Eq Row =>
    (Row -> Row -> Ordering)
    -> (Row -> Row -> Bool)
    -> (Row -> Row -> Bool)
    -> (Row -> Row -> Bool)
    -> (Row -> Row -> Bool)
    -> (Row -> Row -> Row)
    -> (Row -> Row -> Row)
    -> Ord Row
    Row -> Row -> Bool
    Row -> Row -> Ordering
    Row -> Row -> Row
    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 :: Row -> Row -> Ordering
    compare :: Row -> Row -> Ordering
    $c< :: Row -> Row -> Bool
    < :: Row -> Row -> Bool
    $c<= :: Row -> Row -> Bool
    <= :: Row -> Row -> Bool
    $c> :: Row -> Row -> Bool
    > :: Row -> Row -> Bool
    $c>= :: Row -> Row -> Bool
    >= :: Row -> Row -> Bool
    $cmax :: Row -> Row -> Row
    max :: Row -> Row -> Row
    $cmin :: Row -> Row -> Row
    min :: Row -> Row -> Row
    Ord, Int -> Row -> ShowS
    [Row] -> ShowS
    Row -> String
    (Int -> Row -> ShowS)
    -> (Row -> String) -> ([Row] -> ShowS) -> Show Row
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Row -> ShowS
    showsPrec :: Int -> Row -> ShowS
    $cshow :: Row -> String
    show :: Row -> String
    $cshowList :: [Row] -> ShowS
    showList :: [Row] -> ShowS
    Show, ReadPrec [Row]
    ReadPrec Row
    Int -> ReadS Row
    ReadS [Row]
    (Int -> ReadS Row)
    -> ReadS [Row] -> ReadPrec Row -> ReadPrec [Row] -> Read Row
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Row
    readsPrec :: Int -> ReadS Row
    $creadList :: ReadS [Row]
    readList :: ReadS [Row]
    $creadPrec :: ReadPrec Row
    readPrec :: ReadPrec Row
    $creadListPrec :: ReadPrec [Row]
    readListPrec :: ReadPrec [Row]
    Read, Typeable, Typeable Row
    Typeable Row =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Row -> c Row)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Row)
    -> (Row -> Constr)
    -> (Row -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Row))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Row))
    -> ((forall b. Data b => b -> b) -> Row -> Row)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Row -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Row -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Row -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Row -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Row -> m Row)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Row -> m Row)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Row -> m Row)
    -> Data Row
    Row -> Constr
    Row -> DataType
    (forall b. Data b => b -> b) -> Row -> Row
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Row -> u
    forall u. (forall d. Data d => d -> u) -> Row -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Row -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Row -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Row -> m Row
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Row -> m Row
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Row
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Row -> c Row
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Row)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Row)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Row -> c Row
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Row -> c Row
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Row
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Row
    $ctoConstr :: Row -> Constr
    toConstr :: Row -> Constr
    $cdataTypeOf :: Row -> DataType
    dataTypeOf :: Row -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Row)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Row)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Row)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Row)
    $cgmapT :: (forall b. Data b => b -> b) -> Row -> Row
    gmapT :: (forall b. Data b => b -> b) -> Row -> Row
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Row -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Row -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Row -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Row -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Row -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Row -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Row -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Row -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Row -> m Row
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Row -> m Row
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Row -> m Row
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Row -> m Row
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Row -> m Row
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Row -> m Row
    Data, (forall x. Row -> Rep Row x)
    -> (forall x. Rep Row x -> Row) -> Generic Row
    forall x. Rep Row x -> Row
    forall x. Row -> Rep Row x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Row -> Rep Row x
    from :: forall x. Row -> Rep Row x
    $cto :: forall x. Rep Row x -> Row
    to :: forall x. Rep Row x -> Row
    Generic)

    -- | The head of a table.
    data TableHead = TableHead Attr [Row]
      deriving (TableHead -> TableHead -> Bool
    (TableHead -> TableHead -> Bool)
    -> (TableHead -> TableHead -> Bool) -> Eq TableHead
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TableHead -> TableHead -> Bool
    == :: TableHead -> TableHead -> Bool
    $c/= :: TableHead -> TableHead -> Bool
    /= :: TableHead -> TableHead -> Bool
    Eq, Eq TableHead
    Eq TableHead =>
    (TableHead -> TableHead -> Ordering)
    -> (TableHead -> TableHead -> Bool)
    -> (TableHead -> TableHead -> Bool)
    -> (TableHead -> TableHead -> Bool)
    -> (TableHead -> TableHead -> Bool)
    -> (TableHead -> TableHead -> TableHead)
    -> (TableHead -> TableHead -> TableHead)
    -> Ord TableHead
    TableHead -> TableHead -> Bool
    TableHead -> TableHead -> Ordering
    TableHead -> TableHead -> TableHead
    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 :: TableHead -> TableHead -> Ordering
    compare :: TableHead -> TableHead -> Ordering
    $c< :: TableHead -> TableHead -> Bool
    < :: TableHead -> TableHead -> Bool
    $c<= :: TableHead -> TableHead -> Bool
    <= :: TableHead -> TableHead -> Bool
    $c> :: TableHead -> TableHead -> Bool
    > :: TableHead -> TableHead -> Bool
    $c>= :: TableHead -> TableHead -> Bool
    >= :: TableHead -> TableHead -> Bool
    $cmax :: TableHead -> TableHead -> TableHead
    max :: TableHead -> TableHead -> TableHead
    $cmin :: TableHead -> TableHead -> TableHead
    min :: TableHead -> TableHead -> TableHead
    Ord, Int -> TableHead -> ShowS
    [TableHead] -> ShowS
    TableHead -> String
    (Int -> TableHead -> ShowS)
    -> (TableHead -> String)
    -> ([TableHead] -> ShowS)
    -> Show TableHead
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TableHead -> ShowS
    showsPrec :: Int -> TableHead -> ShowS
    $cshow :: TableHead -> String
    show :: TableHead -> String
    $cshowList :: [TableHead] -> ShowS
    showList :: [TableHead] -> ShowS
    Show, ReadPrec [TableHead]
    ReadPrec TableHead
    Int -> ReadS TableHead
    ReadS [TableHead]
    (Int -> ReadS TableHead)
    -> ReadS [TableHead]
    -> ReadPrec TableHead
    -> ReadPrec [TableHead]
    -> Read TableHead
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS TableHead
    readsPrec :: Int -> ReadS TableHead
    $creadList :: ReadS [TableHead]
    readList :: ReadS [TableHead]
    $creadPrec :: ReadPrec TableHead
    readPrec :: ReadPrec TableHead
    $creadListPrec :: ReadPrec [TableHead]
    readListPrec :: ReadPrec [TableHead]
    Read, Typeable, Typeable TableHead
    Typeable TableHead =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TableHead -> c TableHead)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TableHead)
    -> (TableHead -> Constr)
    -> (TableHead -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TableHead))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableHead))
    -> ((forall b. Data b => b -> b) -> TableHead -> TableHead)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TableHead -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TableHead -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TableHead -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TableHead -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TableHead -> m TableHead)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableHead -> m TableHead)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableHead -> m TableHead)
    -> Data TableHead
    TableHead -> Constr
    TableHead -> DataType
    (forall b. Data b => b -> b) -> TableHead -> TableHead
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> TableHead -> u
    forall u. (forall d. Data d => d -> u) -> TableHead -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableHead -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableHead -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableHead -> m TableHead
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableHead -> m TableHead
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableHead
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableHead -> c TableHead
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableHead)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableHead)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableHead -> c TableHead
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableHead -> c TableHead
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableHead
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableHead
    $ctoConstr :: TableHead -> Constr
    toConstr :: TableHead -> Constr
    $cdataTypeOf :: TableHead -> DataType
    dataTypeOf :: TableHead -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableHead)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableHead)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableHead)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableHead)
    $cgmapT :: (forall b. Data b => b -> b) -> TableHead -> TableHead
    gmapT :: (forall b. Data b => b -> b) -> TableHead -> TableHead
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableHead -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableHead -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableHead -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableHead -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableHead -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TableHead -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableHead -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableHead -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableHead -> m TableHead
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableHead -> m TableHead
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableHead -> m TableHead
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableHead -> m TableHead
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableHead -> m TableHead
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableHead -> m TableHead
    Data, (forall x. TableHead -> Rep TableHead x)
    -> (forall x. Rep TableHead x -> TableHead) -> Generic TableHead
    forall x. Rep TableHead x -> TableHead
    forall x. TableHead -> Rep TableHead x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. TableHead -> Rep TableHead x
    from :: forall x. TableHead -> Rep TableHead x
    $cto :: forall x. Rep TableHead x -> TableHead
    to :: forall x. Rep TableHead x -> TableHead
    Generic)

    -- | A body of a table, with an intermediate head, intermediate body,
    -- and the specified number of row header columns in the intermediate
    -- body.
    data TableBody = TableBody Attr RowHeadColumns [Row] [Row]
      deriving (TableBody -> TableBody -> Bool
    (TableBody -> TableBody -> Bool)
    -> (TableBody -> TableBody -> Bool) -> Eq TableBody
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TableBody -> TableBody -> Bool
    == :: TableBody -> TableBody -> Bool
    $c/= :: TableBody -> TableBody -> Bool
    /= :: TableBody -> TableBody -> Bool
    Eq, Eq TableBody
    Eq TableBody =>
    (TableBody -> TableBody -> Ordering)
    -> (TableBody -> TableBody -> Bool)
    -> (TableBody -> TableBody -> Bool)
    -> (TableBody -> TableBody -> Bool)
    -> (TableBody -> TableBody -> Bool)
    -> (TableBody -> TableBody -> TableBody)
    -> (TableBody -> TableBody -> TableBody)
    -> Ord TableBody
    TableBody -> TableBody -> Bool
    TableBody -> TableBody -> Ordering
    TableBody -> TableBody -> TableBody
    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 :: TableBody -> TableBody -> Ordering
    compare :: TableBody -> TableBody -> Ordering
    $c< :: TableBody -> TableBody -> Bool
    < :: TableBody -> TableBody -> Bool
    $c<= :: TableBody -> TableBody -> Bool
    <= :: TableBody -> TableBody -> Bool
    $c> :: TableBody -> TableBody -> Bool
    > :: TableBody -> TableBody -> Bool
    $c>= :: TableBody -> TableBody -> Bool
    >= :: TableBody -> TableBody -> Bool
    $cmax :: TableBody -> TableBody -> TableBody
    max :: TableBody -> TableBody -> TableBody
    $cmin :: TableBody -> TableBody -> TableBody
    min :: TableBody -> TableBody -> TableBody
    Ord, Int -> TableBody -> ShowS
    [TableBody] -> ShowS
    TableBody -> String
    (Int -> TableBody -> ShowS)
    -> (TableBody -> String)
    -> ([TableBody] -> ShowS)
    -> Show TableBody
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TableBody -> ShowS
    showsPrec :: Int -> TableBody -> ShowS
    $cshow :: TableBody -> String
    show :: TableBody -> String
    $cshowList :: [TableBody] -> ShowS
    showList :: [TableBody] -> ShowS
    Show, ReadPrec [TableBody]
    ReadPrec TableBody
    Int -> ReadS TableBody
    ReadS [TableBody]
    (Int -> ReadS TableBody)
    -> ReadS [TableBody]
    -> ReadPrec TableBody
    -> ReadPrec [TableBody]
    -> Read TableBody
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS TableBody
    readsPrec :: Int -> ReadS TableBody
    $creadList :: ReadS [TableBody]
    readList :: ReadS [TableBody]
    $creadPrec :: ReadPrec TableBody
    readPrec :: ReadPrec TableBody
    $creadListPrec :: ReadPrec [TableBody]
    readListPrec :: ReadPrec [TableBody]
    Read, Typeable, Typeable TableBody
    Typeable TableBody =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TableBody -> c TableBody)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TableBody)
    -> (TableBody -> Constr)
    -> (TableBody -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TableBody))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableBody))
    -> ((forall b. Data b => b -> b) -> TableBody -> TableBody)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TableBody -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TableBody -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TableBody -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TableBody -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TableBody -> m TableBody)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableBody -> m TableBody)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableBody -> m TableBody)
    -> Data TableBody
    TableBody -> Constr
    TableBody -> DataType
    (forall b. Data b => b -> b) -> TableBody -> TableBody
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> TableBody -> u
    forall u. (forall d. Data d => d -> u) -> TableBody -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableBody -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableBody -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableBody -> m TableBody
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableBody -> m TableBody
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableBody
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableBody -> c TableBody
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableBody)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableBody)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableBody -> c TableBody
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableBody -> c TableBody
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableBody
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableBody
    $ctoConstr :: TableBody -> Constr
    toConstr :: TableBody -> Constr
    $cdataTypeOf :: TableBody -> DataType
    dataTypeOf :: TableBody -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableBody)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableBody)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableBody)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableBody)
    $cgmapT :: (forall b. Data b => b -> b) -> TableBody -> TableBody
    gmapT :: (forall b. Data b => b -> b) -> TableBody -> TableBody
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableBody -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableBody -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableBody -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableBody -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableBody -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TableBody -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableBody -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableBody -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableBody -> m TableBody
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableBody -> m TableBody
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableBody -> m TableBody
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableBody -> m TableBody
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableBody -> m TableBody
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableBody -> m TableBody
    Data, (forall x. TableBody -> Rep TableBody x)
    -> (forall x. Rep TableBody x -> TableBody) -> Generic TableBody
    forall x. Rep TableBody x -> TableBody
    forall x. TableBody -> Rep TableBody x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. TableBody -> Rep TableBody x
    from :: forall x. TableBody -> Rep TableBody x
    $cto :: forall x. Rep TableBody x -> TableBody
    to :: forall x. Rep TableBody x -> TableBody
    Generic)

    -- | The foot of a table.
    data TableFoot = TableFoot Attr [Row]
      deriving (TableFoot -> TableFoot -> Bool
    (TableFoot -> TableFoot -> Bool)
    -> (TableFoot -> TableFoot -> Bool) -> Eq TableFoot
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TableFoot -> TableFoot -> Bool
    == :: TableFoot -> TableFoot -> Bool
    $c/= :: TableFoot -> TableFoot -> Bool
    /= :: TableFoot -> TableFoot -> Bool
    Eq, Eq TableFoot
    Eq TableFoot =>
    (TableFoot -> TableFoot -> Ordering)
    -> (TableFoot -> TableFoot -> Bool)
    -> (TableFoot -> TableFoot -> Bool)
    -> (TableFoot -> TableFoot -> Bool)
    -> (TableFoot -> TableFoot -> Bool)
    -> (TableFoot -> TableFoot -> TableFoot)
    -> (TableFoot -> TableFoot -> TableFoot)
    -> Ord TableFoot
    TableFoot -> TableFoot -> Bool
    TableFoot -> TableFoot -> Ordering
    TableFoot -> TableFoot -> TableFoot
    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 :: TableFoot -> TableFoot -> Ordering
    compare :: TableFoot -> TableFoot -> Ordering
    $c< :: TableFoot -> TableFoot -> Bool
    < :: TableFoot -> TableFoot -> Bool
    $c<= :: TableFoot -> TableFoot -> Bool
    <= :: TableFoot -> TableFoot -> Bool
    $c> :: TableFoot -> TableFoot -> Bool
    > :: TableFoot -> TableFoot -> Bool
    $c>= :: TableFoot -> TableFoot -> Bool
    >= :: TableFoot -> TableFoot -> Bool
    $cmax :: TableFoot -> TableFoot -> TableFoot
    max :: TableFoot -> TableFoot -> TableFoot
    $cmin :: TableFoot -> TableFoot -> TableFoot
    min :: TableFoot -> TableFoot -> TableFoot
    Ord, Int -> TableFoot -> ShowS
    [TableFoot] -> ShowS
    TableFoot -> String
    (Int -> TableFoot -> ShowS)
    -> (TableFoot -> String)
    -> ([TableFoot] -> ShowS)
    -> Show TableFoot
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TableFoot -> ShowS
    showsPrec :: Int -> TableFoot -> ShowS
    $cshow :: TableFoot -> String
    show :: TableFoot -> String
    $cshowList :: [TableFoot] -> ShowS
    showList :: [TableFoot] -> ShowS
    Show, ReadPrec [TableFoot]
    ReadPrec TableFoot
    Int -> ReadS TableFoot
    ReadS [TableFoot]
    (Int -> ReadS TableFoot)
    -> ReadS [TableFoot]
    -> ReadPrec TableFoot
    -> ReadPrec [TableFoot]
    -> Read TableFoot
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS TableFoot
    readsPrec :: Int -> ReadS TableFoot
    $creadList :: ReadS [TableFoot]
    readList :: ReadS [TableFoot]
    $creadPrec :: ReadPrec TableFoot
    readPrec :: ReadPrec TableFoot
    $creadListPrec :: ReadPrec [TableFoot]
    readListPrec :: ReadPrec [TableFoot]
    Read, Typeable, Typeable TableFoot
    Typeable TableFoot =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TableFoot -> c TableFoot)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TableFoot)
    -> (TableFoot -> Constr)
    -> (TableFoot -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TableFoot))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableFoot))
    -> ((forall b. Data b => b -> b) -> TableFoot -> TableFoot)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TableFoot -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TableFoot -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TableFoot -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TableFoot -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot)
    -> Data TableFoot
    TableFoot -> Constr
    TableFoot -> DataType
    (forall b. Data b => b -> b) -> TableFoot -> TableFoot
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> TableFoot -> u
    forall u. (forall d. Data d => d -> u) -> TableFoot -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableFoot -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableFoot -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableFoot
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableFoot -> c TableFoot
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableFoot)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableFoot)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableFoot -> c TableFoot
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableFoot -> c TableFoot
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableFoot
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableFoot
    $ctoConstr :: TableFoot -> Constr
    toConstr :: TableFoot -> Constr
    $cdataTypeOf :: TableFoot -> DataType
    dataTypeOf :: TableFoot -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableFoot)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableFoot)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableFoot)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableFoot)
    $cgmapT :: (forall b. Data b => b -> b) -> TableFoot -> TableFoot
    gmapT :: (forall b. Data b => b -> b) -> TableFoot -> TableFoot
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableFoot -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableFoot -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableFoot -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableFoot -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableFoot -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TableFoot -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableFoot -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableFoot -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableFoot -> m TableFoot
    Data, (forall x. TableFoot -> Rep TableFoot x)
    -> (forall x. Rep TableFoot x -> TableFoot) -> Generic TableFoot
    forall x. Rep TableFoot x -> TableFoot
    forall x. TableFoot -> Rep TableFoot x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. TableFoot -> Rep TableFoot x
    from :: forall x. TableFoot -> Rep TableFoot x
    $cto :: forall x. Rep TableFoot x -> TableFoot
    to :: forall x. Rep TableFoot x -> TableFoot
    Generic)

    -- | A short caption, for use in, for instance, lists of figures.
    type ShortCaption = [Inline]

    -- | The caption of a table or figure, with optional short caption.
    data Caption = Caption (Maybe ShortCaption) [Block]
      deriving (Caption -> Caption -> Bool
    (Caption -> Caption -> Bool)
    -> (Caption -> Caption -> Bool) -> Eq Caption
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Caption -> Caption -> Bool
    == :: Caption -> Caption -> Bool
    $c/= :: Caption -> Caption -> Bool
    /= :: Caption -> Caption -> Bool
    Eq, Eq Caption
    Eq Caption =>
    (Caption -> Caption -> Ordering)
    -> (Caption -> Caption -> Bool)
    -> (Caption -> Caption -> Bool)
    -> (Caption -> Caption -> Bool)
    -> (Caption -> Caption -> Bool)
    -> (Caption -> Caption -> Caption)
    -> (Caption -> Caption -> Caption)
    -> Ord Caption
    Caption -> Caption -> Bool
    Caption -> Caption -> Ordering
    Caption -> Caption -> Caption
    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 :: Caption -> Caption -> Ordering
    compare :: Caption -> Caption -> Ordering
    $c< :: Caption -> Caption -> Bool
    < :: Caption -> Caption -> Bool
    $c<= :: Caption -> Caption -> Bool
    <= :: Caption -> Caption -> Bool
    $c> :: Caption -> Caption -> Bool
    > :: Caption -> Caption -> Bool
    $c>= :: Caption -> Caption -> Bool
    >= :: Caption -> Caption -> Bool
    $cmax :: Caption -> Caption -> Caption
    max :: Caption -> Caption -> Caption
    $cmin :: Caption -> Caption -> Caption
    min :: Caption -> Caption -> Caption
    Ord, Int -> Caption -> ShowS
    [Caption] -> ShowS
    Caption -> String
    (Int -> Caption -> ShowS)
    -> (Caption -> String) -> ([Caption] -> ShowS) -> Show Caption
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Caption -> ShowS
    showsPrec :: Int -> Caption -> ShowS
    $cshow :: Caption -> String
    show :: Caption -> String
    $cshowList :: [Caption] -> ShowS
    showList :: [Caption] -> ShowS
    Show, ReadPrec [Caption]
    ReadPrec Caption
    Int -> ReadS Caption
    ReadS [Caption]
    (Int -> ReadS Caption)
    -> ReadS [Caption]
    -> ReadPrec Caption
    -> ReadPrec [Caption]
    -> Read Caption
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Caption
    readsPrec :: Int -> ReadS Caption
    $creadList :: ReadS [Caption]
    readList :: ReadS [Caption]
    $creadPrec :: ReadPrec Caption
    readPrec :: ReadPrec Caption
    $creadListPrec :: ReadPrec [Caption]
    readListPrec :: ReadPrec [Caption]
    Read, Typeable, Typeable Caption
    Typeable Caption =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Caption -> c Caption)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Caption)
    -> (Caption -> Constr)
    -> (Caption -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Caption))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Caption))
    -> ((forall b. Data b => b -> b) -> Caption -> Caption)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Caption -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Caption -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Caption -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Caption -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Caption -> m Caption)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Caption -> m Caption)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Caption -> m Caption)
    -> Data Caption
    Caption -> Constr
    Caption -> DataType
    (forall b. Data b => b -> b) -> Caption -> Caption
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Caption -> u
    forall u. (forall d. Data d => d -> u) -> Caption -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Caption -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Caption -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Caption -> m Caption
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Caption -> m Caption
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Caption
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Caption -> c Caption
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Caption)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Caption)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Caption -> c Caption
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Caption -> c Caption
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Caption
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Caption
    $ctoConstr :: Caption -> Constr
    toConstr :: Caption -> Constr
    $cdataTypeOf :: Caption -> DataType
    dataTypeOf :: Caption -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Caption)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Caption)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Caption)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Caption)
    $cgmapT :: (forall b. Data b => b -> b) -> Caption -> Caption
    gmapT :: (forall b. Data b => b -> b) -> Caption -> Caption
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Caption -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Caption -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Caption -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Caption -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Caption -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Caption -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Caption -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Caption -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Caption -> m Caption
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Caption -> m Caption
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Caption -> m Caption
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Caption -> m Caption
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Caption -> m Caption
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Caption -> m Caption
    Data, (forall x. Caption -> Rep Caption x)
    -> (forall x. Rep Caption x -> Caption) -> Generic Caption
    forall x. Rep Caption x -> Caption
    forall x. Caption -> Rep Caption x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Caption -> Rep Caption x
    from :: forall x. Caption -> Rep Caption x
    $cto :: forall x. Rep Caption x -> Caption
    to :: forall x. Rep Caption x -> Caption
    Generic)

    -- | A table cell.
    data Cell = Cell Attr Alignment RowSpan ColSpan [Block]
      deriving (Cell -> Cell -> Bool
    (Cell -> Cell -> Bool) -> (Cell -> Cell -> Bool) -> Eq Cell
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Cell -> Cell -> Bool
    == :: Cell -> Cell -> Bool
    $c/= :: Cell -> Cell -> Bool
    /= :: Cell -> Cell -> Bool
    Eq, Eq Cell
    Eq Cell =>
    (Cell -> Cell -> Ordering)
    -> (Cell -> Cell -> Bool)
    -> (Cell -> Cell -> Bool)
    -> (Cell -> Cell -> Bool)
    -> (Cell -> Cell -> Bool)
    -> (Cell -> Cell -> Cell)
    -> (Cell -> Cell -> Cell)
    -> Ord Cell
    Cell -> Cell -> Bool
    Cell -> Cell -> Ordering
    Cell -> Cell -> Cell
    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 :: Cell -> Cell -> Ordering
    compare :: Cell -> Cell -> Ordering
    $c< :: Cell -> Cell -> Bool
    < :: Cell -> Cell -> Bool
    $c<= :: Cell -> Cell -> Bool
    <= :: Cell -> Cell -> Bool
    $c> :: Cell -> Cell -> Bool
    > :: Cell -> Cell -> Bool
    $c>= :: Cell -> Cell -> Bool
    >= :: Cell -> Cell -> Bool
    $cmax :: Cell -> Cell -> Cell
    max :: Cell -> Cell -> Cell
    $cmin :: Cell -> Cell -> Cell
    min :: Cell -> Cell -> Cell
    Ord, Int -> Cell -> ShowS
    [Cell] -> ShowS
    Cell -> String
    (Int -> Cell -> ShowS)
    -> (Cell -> String) -> ([Cell] -> ShowS) -> Show Cell
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Cell -> ShowS
    showsPrec :: Int -> Cell -> ShowS
    $cshow :: Cell -> String
    show :: Cell -> String
    $cshowList :: [Cell] -> ShowS
    showList :: [Cell] -> ShowS
    Show, ReadPrec [Cell]
    ReadPrec Cell
    Int -> ReadS Cell
    ReadS [Cell]
    (Int -> ReadS Cell)
    -> ReadS [Cell] -> ReadPrec Cell -> ReadPrec [Cell] -> Read Cell
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Cell
    readsPrec :: Int -> ReadS Cell
    $creadList :: ReadS [Cell]
    readList :: ReadS [Cell]
    $creadPrec :: ReadPrec Cell
    readPrec :: ReadPrec Cell
    $creadListPrec :: ReadPrec [Cell]
    readListPrec :: ReadPrec [Cell]
    Read, Typeable, Typeable Cell
    Typeable Cell =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Cell -> c Cell)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Cell)
    -> (Cell -> Constr)
    -> (Cell -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Cell))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cell))
    -> ((forall b. Data b => b -> b) -> Cell -> Cell)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cell -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cell -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Cell -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Cell -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Cell -> m Cell)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Cell -> m Cell)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Cell -> m Cell)
    -> Data Cell
    Cell -> Constr
    Cell -> DataType
    (forall b. Data b => b -> b) -> Cell -> Cell
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Cell -> u
    forall u. (forall d. Data d => d -> u) -> Cell -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cell -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cell -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Cell -> m Cell
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cell -> m Cell
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Cell
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Cell -> c Cell
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Cell)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cell)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Cell -> c Cell
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Cell -> c Cell
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Cell
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Cell
    $ctoConstr :: Cell -> Constr
    toConstr :: Cell -> Constr
    $cdataTypeOf :: Cell -> DataType
    dataTypeOf :: Cell -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Cell)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Cell)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cell)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cell)
    $cgmapT :: (forall b. Data b => b -> b) -> Cell -> Cell
    gmapT :: (forall b. Data b => b -> b) -> Cell -> Cell
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cell -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cell -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cell -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cell -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Cell -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Cell -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Cell -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Cell -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Cell -> m Cell
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Cell -> m Cell
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cell -> m Cell
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cell -> m Cell
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cell -> m Cell
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cell -> m Cell
    Data, (forall x. Cell -> Rep Cell x)
    -> (forall x. Rep Cell x -> Cell) -> Generic Cell
    forall x. Rep Cell x -> Cell
    forall x. Cell -> Rep Cell x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Cell -> Rep Cell x
    from :: forall x. Cell -> Rep Cell x
    $cto :: forall x. Rep Cell x -> Cell
    to :: forall x. Rep Cell x -> Cell
    Generic)

    -- | The number of rows occupied by a cell; the height of a cell.
    newtype RowSpan = RowSpan Int
      deriving (RowSpan -> RowSpan -> Bool
    (RowSpan -> RowSpan -> Bool)
    -> (RowSpan -> RowSpan -> Bool) -> Eq RowSpan
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RowSpan -> RowSpan -> Bool
    == :: RowSpan -> RowSpan -> Bool
    $c/= :: RowSpan -> RowSpan -> Bool
    /= :: RowSpan -> RowSpan -> Bool
    Eq, Eq RowSpan
    Eq RowSpan =>
    (RowSpan -> RowSpan -> Ordering)
    -> (RowSpan -> RowSpan -> Bool)
    -> (RowSpan -> RowSpan -> Bool)
    -> (RowSpan -> RowSpan -> Bool)
    -> (RowSpan -> RowSpan -> Bool)
    -> (RowSpan -> RowSpan -> RowSpan)
    -> (RowSpan -> RowSpan -> RowSpan)
    -> Ord RowSpan
    RowSpan -> RowSpan -> Bool
    RowSpan -> RowSpan -> Ordering
    RowSpan -> RowSpan -> RowSpan
    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 :: RowSpan -> RowSpan -> Ordering
    compare :: RowSpan -> RowSpan -> Ordering
    $c< :: RowSpan -> RowSpan -> Bool
    < :: RowSpan -> RowSpan -> Bool
    $c<= :: RowSpan -> RowSpan -> Bool
    <= :: RowSpan -> RowSpan -> Bool
    $c> :: RowSpan -> RowSpan -> Bool
    > :: RowSpan -> RowSpan -> Bool
    $c>= :: RowSpan -> RowSpan -> Bool
    >= :: RowSpan -> RowSpan -> Bool
    $cmax :: RowSpan -> RowSpan -> RowSpan
    max :: RowSpan -> RowSpan -> RowSpan
    $cmin :: RowSpan -> RowSpan -> RowSpan
    min :: RowSpan -> RowSpan -> RowSpan
    Ord, Int -> RowSpan -> ShowS
    [RowSpan] -> ShowS
    RowSpan -> String
    (Int -> RowSpan -> ShowS)
    -> (RowSpan -> String) -> ([RowSpan] -> ShowS) -> Show RowSpan
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RowSpan -> ShowS
    showsPrec :: Int -> RowSpan -> ShowS
    $cshow :: RowSpan -> String
    show :: RowSpan -> String
    $cshowList :: [RowSpan] -> ShowS
    showList :: [RowSpan] -> ShowS
    Show, ReadPrec [RowSpan]
    ReadPrec RowSpan
    Int -> ReadS RowSpan
    ReadS [RowSpan]
    (Int -> ReadS RowSpan)
    -> ReadS [RowSpan]
    -> ReadPrec RowSpan
    -> ReadPrec [RowSpan]
    -> Read RowSpan
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS RowSpan
    readsPrec :: Int -> ReadS RowSpan
    $creadList :: ReadS [RowSpan]
    readList :: ReadS [RowSpan]
    $creadPrec :: ReadPrec RowSpan
    readPrec :: ReadPrec RowSpan
    $creadListPrec :: ReadPrec [RowSpan]
    readListPrec :: ReadPrec [RowSpan]
    Read, Typeable, Typeable RowSpan
    Typeable RowSpan =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> RowSpan -> c RowSpan)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c RowSpan)
    -> (RowSpan -> Constr)
    -> (RowSpan -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c RowSpan))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RowSpan))
    -> ((forall b. Data b => b -> b) -> RowSpan -> RowSpan)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RowSpan -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RowSpan -> r)
    -> (forall u. (forall d. Data d => d -> u) -> RowSpan -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> RowSpan -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan)
    -> Data RowSpan
    RowSpan -> Constr
    RowSpan -> DataType
    (forall b. Data b => b -> b) -> RowSpan -> RowSpan
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> RowSpan -> u
    forall u. (forall d. Data d => d -> u) -> RowSpan -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RowSpan -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RowSpan -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RowSpan
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RowSpan -> c RowSpan
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RowSpan)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RowSpan)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RowSpan -> c RowSpan
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RowSpan -> c RowSpan
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RowSpan
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RowSpan
    $ctoConstr :: RowSpan -> Constr
    toConstr :: RowSpan -> Constr
    $cdataTypeOf :: RowSpan -> DataType
    dataTypeOf :: RowSpan -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RowSpan)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RowSpan)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RowSpan)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RowSpan)
    $cgmapT :: (forall b. Data b => b -> b) -> RowSpan -> RowSpan
    gmapT :: (forall b. Data b => b -> b) -> RowSpan -> RowSpan
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RowSpan -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RowSpan -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RowSpan -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RowSpan -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> RowSpan -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RowSpan -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RowSpan -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RowSpan -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RowSpan -> m RowSpan
    Data, (forall x. RowSpan -> Rep RowSpan x)
    -> (forall x. Rep RowSpan x -> RowSpan) -> Generic RowSpan
    forall x. Rep RowSpan x -> RowSpan
    forall x. RowSpan -> Rep RowSpan x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. RowSpan -> Rep RowSpan x
    from :: forall x. RowSpan -> Rep RowSpan x
    $cto :: forall x. Rep RowSpan x -> RowSpan
    to :: forall x. Rep RowSpan x -> RowSpan
    Generic, Integer -> RowSpan
    RowSpan -> RowSpan
    RowSpan -> RowSpan -> RowSpan
    (RowSpan -> RowSpan -> RowSpan)
    -> (RowSpan -> RowSpan -> RowSpan)
    -> (RowSpan -> RowSpan -> RowSpan)
    -> (RowSpan -> RowSpan)
    -> (RowSpan -> RowSpan)
    -> (RowSpan -> RowSpan)
    -> (Integer -> RowSpan)
    -> Num RowSpan
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: RowSpan -> RowSpan -> RowSpan
    + :: RowSpan -> RowSpan -> RowSpan
    $c- :: RowSpan -> RowSpan -> RowSpan
    - :: RowSpan -> RowSpan -> RowSpan
    $c* :: RowSpan -> RowSpan -> RowSpan
    * :: RowSpan -> RowSpan -> RowSpan
    $cnegate :: RowSpan -> RowSpan
    negate :: RowSpan -> RowSpan
    $cabs :: RowSpan -> RowSpan
    abs :: RowSpan -> RowSpan
    $csignum :: RowSpan -> RowSpan
    signum :: RowSpan -> RowSpan
    $cfromInteger :: Integer -> RowSpan
    fromInteger :: Integer -> RowSpan
    Num, Int -> RowSpan
    RowSpan -> Int
    RowSpan -> [RowSpan]
    RowSpan -> RowSpan
    RowSpan -> RowSpan -> [RowSpan]
    RowSpan -> RowSpan -> RowSpan -> [RowSpan]
    (RowSpan -> RowSpan)
    -> (RowSpan -> RowSpan)
    -> (Int -> RowSpan)
    -> (RowSpan -> Int)
    -> (RowSpan -> [RowSpan])
    -> (RowSpan -> RowSpan -> [RowSpan])
    -> (RowSpan -> RowSpan -> [RowSpan])
    -> (RowSpan -> RowSpan -> RowSpan -> [RowSpan])
    -> Enum RowSpan
    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 :: RowSpan -> RowSpan
    succ :: RowSpan -> RowSpan
    $cpred :: RowSpan -> RowSpan
    pred :: RowSpan -> RowSpan
    $ctoEnum :: Int -> RowSpan
    toEnum :: Int -> RowSpan
    $cfromEnum :: RowSpan -> Int
    fromEnum :: RowSpan -> Int
    $cenumFrom :: RowSpan -> [RowSpan]
    enumFrom :: RowSpan -> [RowSpan]
    $cenumFromThen :: RowSpan -> RowSpan -> [RowSpan]
    enumFromThen :: RowSpan -> RowSpan -> [RowSpan]
    $cenumFromTo :: RowSpan -> RowSpan -> [RowSpan]
    enumFromTo :: RowSpan -> RowSpan -> [RowSpan]
    $cenumFromThenTo :: RowSpan -> RowSpan -> RowSpan -> [RowSpan]
    enumFromThenTo :: RowSpan -> RowSpan -> RowSpan -> [RowSpan]
    Enum, [RowSpan] -> Value
    [RowSpan] -> Encoding
    RowSpan -> Bool
    RowSpan -> Value
    RowSpan -> Encoding
    (RowSpan -> Value)
    -> (RowSpan -> Encoding)
    -> ([RowSpan] -> Value)
    -> ([RowSpan] -> Encoding)
    -> (RowSpan -> Bool)
    -> ToJSON RowSpan
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> (a -> Bool)
    -> ToJSON a
    $ctoJSON :: RowSpan -> Value
    toJSON :: RowSpan -> Value
    $ctoEncoding :: RowSpan -> Encoding
    toEncoding :: RowSpan -> Encoding
    $ctoJSONList :: [RowSpan] -> Value
    toJSONList :: [RowSpan] -> Value
    $ctoEncodingList :: [RowSpan] -> Encoding
    toEncodingList :: [RowSpan] -> Encoding
    $comitField :: RowSpan -> Bool
    omitField :: RowSpan -> Bool
    ToJSON, Maybe RowSpan
    Value -> Parser [RowSpan]
    Value -> Parser RowSpan
    (Value -> Parser RowSpan)
    -> (Value -> Parser [RowSpan]) -> Maybe RowSpan -> FromJSON RowSpan
    forall a.
    (Value -> Parser a)
    -> (Value -> Parser [a]) -> Maybe a -> FromJSON a
    $cparseJSON :: Value -> Parser RowSpan
    parseJSON :: Value -> Parser RowSpan
    $cparseJSONList :: Value -> Parser [RowSpan]
    parseJSONList :: Value -> Parser [RowSpan]
    $comittedField :: Maybe RowSpan
    omittedField :: Maybe RowSpan
    FromJSON)

    -- | The number of columns occupied by a cell; the width of a cell.
    newtype ColSpan = ColSpan Int
      deriving (ColSpan -> ColSpan -> Bool
    (ColSpan -> ColSpan -> Bool)
    -> (ColSpan -> ColSpan -> Bool) -> Eq ColSpan
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ColSpan -> ColSpan -> Bool
    == :: ColSpan -> ColSpan -> Bool
    $c/= :: ColSpan -> ColSpan -> Bool
    /= :: ColSpan -> ColSpan -> Bool
    Eq, Eq ColSpan
    Eq ColSpan =>
    (ColSpan -> ColSpan -> Ordering)
    -> (ColSpan -> ColSpan -> Bool)
    -> (ColSpan -> ColSpan -> Bool)
    -> (ColSpan -> ColSpan -> Bool)
    -> (ColSpan -> ColSpan -> Bool)
    -> (ColSpan -> ColSpan -> ColSpan)
    -> (ColSpan -> ColSpan -> ColSpan)
    -> Ord ColSpan
    ColSpan -> ColSpan -> Bool
    ColSpan -> ColSpan -> Ordering
    ColSpan -> ColSpan -> ColSpan
    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 :: ColSpan -> ColSpan -> Ordering
    compare :: ColSpan -> ColSpan -> Ordering
    $c< :: ColSpan -> ColSpan -> Bool
    < :: ColSpan -> ColSpan -> Bool
    $c<= :: ColSpan -> ColSpan -> Bool
    <= :: ColSpan -> ColSpan -> Bool
    $c> :: ColSpan -> ColSpan -> Bool
    > :: ColSpan -> ColSpan -> Bool
    $c>= :: ColSpan -> ColSpan -> Bool
    >= :: ColSpan -> ColSpan -> Bool
    $cmax :: ColSpan -> ColSpan -> ColSpan
    max :: ColSpan -> ColSpan -> ColSpan
    $cmin :: ColSpan -> ColSpan -> ColSpan
    min :: ColSpan -> ColSpan -> ColSpan
    Ord, Int -> ColSpan -> ShowS
    [ColSpan] -> ShowS
    ColSpan -> String
    (Int -> ColSpan -> ShowS)
    -> (ColSpan -> String) -> ([ColSpan] -> ShowS) -> Show ColSpan
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ColSpan -> ShowS
    showsPrec :: Int -> ColSpan -> ShowS
    $cshow :: ColSpan -> String
    show :: ColSpan -> String
    $cshowList :: [ColSpan] -> ShowS
    showList :: [ColSpan] -> ShowS
    Show, ReadPrec [ColSpan]
    ReadPrec ColSpan
    Int -> ReadS ColSpan
    ReadS [ColSpan]
    (Int -> ReadS ColSpan)
    -> ReadS [ColSpan]
    -> ReadPrec ColSpan
    -> ReadPrec [ColSpan]
    -> Read ColSpan
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS ColSpan
    readsPrec :: Int -> ReadS ColSpan
    $creadList :: ReadS [ColSpan]
    readList :: ReadS [ColSpan]
    $creadPrec :: ReadPrec ColSpan
    readPrec :: ReadPrec ColSpan
    $creadListPrec :: ReadPrec [ColSpan]
    readListPrec :: ReadPrec [ColSpan]
    Read, Typeable, Typeable ColSpan
    Typeable ColSpan =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ColSpan -> c ColSpan)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ColSpan)
    -> (ColSpan -> Constr)
    -> (ColSpan -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ColSpan))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColSpan))
    -> ((forall b. Data b => b -> b) -> ColSpan -> ColSpan)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ColSpan -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ColSpan -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ColSpan -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> ColSpan -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan)
    -> Data ColSpan
    ColSpan -> Constr
    ColSpan -> DataType
    (forall b. Data b => b -> b) -> ColSpan -> ColSpan
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ColSpan -> u
    forall u. (forall d. Data d => d -> u) -> ColSpan -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColSpan -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColSpan -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColSpan
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColSpan -> c ColSpan
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColSpan)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColSpan)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColSpan -> c ColSpan
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColSpan -> c ColSpan
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColSpan
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColSpan
    $ctoConstr :: ColSpan -> Constr
    toConstr :: ColSpan -> Constr
    $cdataTypeOf :: ColSpan -> DataType
    dataTypeOf :: ColSpan -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColSpan)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColSpan)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColSpan)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColSpan)
    $cgmapT :: (forall b. Data b => b -> b) -> ColSpan -> ColSpan
    gmapT :: (forall b. Data b => b -> b) -> ColSpan -> ColSpan
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColSpan -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColSpan -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColSpan -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColSpan -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColSpan -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ColSpan -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColSpan -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColSpan -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColSpan -> m ColSpan
    Data, (forall x. ColSpan -> Rep ColSpan x)
    -> (forall x. Rep ColSpan x -> ColSpan) -> Generic ColSpan
    forall x. Rep ColSpan x -> ColSpan
    forall x. ColSpan -> Rep ColSpan x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ColSpan -> Rep ColSpan x
    from :: forall x. ColSpan -> Rep ColSpan x
    $cto :: forall x. Rep ColSpan x -> ColSpan
    to :: forall x. Rep ColSpan x -> ColSpan
    Generic, Integer -> ColSpan
    ColSpan -> ColSpan
    ColSpan -> ColSpan -> ColSpan
    (ColSpan -> ColSpan -> ColSpan)
    -> (ColSpan -> ColSpan -> ColSpan)
    -> (ColSpan -> ColSpan -> ColSpan)
    -> (ColSpan -> ColSpan)
    -> (ColSpan -> ColSpan)
    -> (ColSpan -> ColSpan)
    -> (Integer -> ColSpan)
    -> Num ColSpan
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: ColSpan -> ColSpan -> ColSpan
    + :: ColSpan -> ColSpan -> ColSpan
    $c- :: ColSpan -> ColSpan -> ColSpan
    - :: ColSpan -> ColSpan -> ColSpan
    $c* :: ColSpan -> ColSpan -> ColSpan
    * :: ColSpan -> ColSpan -> ColSpan
    $cnegate :: ColSpan -> ColSpan
    negate :: ColSpan -> ColSpan
    $cabs :: ColSpan -> ColSpan
    abs :: ColSpan -> ColSpan
    $csignum :: ColSpan -> ColSpan
    signum :: ColSpan -> ColSpan
    $cfromInteger :: Integer -> ColSpan
    fromInteger :: Integer -> ColSpan
    Num, Int -> ColSpan
    ColSpan -> Int
    ColSpan -> [ColSpan]
    ColSpan -> ColSpan
    ColSpan -> ColSpan -> [ColSpan]
    ColSpan -> ColSpan -> ColSpan -> [ColSpan]
    (ColSpan -> ColSpan)
    -> (ColSpan -> ColSpan)
    -> (Int -> ColSpan)
    -> (ColSpan -> Int)
    -> (ColSpan -> [ColSpan])
    -> (ColSpan -> ColSpan -> [ColSpan])
    -> (ColSpan -> ColSpan -> [ColSpan])
    -> (ColSpan -> ColSpan -> ColSpan -> [ColSpan])
    -> Enum ColSpan
    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 :: ColSpan -> ColSpan
    succ :: ColSpan -> ColSpan
    $cpred :: ColSpan -> ColSpan
    pred :: ColSpan -> ColSpan
    $ctoEnum :: Int -> ColSpan
    toEnum :: Int -> ColSpan
    $cfromEnum :: ColSpan -> Int
    fromEnum :: ColSpan -> Int
    $cenumFrom :: ColSpan -> [ColSpan]
    enumFrom :: ColSpan -> [ColSpan]
    $cenumFromThen :: ColSpan -> ColSpan -> [ColSpan]
    enumFromThen :: ColSpan -> ColSpan -> [ColSpan]
    $cenumFromTo :: ColSpan -> ColSpan -> [ColSpan]
    enumFromTo :: ColSpan -> ColSpan -> [ColSpan]
    $cenumFromThenTo :: ColSpan -> ColSpan -> ColSpan -> [ColSpan]
    enumFromThenTo :: ColSpan -> ColSpan -> ColSpan -> [ColSpan]
    Enum, [ColSpan] -> Value
    [ColSpan] -> Encoding
    ColSpan -> Bool
    ColSpan -> Value
    ColSpan -> Encoding
    (ColSpan -> Value)
    -> (ColSpan -> Encoding)
    -> ([ColSpan] -> Value)
    -> ([ColSpan] -> Encoding)
    -> (ColSpan -> Bool)
    -> ToJSON ColSpan
    forall a.
    (a -> Value)
    -> (a -> Encoding)
    -> ([a] -> Value)
    -> ([a] -> Encoding)
    -> (a -> Bool)
    -> ToJSON a
    $ctoJSON :: ColSpan -> Value
    toJSON :: ColSpan -> Value
    $ctoEncoding :: ColSpan -> Encoding
    toEncoding :: ColSpan -> Encoding
    $ctoJSONList :: [ColSpan] -> Value
    toJSONList :: [ColSpan] -> Value
    $ctoEncodingList :: [ColSpan] -> Encoding
    toEncodingList :: [ColSpan] -> Encoding
    $comitField :: ColSpan -> Bool
    omitField :: ColSpan -> Bool
    ToJSON, Maybe ColSpan
    Value -> Parser [ColSpan]
    Value -> Parser ColSpan
    (Value -> Parser ColSpan)
    -> (Value -> Parser [ColSpan]) -> Maybe ColSpan -> FromJSON ColSpan
    forall a.
    (Value -> Parser a)
    -> (Value -> Parser [a]) -> Maybe a -> FromJSON a
    $cparseJSON :: Value -> Parser ColSpan
    parseJSON :: Value -> Parser ColSpan
    $cparseJSONList :: Value -> Parser [ColSpan]
    parseJSONList :: Value -> Parser [ColSpan]
    $comittedField :: Maybe ColSpan
    omittedField :: Maybe ColSpan
    FromJSON)

    -- | Block element.
    data Block
        -- | Plain text, not a paragraph
        = Plain [Inline]
        -- | Paragraph
        | Para [Inline]
        -- | Multiple non-breaking lines
        | LineBlock [[Inline]]
        -- | Code block (literal) with attributes
        | CodeBlock Attr Text
        -- | Raw block
        | RawBlock Format Text
        -- | Block quote (list of blocks)
        | BlockQuote [Block]
        -- | Ordered list (attributes and a list of items, each a list of
        -- blocks)
        | OrderedList ListAttributes [[Block]]
        -- | Bullet list (list of items, each a list of blocks)
        | BulletList [[Block]]
        -- | Definition list. Each list item is a pair consisting of a
        -- term (a list of inlines) and one or more definitions (each a
        -- list of blocks)
        | DefinitionList [([Inline],[[Block]])]
        -- | Header - level (integer) and text (inlines)
        | Header Int Attr [Inline]
        -- | Horizontal rule
        | HorizontalRule
        -- | Table, with attributes, caption, optional short caption,
        -- column alignments and widths (required), table head, table
        -- bodies, and table foot
        | Table Attr Caption [ColSpec] TableHead [TableBody] TableFoot
        -- | Figure, with attributes, caption, and content (list of blocks)
        | Figure Attr Caption [Block]
        -- | Generic block container with attributes
        | Div Attr [Block]
        deriving (Block -> Block -> Bool
    (Block -> Block -> Bool) -> (Block -> Block -> Bool) -> Eq Block
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Block -> Block -> Bool
    == :: Block -> Block -> Bool
    $c/= :: Block -> Block -> Bool
    /= :: Block -> Block -> Bool
    Eq, Eq Block
    Eq Block =>
    (Block -> Block -> Ordering)
    -> (Block -> Block -> Bool)
    -> (Block -> Block -> Bool)
    -> (Block -> Block -> Bool)
    -> (Block -> Block -> Bool)
    -> (Block -> Block -> Block)
    -> (Block -> Block -> Block)
    -> Ord Block
    Block -> Block -> Bool
    Block -> Block -> Ordering
    Block -> Block -> Block
    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 :: Block -> Block -> Ordering
    compare :: Block -> Block -> Ordering
    $c< :: Block -> Block -> Bool
    < :: Block -> Block -> Bool
    $c<= :: Block -> Block -> Bool
    <= :: Block -> Block -> Bool
    $c> :: Block -> Block -> Bool
    > :: Block -> Block -> Bool
    $c>= :: Block -> Block -> Bool
    >= :: Block -> Block -> Bool
    $cmax :: Block -> Block -> Block
    max :: Block -> Block -> Block
    $cmin :: Block -> Block -> Block
    min :: Block -> Block -> Block
    Ord, ReadPrec [Block]
    ReadPrec Block
    Int -> ReadS Block
    ReadS [Block]
    (Int -> ReadS Block)
    -> ReadS [Block]
    -> ReadPrec Block
    -> ReadPrec [Block]
    -> Read Block
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Block
    readsPrec :: Int -> ReadS Block
    $creadList :: ReadS [Block]
    readList :: ReadS [Block]
    $creadPrec :: ReadPrec Block
    readPrec :: ReadPrec Block
    $creadListPrec :: ReadPrec [Block]
    readListPrec :: ReadPrec [Block]
    Read, Int -> Block -> ShowS
    [Block] -> ShowS
    Block -> String
    (Int -> Block -> ShowS)
    -> (Block -> String) -> ([Block] -> ShowS) -> Show Block
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Block -> ShowS
    showsPrec :: Int -> Block -> ShowS
    $cshow :: Block -> String
    show :: Block -> String
    $cshowList :: [Block] -> ShowS
    showList :: [Block] -> ShowS
    Show, Typeable, Typeable Block
    Typeable Block =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Block -> c Block)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Block)
    -> (Block -> Constr)
    -> (Block -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Block))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block))
    -> ((forall b. Data b => b -> b) -> Block -> Block)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Block -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Block -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Block -> m Block)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Block -> m Block)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Block -> m Block)
    -> Data Block
    Block -> Constr
    Block -> DataType
    (forall b. Data b => b -> b) -> Block -> Block
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Block -> u
    forall u. (forall d. Data d => d -> u) -> Block -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Block
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block -> c Block
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Block)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block -> c Block
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block -> c Block
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Block
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Block
    $ctoConstr :: Block -> Constr
    toConstr :: Block -> Constr
    $cdataTypeOf :: Block -> DataType
    dataTypeOf :: Block -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Block)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Block)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
    $cgmapT :: (forall b. Data b => b -> b) -> Block -> Block
    gmapT :: (forall b. Data b => b -> b) -> Block -> Block
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Block -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Block -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Block -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Block -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    Data, (forall x. Block -> Rep Block x)
    -> (forall x. Rep Block x -> Block) -> Generic Block
    forall x. Rep Block x -> Block
    forall x. Block -> Rep Block x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Block -> Rep Block x
    from :: forall x. Block -> Rep Block x
    $cto :: forall x. Rep Block x -> Block
    to :: forall x. Rep Block x -> Block
    Generic)

    -- | Type of quotation marks to use in Quoted inline.
    data QuoteType = SingleQuote | DoubleQuote deriving (Int -> QuoteType -> ShowS
    [QuoteType] -> ShowS
    QuoteType -> String
    (Int -> QuoteType -> ShowS)
    -> (QuoteType -> String)
    -> ([QuoteType] -> ShowS)
    -> Show QuoteType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> QuoteType -> ShowS
    showsPrec :: Int -> QuoteType -> ShowS
    $cshow :: QuoteType -> String
    show :: QuoteType -> String
    $cshowList :: [QuoteType] -> ShowS
    showList :: [QuoteType] -> ShowS
    Show, QuoteType -> QuoteType -> Bool
    (QuoteType -> QuoteType -> Bool)
    -> (QuoteType -> QuoteType -> Bool) -> Eq QuoteType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: QuoteType -> QuoteType -> Bool
    == :: QuoteType -> QuoteType -> Bool
    $c/= :: QuoteType -> QuoteType -> Bool
    /= :: QuoteType -> QuoteType -> Bool
    Eq, Eq QuoteType
    Eq QuoteType =>
    (QuoteType -> QuoteType -> Ordering)
    -> (QuoteType -> QuoteType -> Bool)
    -> (QuoteType -> QuoteType -> Bool)
    -> (QuoteType -> QuoteType -> Bool)
    -> (QuoteType -> QuoteType -> Bool)
    -> (QuoteType -> QuoteType -> QuoteType)
    -> (QuoteType -> QuoteType -> QuoteType)
    -> Ord QuoteType
    QuoteType -> QuoteType -> Bool
    QuoteType -> QuoteType -> Ordering
    QuoteType -> QuoteType -> QuoteType
    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 :: QuoteType -> QuoteType -> Ordering
    compare :: QuoteType -> QuoteType -> Ordering
    $c< :: QuoteType -> QuoteType -> Bool
    < :: QuoteType -> QuoteType -> Bool
    $c<= :: QuoteType -> QuoteType -> Bool
    <= :: QuoteType -> QuoteType -> Bool
    $c> :: QuoteType -> QuoteType -> Bool
    > :: QuoteType -> QuoteType -> Bool
    $c>= :: QuoteType -> QuoteType -> Bool
    >= :: QuoteType -> QuoteType -> Bool
    $cmax :: QuoteType -> QuoteType -> QuoteType
    max :: QuoteType -> QuoteType -> QuoteType
    $cmin :: QuoteType -> QuoteType -> QuoteType
    min :: QuoteType -> QuoteType -> QuoteType
    Ord, ReadPrec [QuoteType]
    ReadPrec QuoteType
    Int -> ReadS QuoteType
    ReadS [QuoteType]
    (Int -> ReadS QuoteType)
    -> ReadS [QuoteType]
    -> ReadPrec QuoteType
    -> ReadPrec [QuoteType]
    -> Read QuoteType
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS QuoteType
    readsPrec :: Int -> ReadS QuoteType
    $creadList :: ReadS [QuoteType]
    readList :: ReadS [QuoteType]
    $creadPrec :: ReadPrec QuoteType
    readPrec :: ReadPrec QuoteType
    $creadListPrec :: ReadPrec [QuoteType]
    readListPrec :: ReadPrec [QuoteType]
    Read, Typeable, Typeable QuoteType
    Typeable QuoteType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> QuoteType -> c QuoteType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c QuoteType)
    -> (QuoteType -> Constr)
    -> (QuoteType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c QuoteType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QuoteType))
    -> ((forall b. Data b => b -> b) -> QuoteType -> QuoteType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> QuoteType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> QuoteType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> QuoteType -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> QuoteType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType)
    -> Data QuoteType
    QuoteType -> Constr
    QuoteType -> DataType
    (forall b. Data b => b -> b) -> QuoteType -> QuoteType
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> QuoteType -> u
    forall u. (forall d. Data d => d -> u) -> QuoteType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QuoteType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QuoteType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QuoteType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QuoteType -> c QuoteType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QuoteType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QuoteType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QuoteType -> c QuoteType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QuoteType -> c QuoteType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QuoteType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QuoteType
    $ctoConstr :: QuoteType -> Constr
    toConstr :: QuoteType -> Constr
    $cdataTypeOf :: QuoteType -> DataType
    dataTypeOf :: QuoteType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QuoteType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QuoteType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QuoteType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QuoteType)
    $cgmapT :: (forall b. Data b => b -> b) -> QuoteType -> QuoteType
    gmapT :: (forall b. Data b => b -> b) -> QuoteType -> QuoteType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QuoteType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QuoteType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QuoteType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QuoteType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> QuoteType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> QuoteType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QuoteType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QuoteType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType
    Data, (forall x. QuoteType -> Rep QuoteType x)
    -> (forall x. Rep QuoteType x -> QuoteType) -> Generic QuoteType
    forall x. Rep QuoteType x -> QuoteType
    forall x. QuoteType -> Rep QuoteType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. QuoteType -> Rep QuoteType x
    from :: forall x. QuoteType -> Rep QuoteType x
    $cto :: forall x. Rep QuoteType x -> QuoteType
    to :: forall x. Rep QuoteType x -> QuoteType
    Generic)

    -- | Link target (URL, title).
    type Target = (Text, Text)

    isFigureTarget :: Target -> Maybe Target
    isFigureTarget :: (Text, Text) -> Maybe (Text, Text)
    isFigureTarget (Text, Text)
    tgt
      | (Text
    src, Just Text
    tit) <- (Text -> Maybe Text) -> (Text, Text) -> (Text, Maybe Text)
    forall b c d. (b -> c) -> (d, b) -> (d, c)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (d, b) (d, c)
    second (Text -> Text -> Maybe Text
    T.stripPrefix Text
    "fig:") (Text, Text)
    tgt = (Text, Text) -> Maybe (Text, Text)
    forall a. a -> Maybe a
    Just (Text
    src, Text
    tit)
      | Bool
    otherwise = Maybe (Text, Text)
    forall a. Maybe a
    Nothing

    -- | Bidirectional pattern synonym
    --
    -- It can pass as a Block constructor
    --
    -- >>> SimpleFigure nullAttr [] (T.pack "", T.pack "title")
    -- Para [Image ("",[],[]) [] ("","fig:title")]
    --
    --
    -- It can be used to pattern match
    -- >>> let img = Para [Image undefined undefined (undefined, T.pack "title")]
    -- >>> case img of { SimpleFigure _ _ _ -> True; _ -> False }
    -- False
    -- >>> let fig = Para [Image undefined undefined (undefined, T.pack "fig:title")]
    -- >>> case fig of { SimpleFigure _ _ tit -> snd tit; _ -> T.pack "" }
    -- "title"
    pattern SimpleFigure :: Attr -> [Inline] -> Target -> Block
    pattern $mSimpleFigure :: forall {r}.
    Block
    -> (Attr -> [Inline] -> (Text, Text) -> r) -> ((# #) -> r) -> r
    $bSimpleFigure :: Attr -> [Inline] -> (Text, Text) -> Block
    SimpleFigure attr figureCaption tgt <-
        Para [Image attr figureCaption
            (isFigureTarget -> Just tgt)]  where
      SimpleFigure Attr
    attr [Inline]
    figureCaption (Text, Text)
    tgt =
        [Inline] -> Block
    Para [Attr -> [Inline] -> (Text, Text) -> Inline
    Image Attr
    attr [Inline]
    figureCaption ((Text -> Text) -> (Text, Text) -> (Text, Text)
    forall b c d. (b -> c) -> (d, b) -> (d, c)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (d, b) (d, c)
    second (Text
    "fig:" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <>) (Text, Text)
    tgt)]

    -- | Type of math element (display or inline).
    data MathType = DisplayMath | InlineMath deriving (Int -> MathType -> ShowS
    [MathType] -> ShowS
    MathType -> String
    (Int -> MathType -> ShowS)
    -> (MathType -> String) -> ([MathType] -> ShowS) -> Show MathType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MathType -> ShowS
    showsPrec :: Int -> MathType -> ShowS
    $cshow :: MathType -> String
    show :: MathType -> String
    $cshowList :: [MathType] -> ShowS
    showList :: [MathType] -> ShowS
    Show, MathType -> MathType -> Bool
    (MathType -> MathType -> Bool)
    -> (MathType -> MathType -> Bool) -> Eq MathType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MathType -> MathType -> Bool
    == :: MathType -> MathType -> Bool
    $c/= :: MathType -> MathType -> Bool
    /= :: MathType -> MathType -> Bool
    Eq, Eq MathType
    Eq MathType =>
    (MathType -> MathType -> Ordering)
    -> (MathType -> MathType -> Bool)
    -> (MathType -> MathType -> Bool)
    -> (MathType -> MathType -> Bool)
    -> (MathType -> MathType -> Bool)
    -> (MathType -> MathType -> MathType)
    -> (MathType -> MathType -> MathType)
    -> Ord MathType
    MathType -> MathType -> Bool
    MathType -> MathType -> Ordering
    MathType -> MathType -> MathType
    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 :: MathType -> MathType -> Ordering
    compare :: MathType -> MathType -> Ordering
    $c< :: MathType -> MathType -> Bool
    < :: MathType -> MathType -> Bool
    $c<= :: MathType -> MathType -> Bool
    <= :: MathType -> MathType -> Bool
    $c> :: MathType -> MathType -> Bool
    > :: MathType -> MathType -> Bool
    $c>= :: MathType -> MathType -> Bool
    >= :: MathType -> MathType -> Bool
    $cmax :: MathType -> MathType -> MathType
    max :: MathType -> MathType -> MathType
    $cmin :: MathType -> MathType -> MathType
    min :: MathType -> MathType -> MathType
    Ord, ReadPrec [MathType]
    ReadPrec MathType
    Int -> ReadS MathType
    ReadS [MathType]
    (Int -> ReadS MathType)
    -> ReadS [MathType]
    -> ReadPrec MathType
    -> ReadPrec [MathType]
    -> Read MathType
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS MathType
    readsPrec :: Int -> ReadS MathType
    $creadList :: ReadS [MathType]
    readList :: ReadS [MathType]
    $creadPrec :: ReadPrec MathType
    readPrec :: ReadPrec MathType
    $creadListPrec :: ReadPrec [MathType]
    readListPrec :: ReadPrec [MathType]
    Read, Typeable, Typeable MathType
    Typeable MathType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> MathType -> c MathType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c MathType)
    -> (MathType -> Constr)
    -> (MathType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c MathType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathType))
    -> ((forall b. Data b => b -> b) -> MathType -> MathType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> MathType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> MathType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> MathType -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> MathType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> MathType -> m MathType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MathType -> m MathType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MathType -> m MathType)
    -> Data MathType
    MathType -> Constr
    MathType -> DataType
    (forall b. Data b => b -> b) -> MathType -> MathType
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> MathType -> u
    forall u. (forall d. Data d => d -> u) -> MathType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MathType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MathType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MathType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MathType -> c MathType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MathType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MathType -> c MathType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MathType -> c MathType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MathType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MathType
    $ctoConstr :: MathType -> Constr
    toConstr :: MathType -> Constr
    $cdataTypeOf :: MathType -> DataType
    dataTypeOf :: MathType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MathType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MathType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathType)
    $cgmapT :: (forall b. Data b => b -> b) -> MathType -> MathType
    gmapT :: (forall b. Data b => b -> b) -> MathType -> MathType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MathType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MathType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MathType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MathType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> MathType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> MathType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MathType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MathType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType
    Data, (forall x. MathType -> Rep MathType x)
    -> (forall x. Rep MathType x -> MathType) -> Generic MathType
    forall x. Rep MathType x -> MathType
    forall x. MathType -> Rep MathType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. MathType -> Rep MathType x
    from :: forall x. MathType -> Rep MathType x
    $cto :: forall x. Rep MathType x -> MathType
    to :: forall x. Rep MathType x -> MathType
    Generic)

    -- | Inline elements.
    data Inline
        = Str Text            -- ^ Text (string)
        | Emph [Inline]         -- ^ Emphasized text (list of inlines)
        | Underline [Inline]    -- ^  Underlined text (list of inlines)
        | Strong [Inline]       -- ^ Strongly emphasized text (list of inlines)
        | Strikeout [Inline]    -- ^ Strikeout text (list of inlines)
        | Superscript [Inline]  -- ^ Superscripted text (list of inlines)
        | Subscript [Inline]    -- ^ Subscripted text (list of inlines)
        | SmallCaps [Inline]    -- ^ Small caps text (list of inlines)
        | Quoted QuoteType [Inline] -- ^ Quoted text (list of inlines)
        | Cite [Citation]  [Inline] -- ^ Citation (list of inlines)
        | Code Attr Text      -- ^ Inline code (literal)
        | Space                 -- ^ Inter-word space
        | SoftBreak             -- ^ Soft line break
        | LineBreak             -- ^ Hard line break
        | Math MathType Text  -- ^ TeX math (literal)
        | RawInline Format Text -- ^ Raw inline
        | Link Attr [Inline] Target  -- ^ Hyperlink: alt text (list of inlines), target
        | Image Attr [Inline] Target -- ^ Image:  alt text (list of inlines), target
        | Note [Block]          -- ^ Footnote or endnote
        | Span Attr [Inline]    -- ^ Generic inline container with attributes
        deriving (Int -> Inline -> ShowS
    [Inline] -> ShowS
    Inline -> String
    (Int -> Inline -> ShowS)
    -> (Inline -> String) -> ([Inline] -> ShowS) -> Show Inline
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Inline -> ShowS
    showsPrec :: Int -> Inline -> ShowS
    $cshow :: Inline -> String
    show :: Inline -> String
    $cshowList :: [Inline] -> ShowS
    showList :: [Inline] -> ShowS
    Show, Inline -> Inline -> Bool
    (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool) -> Eq Inline
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Inline -> Inline -> Bool
    == :: Inline -> Inline -> Bool
    $c/= :: Inline -> Inline -> Bool
    /= :: Inline -> Inline -> Bool
    Eq, Eq Inline
    Eq Inline =>
    (Inline -> Inline -> Ordering)
    -> (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Inline)
    -> (Inline -> Inline -> Inline)
    -> Ord Inline
    Inline -> Inline -> Bool
    Inline -> Inline -> Ordering
    Inline -> Inline -> Inline
    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 :: Inline -> Inline -> Ordering
    compare :: Inline -> Inline -> Ordering
    $c< :: Inline -> Inline -> Bool
    < :: Inline -> Inline -> Bool
    $c<= :: Inline -> Inline -> Bool
    <= :: Inline -> Inline -> Bool
    $c> :: Inline -> Inline -> Bool
    > :: Inline -> Inline -> Bool
    $c>= :: Inline -> Inline -> Bool
    >= :: Inline -> Inline -> Bool
    $cmax :: Inline -> Inline -> Inline
    max :: Inline -> Inline -> Inline
    $cmin :: Inline -> Inline -> Inline
    min :: Inline -> Inline -> Inline
    Ord, ReadPrec [Inline]
    ReadPrec Inline
    Int -> ReadS Inline
    ReadS [Inline]
    (Int -> ReadS Inline)
    -> ReadS [Inline]
    -> ReadPrec Inline
    -> ReadPrec [Inline]
    -> Read Inline
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Inline
    readsPrec :: Int -> ReadS Inline
    $creadList :: ReadS [Inline]
    readList :: ReadS [Inline]
    $creadPrec :: ReadPrec Inline
    readPrec :: ReadPrec Inline
    $creadListPrec :: ReadPrec [Inline]
    readListPrec :: ReadPrec [Inline]
    Read, Typeable, Typeable Inline
    Typeable Inline =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Inline -> c Inline)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Inline)
    -> (Inline -> Constr)
    -> (Inline -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Inline))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline))
    -> ((forall b. Data b => b -> b) -> Inline -> Inline)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Inline -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Inline -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Inline -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> Data Inline
    Inline -> Constr
    Inline -> DataType
    (forall b. Data b => b -> b) -> Inline -> Inline
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u
    forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    $ctoConstr :: Inline -> Constr
    toConstr :: Inline -> Constr
    $cdataTypeOf :: Inline -> DataType
    dataTypeOf :: Inline -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    $cgmapT :: (forall b. Data b => b -> b) -> Inline -> Inline
    gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    Data, (forall x. Inline -> Rep Inline x)
    -> (forall x. Rep Inline x -> Inline) -> Generic Inline
    forall x. Rep Inline x -> Inline
    forall x. Inline -> Rep Inline x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Inline -> Rep Inline x
    from :: forall x. Inline -> Rep Inline x
    $cto :: forall x. Rep Inline x -> Inline
    to :: forall x. Rep Inline x -> Inline
    Generic)

    data Citation = Citation { Citation -> Text
    citationId      :: Text
                             , Citation -> [Inline]
    citationPrefix  :: [Inline]
                             , Citation -> [Inline]
    citationSuffix  :: [Inline]
                             , Citation -> CitationMode
    citationMode    :: CitationMode
                             , Citation -> Int
    citationNoteNum :: Int
                             , Citation -> Int
    citationHash    :: Int
                             }
                    deriving (Int -> Citation -> ShowS
    [Citation] -> ShowS
    Citation -> String
    (Int -> Citation -> ShowS)
    -> (Citation -> String) -> ([Citation] -> ShowS) -> Show Citation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Citation -> ShowS
    showsPrec :: Int -> Citation -> ShowS
    $cshow :: Citation -> String
    show :: Citation -> String
    $cshowList :: [Citation] -> ShowS
    showList :: [Citation] -> ShowS
    Show, Citation -> Citation -> Bool
    (Citation -> Citation -> Bool)
    -> (Citation -> Citation -> Bool) -> Eq Citation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Citation -> Citation -> Bool
    == :: Citation -> Citation -> Bool
    $c/= :: Citation -> Citation -> Bool
    /= :: Citation -> Citation -> Bool
    Eq, ReadPrec [Citation]
    ReadPrec Citation
    Int -> ReadS Citation
    ReadS [Citation]
    (Int -> ReadS Citation)
    -> ReadS [Citation]
    -> ReadPrec Citation
    -> ReadPrec [Citation]
    -> Read Citation
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Citation
    readsPrec :: Int -> ReadS Citation
    $creadList :: ReadS [Citation]
    readList :: ReadS [Citation]
    $creadPrec :: ReadPrec Citation
    readPrec :: ReadPrec Citation
    $creadListPrec :: ReadPrec [Citation]
    readListPrec :: ReadPrec [Citation]
    Read, Typeable, Typeable Citation
    Typeable Citation =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Citation -> c Citation)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Citation)
    -> (Citation -> Constr)
    -> (Citation -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Citation))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Citation))
    -> ((forall b. Data b => b -> b) -> Citation -> Citation)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Citation -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Citation -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Citation -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Citation -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Citation -> m Citation)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Citation -> m Citation)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Citation -> m Citation)
    -> Data Citation
    Citation -> Constr
    Citation -> DataType
    (forall b. Data b => b -> b) -> Citation -> Citation
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Citation -> u
    forall u. (forall d. Data d => d -> u) -> Citation -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Citation -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Citation -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Citation
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Citation -> c Citation
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Citation)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Citation)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Citation -> c Citation
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Citation -> c Citation
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Citation
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Citation
    $ctoConstr :: Citation -> Constr
    toConstr :: Citation -> Constr
    $cdataTypeOf :: Citation -> DataType
    dataTypeOf :: Citation -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Citation)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Citation)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Citation)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Citation)
    $cgmapT :: (forall b. Data b => b -> b) -> Citation -> Citation
    gmapT :: (forall b. Data b => b -> b) -> Citation -> Citation
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Citation -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Citation -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Citation -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Citation -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Citation -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Citation -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Citation -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Citation -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation
    Data, (forall x. Citation -> Rep Citation x)
    -> (forall x. Rep Citation x -> Citation) -> Generic Citation
    forall x. Rep Citation x -> Citation
    forall x. Citation -> Rep Citation x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Citation -> Rep Citation x
    from :: forall x. Citation -> Rep Citation x
    $cto :: forall x. Rep Citation x -> Citation
    to :: forall x. Rep Citation x -> Citation
    Generic)

    instance Ord Citation where
        compare :: Citation -> Citation -> Ordering
    compare = (Citation -> Int) -> Citation -> Citation -> Ordering
    forall a b. Ord a => (b -> a) -> b -> b -> Ordering
    comparing Citation -> Int
    citationHash

    data CitationMode = AuthorInText | SuppressAuthor | NormalCitation
                        deriving (Int -> CitationMode -> ShowS
    [CitationMode] -> ShowS
    CitationMode -> String
    (Int -> CitationMode -> ShowS)
    -> (CitationMode -> String)
    -> ([CitationMode] -> ShowS)
    -> Show CitationMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CitationMode -> ShowS
    showsPrec :: Int -> CitationMode -> ShowS
    $cshow :: CitationMode -> String
    show :: CitationMode -> String
    $cshowList :: [CitationMode] -> ShowS
    showList :: [CitationMode] -> ShowS
    Show, CitationMode -> CitationMode -> Bool
    (CitationMode -> CitationMode -> Bool)
    -> (CitationMode -> CitationMode -> Bool) -> Eq CitationMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CitationMode -> CitationMode -> Bool
    == :: CitationMode -> CitationMode -> Bool
    $c/= :: CitationMode -> CitationMode -> Bool
    /= :: CitationMode -> CitationMode -> Bool
    Eq, Eq CitationMode
    Eq CitationMode =>
    (CitationMode -> CitationMode -> Ordering)
    -> (CitationMode -> CitationMode -> Bool)
    -> (CitationMode -> CitationMode -> Bool)
    -> (CitationMode -> CitationMode -> Bool)
    -> (CitationMode -> CitationMode -> Bool)
    -> (CitationMode -> CitationMode -> CitationMode)
    -> (CitationMode -> CitationMode -> CitationMode)
    -> Ord CitationMode
    CitationMode -> CitationMode -> Bool
    CitationMode -> CitationMode -> Ordering
    CitationMode -> CitationMode -> CitationMode
    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 :: CitationMode -> CitationMode -> Ordering
    compare :: CitationMode -> CitationMode -> Ordering
    $c< :: CitationMode -> CitationMode -> Bool
    < :: CitationMode -> CitationMode -> Bool
    $c<= :: CitationMode -> CitationMode -> Bool
    <= :: CitationMode -> CitationMode -> Bool
    $c> :: CitationMode -> CitationMode -> Bool
    > :: CitationMode -> CitationMode -> Bool
    $c>= :: CitationMode -> CitationMode -> Bool
    >= :: CitationMode -> CitationMode -> Bool
    $cmax :: CitationMode -> CitationMode -> CitationMode
    max :: CitationMode -> CitationMode -> CitationMode
    $cmin :: CitationMode -> CitationMode -> CitationMode
    min :: CitationMode -> CitationMode -> CitationMode
    Ord, ReadPrec [CitationMode]
    ReadPrec CitationMode
    Int -> ReadS CitationMode
    ReadS [CitationMode]
    (Int -> ReadS CitationMode)
    -> ReadS [CitationMode]
    -> ReadPrec CitationMode
    -> ReadPrec [CitationMode]
    -> Read CitationMode
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS CitationMode
    readsPrec :: Int -> ReadS CitationMode
    $creadList :: ReadS [CitationMode]
    readList :: ReadS [CitationMode]
    $creadPrec :: ReadPrec CitationMode
    readPrec :: ReadPrec CitationMode
    $creadListPrec :: ReadPrec [CitationMode]
    readListPrec :: ReadPrec [CitationMode]
    Read, Typeable, Typeable CitationMode
    Typeable CitationMode =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> CitationMode -> c CitationMode)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c CitationMode)
    -> (CitationMode -> Constr)
    -> (CitationMode -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c CitationMode))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c CitationMode))
    -> ((forall b. Data b => b -> b) -> CitationMode -> CitationMode)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CitationMode -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CitationMode -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CitationMode -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CitationMode -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode)
    -> Data CitationMode
    CitationMode -> Constr
    CitationMode -> DataType
    (forall b. Data b => b -> b) -> CitationMode -> CitationMode
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> CitationMode -> u
    forall u. (forall d. Data d => d -> u) -> CitationMode -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CitationMode -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CitationMode -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CitationMode
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CitationMode -> c CitationMode
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CitationMode)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CitationMode)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CitationMode -> c CitationMode
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CitationMode -> c CitationMode
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CitationMode
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CitationMode
    $ctoConstr :: CitationMode -> Constr
    toConstr :: CitationMode -> Constr
    $cdataTypeOf :: CitationMode -> DataType
    dataTypeOf :: CitationMode -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CitationMode)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CitationMode)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CitationMode)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CitationMode)
    $cgmapT :: (forall b. Data b => b -> b) -> CitationMode -> CitationMode
    gmapT :: (forall b. Data b => b -> b) -> CitationMode -> CitationMode
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CitationMode -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CitationMode -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CitationMode -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CitationMode -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> CitationMode -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CitationMode -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CitationMode -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CitationMode -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CitationMode -> m CitationMode
    Data, (forall x. CitationMode -> Rep CitationMode x)
    -> (forall x. Rep CitationMode x -> CitationMode)
    -> Generic CitationMode
    forall x. Rep CitationMode x -> CitationMode
    forall x. CitationMode -> Rep CitationMode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. CitationMode -> Rep CitationMode x
    from :: forall x. CitationMode -> Rep CitationMode x
    $cto :: forall x. Rep CitationMode x -> CitationMode
    to :: forall x. Rep CitationMode x -> CitationMode
    Generic)

    -- ToJSON/FromJSON instances. Some are defined by hand so that we have
    -- more control over the format.

    $(let jsonOpts = defaultOptions
            { allNullaryToStringTag = False
            , sumEncoding = TaggedObject { tagFieldName = "t", contentsFieldName = "c" }
            }
      in concat <$> traverse (deriveJSON jsonOpts)
         [ ''MetaValue
         , ''CitationMode
         , ''Citation
         , ''QuoteType
         , ''MathType
         , ''ListNumberStyle
         , ''ListNumberDelim
         , ''Alignment
         , ''ColWidth
         , ''Row
         , ''Caption
         , ''TableHead
         , ''TableBody
         , ''TableFoot
         , ''Cell
         , ''Inline
         , ''Block
         ])

    instance FromJSON Meta where
      parseJSON :: Value -> Parser Meta
    parseJSON = (Map Text MetaValue -> Meta)
    -> Parser (Map Text MetaValue) -> Parser Meta
    forall a b. (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Map Text MetaValue -> Meta
    Meta (Parser (Map Text MetaValue) -> Parser Meta)
    -> (Value -> Parser (Map Text MetaValue)) -> Value -> Parser Meta
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Value -> Parser (Map Text MetaValue)
    forall a. FromJSON a => Value -> Parser a
    parseJSON
    instance ToJSON Meta where
      toJSON :: Meta -> Value
    toJSON (Meta Map Text MetaValue
    m) = Map Text MetaValue -> Value
    forall a. ToJSON a => a -> Value
    toJSON Map Text MetaValue
    m
      toEncoding :: Meta -> Encoding
    toEncoding (Meta Map Text MetaValue
    m) = Map Text MetaValue -> Encoding
    forall a. ToJSON a => a -> Encoding
    toEncoding Map Text MetaValue
    m

    instance FromJSON Pandoc where
      parseJSON :: Value -> Parser Pandoc
    parseJSON (Object Object
    v) = do
        mbJVersion <- Object
    v Object -> Key -> Parser (Maybe [Int])
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "pandoc-api-version" :: Aeson.Parser (Maybe [Int])
        case mbJVersion of
          Just [Int]
    jVersion  | Int
    x : Int
    y : [Int]
    _ <- [Int]
    jVersion
                         , Int
    x' : Int
    y' : [Int]
    _ <- Version -> [Int]
    versionBranch Version
    pandocTypesVersion
                         , Int
    x Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    x'
                         , Int
    y Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    y' -> Meta -> [Block] -> Pandoc
    Pandoc (Meta -> [Block] -> Pandoc)
    -> Parser Meta -> Parser ([Block] -> Pandoc)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Object
    v Object -> Key -> Parser Meta
    forall a. FromJSON a => Object -> Key -> Parser a
    .: Key
    "meta" Parser ([Block] -> Pandoc) -> Parser [Block] -> Parser Pandoc
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Object
    v Object -> Key -> Parser [Block]
    forall a. FromJSON a => Object -> Key -> Parser a
    .: Key
    "blocks"
                         | Bool
    otherwise ->
                             String -> Parser Pandoc
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> Parser Pandoc) -> String -> Parser Pandoc
    forall a b. (a -> b) -> a -> b
    $ [String] -> String
    forall a. Monoid a => [a] -> a
    mconcat [ String
    "Incompatible API versions: "
                                            , String
    "encoded with "
                                            , [Int] -> String
    forall a. Show a => a -> String
    show [Int]
    jVersion
                                            , String
    " but attempted to decode with "
                                            , [Int] -> String
    forall a. Show a => a -> String
    show ([Int] -> String) -> [Int] -> String
    forall a b. (a -> b) -> a -> b
    $ Version -> [Int]
    versionBranch Version
    pandocTypesVersion
                                            , String
    "."
                                            ]
          Maybe [Int]
    _ -> String -> Parser Pandoc
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "JSON missing pandoc-api-version."
      parseJSON Value
    _ = Parser Pandoc
    forall a. Monoid a => a
    mempty
    instance ToJSON Pandoc where
      toJSON :: Pandoc -> Value
    toJSON (Pandoc Meta
    meta [Block]
    blks) =
        [Pair] -> Value
    object [ Key
    "pandoc-api-version" Key -> [Int] -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= Version -> [Int]
    versionBranch Version
    pandocTypesVersion
               , Key
    "meta"               Key -> Meta -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= Meta
    meta
               , Key
    "blocks"             Key -> [Block] -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= [Block]
    blks
               ]
      toEncoding :: Pandoc -> Encoding
    toEncoding (Pandoc Meta
    meta [Block]
    blks) =
        Series -> Encoding
    pairs (Series -> Encoding) -> Series -> Encoding
    forall a b. (a -> b) -> a -> b
    $ [Series] -> Series
    forall a. Monoid a => [a] -> a
    mconcat [ Key
    "pandoc-api-version" Key -> [Int] -> Series
    forall v. ToJSON v => Key -> v -> Series
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= Version -> [Int]
    versionBranch Version
    pandocTypesVersion
                        , Key
    "meta"               Key -> Meta -> Series
    forall v. ToJSON v => Key -> v -> Series
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= Meta
    meta
                        , Key
    "blocks"             Key -> [Block] -> Series
    forall v. ToJSON v => Key -> v -> Series
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= [Block]
    blks
                        ]

    -- Instances for deepseq
    instance NFData MetaValue
    instance NFData Meta
    instance NFData Citation
    instance NFData Alignment
    instance NFData RowSpan
    instance NFData ColSpan
    instance NFData Cell
    instance NFData Row
    instance NFData TableHead
    instance NFData TableBody
    instance NFData TableFoot
    instance NFData Caption
    instance NFData Inline
    instance NFData MathType
    instance NFData Format
    instance NFData CitationMode
    instance NFData QuoteType
    instance NFData ListNumberDelim
    instance NFData ListNumberStyle
    instance NFData ColWidth
    instance NFData RowHeadColumns
    instance NFData Block
    instance NFData Pandoc

    pandocTypesVersion :: Version
    pandocTypesVersion :: Version
    pandocTypesVersion = Version
    version