    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}

    module Typst.Syntax
      ( Markup (..),
        Identifier (..),
        Imports (..),
        Arg (..),
        Param (..),
        Bind (..),
        BindPart (..),
        Literal (..),
        Block (..),
        Expr (..),
        Unit (..),
      )
    where

    import Data.Data (Data, Typeable)
    import Data.String
    import Data.Text (Text)
    import qualified Data.Text as T
    import Text.Parsec (SourcePos)

    data Markup
      = Space
      | SoftBreak
      | HardBreak
      | ParBreak
      | Text Text
      | Nbsp
      | Shy
      | EmDash
      | EnDash
      | Ellipsis
      | Quote Char
      | Ref Text Expr
      | Equation Bool [Markup] -- Bool is True for displayed format
      | Strong [Markup]
      | Emph [Markup]
      | Bracketed [Markup]
      | RawInline Text
      | RawBlock Text Text
      | Heading Int [Markup]
      | Url Text
      | BulletListItem [Markup]
      | EnumListItem (Maybe Int) [Markup]
      | DescListItem [Markup] [Markup]
      | Code SourcePos Expr
      | Comment
      | MAlignPoint
      | MFrac Markup Markup
      | MAttach (Maybe Markup) (Maybe Markup) Markup -- bottom then top
      | MGroup (Maybe Text) (Maybe Text) [Markup] -- maybes are open/cloes delims
      deriving (Int -> Markup -> ShowS
    [Markup] -> ShowS
    Markup -> String
    (Int -> Markup -> ShowS)
    -> (Markup -> String) -> ([Markup] -> ShowS) -> Show Markup
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Markup -> ShowS
    showsPrec :: Int -> Markup -> ShowS
    $cshow :: Markup -> String
    show :: Markup -> String
    $cshowList :: [Markup] -> ShowS
    showList :: [Markup] -> ShowS
    Show, Eq Markup
    Eq Markup
    -> (Markup -> Markup -> Ordering)
    -> (Markup -> Markup -> Bool)
    -> (Markup -> Markup -> Bool)
    -> (Markup -> Markup -> Bool)
    -> (Markup -> Markup -> Bool)
    -> (Markup -> Markup -> Markup)
    -> (Markup -> Markup -> Markup)
    -> Ord Markup
    Markup -> Markup -> Bool
    Markup -> Markup -> Ordering
    Markup -> Markup -> Markup
    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 :: Markup -> Markup -> Ordering
    compare :: Markup -> Markup -> Ordering
    $c< :: Markup -> Markup -> Bool
    < :: Markup -> Markup -> Bool
    $c<= :: Markup -> Markup -> Bool
    <= :: Markup -> Markup -> Bool
    $c> :: Markup -> Markup -> Bool
    > :: Markup -> Markup -> Bool
    $c>= :: Markup -> Markup -> Bool
    >= :: Markup -> Markup -> Bool
    $cmax :: Markup -> Markup -> Markup
    max :: Markup -> Markup -> Markup
    $cmin :: Markup -> Markup -> Markup
    min :: Markup -> Markup -> Markup
    Ord, Markup -> Markup -> Bool
    (Markup -> Markup -> Bool)
    -> (Markup -> Markup -> Bool) -> Eq Markup
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Markup -> Markup -> Bool
    == :: Markup -> Markup -> Bool
    $c/= :: Markup -> Markup -> Bool
    /= :: Markup -> Markup -> Bool
    Eq, Typeable Markup
    Typeable Markup
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Markup -> c Markup)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Markup)
    -> (Markup -> Constr)
    -> (Markup -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Markup))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Markup))
    -> ((forall b. Data b => b -> b) -> Markup -> Markup)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Markup -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Markup -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Markup -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Markup -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Markup -> m Markup)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Markup -> m Markup)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Markup -> m Markup)
    -> Data Markup
    Markup -> Constr
    Markup -> DataType
    (forall b. Data b => b -> b) -> Markup -> Markup
    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) -> Markup -> u
    forall u. (forall d. Data d => d -> u) -> Markup -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Markup -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Markup -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Markup -> m Markup
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Markup -> m Markup
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Markup
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Markup -> c Markup
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Markup)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Markup)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Markup -> c Markup
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Markup -> c Markup
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Markup
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Markup
    $ctoConstr :: Markup -> Constr
    toConstr :: Markup -> Constr
    $cdataTypeOf :: Markup -> DataType
    dataTypeOf :: Markup -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Markup)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Markup)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Markup)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Markup)
    $cgmapT :: (forall b. Data b => b -> b) -> Markup -> Markup
    gmapT :: (forall b. Data b => b -> b) -> Markup -> Markup
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Markup -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Markup -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Markup -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Markup -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Markup -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Markup -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Markup -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Markup -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Markup -> m Markup
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Markup -> m Markup
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Markup -> m Markup
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Markup -> m Markup
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Markup -> m Markup
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Markup -> m Markup
    Data, Typeable)

    newtype Identifier = Identifier Text
      deriving (Int -> Identifier -> ShowS
    [Identifier] -> ShowS
    Identifier -> String
    (Int -> Identifier -> ShowS)
    -> (Identifier -> String)
    -> ([Identifier] -> ShowS)
    -> Show Identifier
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Identifier -> ShowS
    showsPrec :: Int -> Identifier -> ShowS
    $cshow :: Identifier -> String
    show :: Identifier -> String
    $cshowList :: [Identifier] -> ShowS
    showList :: [Identifier] -> ShowS
    Show, Identifier -> Identifier -> Bool
    (Identifier -> Identifier -> Bool)
    -> (Identifier -> Identifier -> Bool) -> Eq Identifier
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Identifier -> Identifier -> Bool
    == :: Identifier -> Identifier -> Bool
    $c/= :: Identifier -> Identifier -> Bool
    /= :: Identifier -> Identifier -> Bool
    Eq, Eq Identifier
    Eq Identifier
    -> (Identifier -> Identifier -> Ordering)
    -> (Identifier -> Identifier -> Bool)
    -> (Identifier -> Identifier -> Bool)
    -> (Identifier -> Identifier -> Bool)
    -> (Identifier -> Identifier -> Bool)
    -> (Identifier -> Identifier -> Identifier)
    -> (Identifier -> Identifier -> Identifier)
    -> Ord Identifier
    Identifier -> Identifier -> Bool
    Identifier -> Identifier -> Ordering
    Identifier -> Identifier -> Identifier
    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 :: Identifier -> Identifier -> Ordering
    compare :: Identifier -> Identifier -> Ordering
    $c< :: Identifier -> Identifier -> Bool
    < :: Identifier -> Identifier -> Bool
    $c<= :: Identifier -> Identifier -> Bool
    <= :: Identifier -> Identifier -> Bool
    $c> :: Identifier -> Identifier -> Bool
    > :: Identifier -> Identifier -> Bool
    $c>= :: Identifier -> Identifier -> Bool
    >= :: Identifier -> Identifier -> Bool
    $cmax :: Identifier -> Identifier -> Identifier
    max :: Identifier -> Identifier -> Identifier
    $cmin :: Identifier -> Identifier -> Identifier
    min :: Identifier -> Identifier -> Identifier
    Ord, Typeable Identifier
    Typeable Identifier
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Identifier -> c Identifier)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Identifier)
    -> (Identifier -> Constr)
    -> (Identifier -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Identifier))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c Identifier))
    -> ((forall b. Data b => b -> b) -> Identifier -> Identifier)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Identifier -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Identifier -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
    -> Data Identifier
    Identifier -> Constr
    Identifier -> DataType
    (forall b. Data b => b -> b) -> Identifier -> Identifier
    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) -> Identifier -> u
    forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Identifier
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Identifier -> c Identifier
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Identifier)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Identifier -> c Identifier
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Identifier -> c Identifier
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Identifier
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Identifier
    $ctoConstr :: Identifier -> Constr
    toConstr :: Identifier -> Constr
    $cdataTypeOf :: Identifier -> DataType
    dataTypeOf :: Identifier -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Identifier)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Identifier)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
    $cgmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
    gmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier
    Data, Typeable, NonEmpty Identifier -> Identifier
    Identifier -> Identifier -> Identifier
    (Identifier -> Identifier -> Identifier)
    -> (NonEmpty Identifier -> Identifier)
    -> (forall b. Integral b => b -> Identifier -> Identifier)
    -> Semigroup Identifier
    forall b. Integral b => b -> Identifier -> Identifier
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: Identifier -> Identifier -> Identifier
    <> :: Identifier -> Identifier -> Identifier
    $csconcat :: NonEmpty Identifier -> Identifier
    sconcat :: NonEmpty Identifier -> Identifier
    $cstimes :: forall b. Integral b => b -> Identifier -> Identifier
    stimes :: forall b. Integral b => b -> Identifier -> Identifier
    Semigroup, Semigroup Identifier
    Identifier
    Semigroup Identifier
    -> Identifier
    -> (Identifier -> Identifier -> Identifier)
    -> ([Identifier] -> Identifier)
    -> Monoid Identifier
    [Identifier] -> Identifier
    Identifier -> Identifier -> Identifier
    forall a.
    Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    $cmempty :: Identifier
    mempty :: Identifier
    $cmappend :: Identifier -> Identifier -> Identifier
    mappend :: Identifier -> Identifier -> Identifier
    $cmconcat :: [Identifier] -> Identifier
    mconcat :: [Identifier] -> Identifier
    Monoid)

    instance IsString Identifier where
      fromString :: String -> Identifier
    fromString = Text -> Identifier
    Identifier (Text -> Identifier) -> (String -> Text) -> String -> Identifier
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Text
    T.pack

    data Arg
      = KeyValArg Identifier Expr
      | NormalArg Expr
      | ArrayArg [[Markup]]
      | SpreadArg Expr
      | BlockArg [Markup]
      deriving (Int -> Arg -> ShowS
    [Arg] -> ShowS
    Arg -> String
    (Int -> Arg -> ShowS)
    -> (Arg -> String) -> ([Arg] -> ShowS) -> Show Arg
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Arg -> ShowS
    showsPrec :: Int -> Arg -> ShowS
    $cshow :: Arg -> String
    show :: Arg -> String
    $cshowList :: [Arg] -> ShowS
    showList :: [Arg] -> ShowS
    Show, Eq Arg
    Eq Arg
    -> (Arg -> Arg -> Ordering)
    -> (Arg -> Arg -> Bool)
    -> (Arg -> Arg -> Bool)
    -> (Arg -> Arg -> Bool)
    -> (Arg -> Arg -> Bool)
    -> (Arg -> Arg -> Arg)
    -> (Arg -> Arg -> Arg)
    -> Ord Arg
    Arg -> Arg -> Bool
    Arg -> Arg -> Ordering
    Arg -> Arg -> Arg
    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 :: Arg -> Arg -> Ordering
    compare :: Arg -> Arg -> Ordering
    $c< :: Arg -> Arg -> Bool
    < :: Arg -> Arg -> Bool
    $c<= :: Arg -> Arg -> Bool
    <= :: Arg -> Arg -> Bool
    $c> :: Arg -> Arg -> Bool
    > :: Arg -> Arg -> Bool
    $c>= :: Arg -> Arg -> Bool
    >= :: Arg -> Arg -> Bool
    $cmax :: Arg -> Arg -> Arg
    max :: Arg -> Arg -> Arg
    $cmin :: Arg -> Arg -> Arg
    min :: Arg -> Arg -> Arg
    Ord, Arg -> Arg -> Bool
    (Arg -> Arg -> Bool) -> (Arg -> Arg -> Bool) -> Eq Arg
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Arg -> Arg -> Bool
    == :: Arg -> Arg -> Bool
    $c/= :: Arg -> Arg -> Bool
    /= :: Arg -> Arg -> Bool
    Eq, Typeable Arg
    Typeable Arg
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Arg -> c Arg)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Arg)
    -> (Arg -> Constr)
    -> (Arg -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Arg))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arg))
    -> ((forall b. Data b => b -> b) -> Arg -> Arg)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Arg -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Arg -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Arg -> m Arg)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Arg -> m Arg)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Arg -> m Arg)
    -> Data Arg
    Arg -> Constr
    Arg -> DataType
    (forall b. Data b => b -> b) -> Arg -> Arg
    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) -> Arg -> u
    forall u. (forall d. Data d => d -> u) -> Arg -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Arg -> m Arg
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arg -> m Arg
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Arg
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Arg -> c Arg
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Arg)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arg)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Arg -> c Arg
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Arg -> c Arg
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Arg
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Arg
    $ctoConstr :: Arg -> Constr
    toConstr :: Arg -> Constr
    $cdataTypeOf :: Arg -> DataType
    dataTypeOf :: Arg -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Arg)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Arg)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arg)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arg)
    $cgmapT :: (forall b. Data b => b -> b) -> Arg -> Arg
    gmapT :: (forall b. Data b => b -> b) -> Arg -> Arg
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Arg -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Arg -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Arg -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Arg -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Arg -> m Arg
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Arg -> m Arg
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arg -> m Arg
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arg -> m Arg
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arg -> m Arg
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arg -> m Arg
    Data, Typeable)

    data Param
      = DefaultParam Identifier Expr
      | NormalParam Identifier
      | DestructuringParam [BindPart]
      | SinkParam (Maybe Identifier)
      | SkipParam -- _
      deriving (Int -> Param -> ShowS
    [Param] -> ShowS
    Param -> String
    (Int -> Param -> ShowS)
    -> (Param -> String) -> ([Param] -> ShowS) -> Show Param
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Param -> ShowS
    showsPrec :: Int -> Param -> ShowS
    $cshow :: Param -> String
    show :: Param -> String
    $cshowList :: [Param] -> ShowS
    showList :: [Param] -> ShowS
    Show, Eq Param
    Eq Param
    -> (Param -> Param -> Ordering)
    -> (Param -> Param -> Bool)
    -> (Param -> Param -> Bool)
    -> (Param -> Param -> Bool)
    -> (Param -> Param -> Bool)
    -> (Param -> Param -> Param)
    -> (Param -> Param -> Param)
    -> Ord Param
    Param -> Param -> Bool
    Param -> Param -> Ordering
    Param -> Param -> Param
    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 :: Param -> Param -> Ordering
    compare :: Param -> Param -> Ordering
    $c< :: Param -> Param -> Bool
    < :: Param -> Param -> Bool
    $c<= :: Param -> Param -> Bool
    <= :: Param -> Param -> Bool
    $c> :: Param -> Param -> Bool
    > :: Param -> Param -> Bool
    $c>= :: Param -> Param -> Bool
    >= :: Param -> Param -> Bool
    $cmax :: Param -> Param -> Param
    max :: Param -> Param -> Param
    $cmin :: Param -> Param -> Param
    min :: Param -> Param -> Param
    Ord, Param -> Param -> Bool
    (Param -> Param -> Bool) -> (Param -> Param -> Bool) -> Eq Param
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Param -> Param -> Bool
    == :: Param -> Param -> Bool
    $c/= :: Param -> Param -> Bool
    /= :: Param -> Param -> Bool
    Eq, Typeable Param
    Typeable Param
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Param -> c Param)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Param)
    -> (Param -> Constr)
    -> (Param -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Param))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Param))
    -> ((forall b. Data b => b -> b) -> Param -> Param)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Param -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Param -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Param -> m Param)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Param -> m Param)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Param -> m Param)
    -> Data Param
    Param -> Constr
    Param -> DataType
    (forall b. Data b => b -> b) -> Param -> Param
    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) -> Param -> u
    forall u. (forall d. Data d => d -> u) -> Param -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Param -> m Param
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Param -> m Param
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Param
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Param -> c Param
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Param)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Param)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Param -> c Param
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Param -> c Param
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Param
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Param
    $ctoConstr :: Param -> Constr
    toConstr :: Param -> Constr
    $cdataTypeOf :: Param -> DataType
    dataTypeOf :: Param -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Param)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Param)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Param)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Param)
    $cgmapT :: (forall b. Data b => b -> b) -> Param -> Param
    gmapT :: (forall b. Data b => b -> b) -> Param -> Param
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Param -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Param -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Param -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Param -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Param -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Param -> m Param
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Param -> m Param
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Param -> m Param
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Param -> m Param
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Param -> m Param
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Param -> m Param
    Data, Typeable)

    data Bind
      = BasicBind (Maybe Identifier)
      | DestructuringBind [BindPart]
      deriving (Int -> Bind -> ShowS
    [Bind] -> ShowS
    Bind -> String
    (Int -> Bind -> ShowS)
    -> (Bind -> String) -> ([Bind] -> ShowS) -> Show Bind
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Bind -> ShowS
    showsPrec :: Int -> Bind -> ShowS
    $cshow :: Bind -> String
    show :: Bind -> String
    $cshowList :: [Bind] -> ShowS
    showList :: [Bind] -> ShowS
    Show, Eq Bind
    Eq Bind
    -> (Bind -> Bind -> Ordering)
    -> (Bind -> Bind -> Bool)
    -> (Bind -> Bind -> Bool)
    -> (Bind -> Bind -> Bool)
    -> (Bind -> Bind -> Bool)
    -> (Bind -> Bind -> Bind)
    -> (Bind -> Bind -> Bind)
    -> Ord Bind
    Bind -> Bind -> Bool
    Bind -> Bind -> Ordering
    Bind -> Bind -> Bind
    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 :: Bind -> Bind -> Ordering
    compare :: Bind -> Bind -> Ordering
    $c< :: Bind -> Bind -> Bool
    < :: Bind -> Bind -> Bool
    $c<= :: Bind -> Bind -> Bool
    <= :: Bind -> Bind -> Bool
    $c> :: Bind -> Bind -> Bool
    > :: Bind -> Bind -> Bool
    $c>= :: Bind -> Bind -> Bool
    >= :: Bind -> Bind -> Bool
    $cmax :: Bind -> Bind -> Bind
    max :: Bind -> Bind -> Bind
    $cmin :: Bind -> Bind -> Bind
    min :: Bind -> Bind -> Bind
    Ord, Bind -> Bind -> Bool
    (Bind -> Bind -> Bool) -> (Bind -> Bind -> Bool) -> Eq Bind
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Bind -> Bind -> Bool
    == :: Bind -> Bind -> Bool
    $c/= :: Bind -> Bind -> Bool
    /= :: Bind -> Bind -> Bool
    Eq, Typeable Bind
    Typeable Bind
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Bind -> c Bind)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Bind)
    -> (Bind -> Constr)
    -> (Bind -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Bind))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bind))
    -> ((forall b. Data b => b -> b) -> Bind -> Bind)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bind -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bind -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Bind -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Bind -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Bind -> m Bind)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Bind -> m Bind)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Bind -> m Bind)
    -> Data Bind
    Bind -> Constr
    Bind -> DataType
    (forall b. Data b => b -> b) -> Bind -> Bind
    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) -> Bind -> u
    forall u. (forall d. Data d => d -> u) -> Bind -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bind -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bind -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bind -> m Bind
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bind -> m Bind
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bind
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bind -> c Bind
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bind)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bind)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bind -> c Bind
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bind -> c Bind
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bind
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bind
    $ctoConstr :: Bind -> Constr
    toConstr :: Bind -> Constr
    $cdataTypeOf :: Bind -> DataType
    dataTypeOf :: Bind -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bind)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bind)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bind)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bind)
    $cgmapT :: (forall b. Data b => b -> b) -> Bind -> Bind
    gmapT :: (forall b. Data b => b -> b) -> Bind -> Bind
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bind -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bind -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bind -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bind -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bind -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Bind -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bind -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bind -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bind -> m Bind
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bind -> m Bind
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bind -> m Bind
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bind -> m Bind
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bind -> m Bind
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bind -> m Bind
    Data, Typeable)

    data BindPart
      = Simple (Maybe Identifier)
      | WithKey Identifier (Maybe Identifier)
      | Sink (Maybe Identifier)
      deriving (Int -> BindPart -> ShowS
    [BindPart] -> ShowS
    BindPart -> String
    (Int -> BindPart -> ShowS)
    -> (BindPart -> String) -> ([BindPart] -> ShowS) -> Show BindPart
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BindPart -> ShowS
    showsPrec :: Int -> BindPart -> ShowS
    $cshow :: BindPart -> String
    show :: BindPart -> String
    $cshowList :: [BindPart] -> ShowS
    showList :: [BindPart] -> ShowS
    Show, Eq BindPart
    Eq BindPart
    -> (BindPart -> BindPart -> Ordering)
    -> (BindPart -> BindPart -> Bool)
    -> (BindPart -> BindPart -> Bool)
    -> (BindPart -> BindPart -> Bool)
    -> (BindPart -> BindPart -> Bool)
    -> (BindPart -> BindPart -> BindPart)
    -> (BindPart -> BindPart -> BindPart)
    -> Ord BindPart
    BindPart -> BindPart -> Bool
    BindPart -> BindPart -> Ordering
    BindPart -> BindPart -> BindPart
    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 :: BindPart -> BindPart -> Ordering
    compare :: BindPart -> BindPart -> Ordering
    $c< :: BindPart -> BindPart -> Bool
    < :: BindPart -> BindPart -> Bool
    $c<= :: BindPart -> BindPart -> Bool
    <= :: BindPart -> BindPart -> Bool
    $c> :: BindPart -> BindPart -> Bool
    > :: BindPart -> BindPart -> Bool
    $c>= :: BindPart -> BindPart -> Bool
    >= :: BindPart -> BindPart -> Bool
    $cmax :: BindPart -> BindPart -> BindPart
    max :: BindPart -> BindPart -> BindPart
    $cmin :: BindPart -> BindPart -> BindPart
    min :: BindPart -> BindPart -> BindPart
    Ord, BindPart -> BindPart -> Bool
    (BindPart -> BindPart -> Bool)
    -> (BindPart -> BindPart -> Bool) -> Eq BindPart
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BindPart -> BindPart -> Bool
    == :: BindPart -> BindPart -> Bool
    $c/= :: BindPart -> BindPart -> Bool
    /= :: BindPart -> BindPart -> Bool
    Eq, Typeable BindPart
    Typeable BindPart
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> BindPart -> c BindPart)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c BindPart)
    -> (BindPart -> Constr)
    -> (BindPart -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c BindPart))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindPart))
    -> ((forall b. Data b => b -> b) -> BindPart -> BindPart)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> BindPart -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> BindPart -> r)
    -> (forall u. (forall d. Data d => d -> u) -> BindPart -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> BindPart -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> BindPart -> m BindPart)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BindPart -> m BindPart)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BindPart -> m BindPart)
    -> Data BindPart
    BindPart -> Constr
    BindPart -> DataType
    (forall b. Data b => b -> b) -> BindPart -> BindPart
    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) -> BindPart -> u
    forall u. (forall d. Data d => d -> u) -> BindPart -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BindPart -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BindPart -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BindPart -> m BindPart
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindPart -> m BindPart
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BindPart
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BindPart -> c BindPart
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BindPart)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindPart)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BindPart -> c BindPart
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BindPart -> c BindPart
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BindPart
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BindPart
    $ctoConstr :: BindPart -> Constr
    toConstr :: BindPart -> Constr
    $cdataTypeOf :: BindPart -> DataType
    dataTypeOf :: BindPart -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BindPart)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BindPart)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindPart)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindPart)
    $cgmapT :: (forall b. Data b => b -> b) -> BindPart -> BindPart
    gmapT :: (forall b. Data b => b -> b) -> BindPart -> BindPart
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BindPart -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BindPart -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BindPart -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BindPart -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> BindPart -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> BindPart -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BindPart -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BindPart -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BindPart -> m BindPart
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BindPart -> m BindPart
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindPart -> m BindPart
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindPart -> m BindPart
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindPart -> m BindPart
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindPart -> m BindPart
    Data, Typeable)

    data Unit = Pt | Mm | Cm | In | Deg | Rad | Em | Fr | Percent
      deriving (Int -> Unit -> ShowS
    [Unit] -> ShowS
    Unit -> String
    (Int -> Unit -> ShowS)
    -> (Unit -> String) -> ([Unit] -> ShowS) -> Show Unit
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Unit -> ShowS
    showsPrec :: Int -> Unit -> ShowS
    $cshow :: Unit -> String
    show :: Unit -> String
    $cshowList :: [Unit] -> ShowS
    showList :: [Unit] -> ShowS
    Show, Eq Unit
    Eq Unit
    -> (Unit -> Unit -> Ordering)
    -> (Unit -> Unit -> Bool)
    -> (Unit -> Unit -> Bool)
    -> (Unit -> Unit -> Bool)
    -> (Unit -> Unit -> Bool)
    -> (Unit -> Unit -> Unit)
    -> (Unit -> Unit -> Unit)
    -> Ord Unit
    Unit -> Unit -> Bool
    Unit -> Unit -> Ordering
    Unit -> Unit -> Unit
    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 :: Unit -> Unit -> Ordering
    compare :: Unit -> Unit -> Ordering
    $c< :: Unit -> Unit -> Bool
    < :: Unit -> Unit -> Bool
    $c<= :: Unit -> Unit -> Bool
    <= :: Unit -> Unit -> Bool
    $c> :: Unit -> Unit -> Bool
    > :: Unit -> Unit -> Bool
    $c>= :: Unit -> Unit -> Bool
    >= :: Unit -> Unit -> Bool
    $cmax :: Unit -> Unit -> Unit
    max :: Unit -> Unit -> Unit
    $cmin :: Unit -> Unit -> Unit
    min :: Unit -> Unit -> Unit
    Ord, Unit -> Unit -> Bool
    (Unit -> Unit -> Bool) -> (Unit -> Unit -> Bool) -> Eq Unit
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Unit -> Unit -> Bool
    == :: Unit -> Unit -> Bool
    $c/= :: Unit -> Unit -> Bool
    /= :: Unit -> Unit -> Bool
    Eq, Typeable Unit
    Typeable Unit
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Unit -> c Unit)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Unit)
    -> (Unit -> Constr)
    -> (Unit -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Unit))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unit))
    -> ((forall b. Data b => b -> b) -> Unit -> Unit)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Unit -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Unit -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Unit -> m Unit)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Unit -> m Unit)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Unit -> m Unit)
    -> Data Unit
    Unit -> Constr
    Unit -> DataType
    (forall b. Data b => b -> b) -> Unit -> Unit
    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) -> Unit -> u
    forall u. (forall d. Data d => d -> u) -> Unit -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Unit -> m Unit
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Unit -> m Unit
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Unit
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Unit -> c Unit
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Unit)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unit)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Unit -> c Unit
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Unit -> c Unit
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Unit
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Unit
    $ctoConstr :: Unit -> Constr
    toConstr :: Unit -> Constr
    $cdataTypeOf :: Unit -> DataType
    dataTypeOf :: Unit -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Unit)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Unit)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unit)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unit)
    $cgmapT :: (forall b. Data b => b -> b) -> Unit -> Unit
    gmapT :: (forall b. Data b => b -> b) -> Unit -> Unit
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Unit -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Unit -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Unit -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Unit -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Unit -> m Unit
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Unit -> m Unit
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Unit -> m Unit
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Unit -> m Unit
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Unit -> m Unit
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Unit -> m Unit
    Data, Typeable)

    data Literal
      = String Text
      | Boolean Bool
      | Float Double
      | Int Integer
      | Numeric Double Unit
      | None
      | Auto
      deriving (Int -> Literal -> ShowS
    [Literal] -> ShowS
    Literal -> String
    (Int -> Literal -> ShowS)
    -> (Literal -> String) -> ([Literal] -> ShowS) -> Show Literal
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Literal -> ShowS
    showsPrec :: Int -> Literal -> ShowS
    $cshow :: Literal -> String
    show :: Literal -> String
    $cshowList :: [Literal] -> ShowS
    showList :: [Literal] -> ShowS
    Show, Eq Literal
    Eq Literal
    -> (Literal -> Literal -> Ordering)
    -> (Literal -> Literal -> Bool)
    -> (Literal -> Literal -> Bool)
    -> (Literal -> Literal -> Bool)
    -> (Literal -> Literal -> Bool)
    -> (Literal -> Literal -> Literal)
    -> (Literal -> Literal -> Literal)
    -> Ord Literal
    Literal -> Literal -> Bool
    Literal -> Literal -> Ordering
    Literal -> Literal -> Literal
    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 :: Literal -> Literal -> Ordering
    compare :: Literal -> Literal -> Ordering
    $c< :: Literal -> Literal -> Bool
    < :: Literal -> Literal -> Bool
    $c<= :: Literal -> Literal -> Bool
    <= :: Literal -> Literal -> Bool
    $c> :: Literal -> Literal -> Bool
    > :: Literal -> Literal -> Bool
    $c>= :: Literal -> Literal -> Bool
    >= :: Literal -> Literal -> Bool
    $cmax :: Literal -> Literal -> Literal
    max :: Literal -> Literal -> Literal
    $cmin :: Literal -> Literal -> Literal
    min :: Literal -> Literal -> Literal
    Ord, Literal -> Literal -> Bool
    (Literal -> Literal -> Bool)
    -> (Literal -> Literal -> Bool) -> Eq Literal
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Literal -> Literal -> Bool
    == :: Literal -> Literal -> Bool
    $c/= :: Literal -> Literal -> Bool
    /= :: Literal -> Literal -> Bool
    Eq, Typeable Literal
    Typeable Literal
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Literal -> c Literal)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Literal)
    -> (Literal -> Constr)
    -> (Literal -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Literal))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal))
    -> ((forall b. Data b => b -> b) -> Literal -> Literal)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Literal -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Literal -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Literal -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Literal -> m Literal)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Literal -> m Literal)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Literal -> m Literal)
    -> Data Literal
    Literal -> Constr
    Literal -> DataType
    (forall b. Data b => b -> b) -> Literal -> Literal
    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) -> Literal -> u
    forall u. (forall d. Data d => d -> u) -> Literal -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Literal
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal -> c Literal
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Literal)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal -> c Literal
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal -> c Literal
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Literal
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Literal
    $ctoConstr :: Literal -> Constr
    toConstr :: Literal -> Constr
    $cdataTypeOf :: Literal -> DataType
    dataTypeOf :: Literal -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Literal)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Literal)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
    $cgmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
    gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Literal -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Literal -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal
    Data, Typeable)

    data Block
      = Content [Markup]
      | CodeBlock [Expr]
      deriving (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, 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, 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, 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, Typeable)

    -- binary-op ::=
    --   '+' | '-' | '*' | '/' | 'and' | 'or' | '==' | '!=' |
    --   '<' | '<=' | '>' | '>=' | '=' | 'in' | ('not' 'in') |
    --   '+=' | '-=' | '*=' | '/='
    data Expr
      = Literal Literal
      | Negated Expr
      | ToPower Expr Expr
      | Times Expr Expr
      | Divided Expr Expr
      | Plus Expr Expr
      | Minus Expr Expr
      | Equals Expr Expr
      | LessThan Expr Expr
      | LessThanOrEqual Expr Expr
      | GreaterThan Expr Expr
      | GreaterThanOrEqual Expr Expr
      | InCollection Expr Expr
      | Not Expr
      | And Expr Expr
      | Or Expr Expr
      | Assign Expr Expr
      | Ident Identifier
      | FuncCall Expr [Arg]
      | FuncExpr [Param] Expr
      | FieldAccess Expr Expr
      | Group Expr
      | Array [Expr]
      | Dict [(Identifier, Expr)]
      | Binding Bind
      | Let Bind Expr
      | LetFunc Identifier [Param] Expr
      | Set Expr [Arg]
      | Show (Maybe Expr) Expr
      | If [(Expr, Expr)]
      | While Expr Expr
      | For Bind Expr Expr
      | Block Block
      | Import Expr Imports
      | Include Expr
      | Return (Maybe Expr)
      | Label Text
      | Break
      | Continue
      deriving (Int -> Expr -> ShowS
    [Expr] -> ShowS
    Expr -> String
    (Int -> Expr -> ShowS)
    -> (Expr -> String) -> ([Expr] -> ShowS) -> Show Expr
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Expr -> ShowS
    showsPrec :: Int -> Expr -> ShowS
    $cshow :: Expr -> String
    show :: Expr -> String
    $cshowList :: [Expr] -> ShowS
    showList :: [Expr] -> ShowS
    Show, Eq Expr
    Eq Expr
    -> (Expr -> Expr -> Ordering)
    -> (Expr -> Expr -> Bool)
    -> (Expr -> Expr -> Bool)
    -> (Expr -> Expr -> Bool)
    -> (Expr -> Expr -> Bool)
    -> (Expr -> Expr -> Expr)
    -> (Expr -> Expr -> Expr)
    -> Ord Expr
    Expr -> Expr -> Bool
    Expr -> Expr -> Ordering
    Expr -> Expr -> Expr
    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 :: Expr -> Expr -> Ordering
    compare :: Expr -> Expr -> Ordering
    $c< :: Expr -> Expr -> Bool
    < :: Expr -> Expr -> Bool
    $c<= :: Expr -> Expr -> Bool
    <= :: Expr -> Expr -> Bool
    $c> :: Expr -> Expr -> Bool
    > :: Expr -> Expr -> Bool
    $c>= :: Expr -> Expr -> Bool
    >= :: Expr -> Expr -> Bool
    $cmax :: Expr -> Expr -> Expr
    max :: Expr -> Expr -> Expr
    $cmin :: Expr -> Expr -> Expr
    min :: Expr -> Expr -> Expr
    Ord, Expr -> Expr -> Bool
    (Expr -> Expr -> Bool) -> (Expr -> Expr -> Bool) -> Eq Expr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Expr -> Expr -> Bool
    == :: Expr -> Expr -> Bool
    $c/= :: Expr -> Expr -> Bool
    /= :: Expr -> Expr -> Bool
    Eq, Typeable Expr
    Typeable Expr
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Expr -> c Expr)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Expr)
    -> (Expr -> Constr)
    -> (Expr -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Expr))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr))
    -> ((forall b. Data b => b -> b) -> Expr -> Expr)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Expr -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Expr -> m Expr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Expr -> m Expr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Expr -> m Expr)
    -> Data Expr
    Expr -> Constr
    Expr -> DataType
    (forall b. Data b => b -> b) -> Expr -> Expr
    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) -> Expr -> u
    forall u. (forall d. Data d => d -> u) -> Expr -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr -> c Expr
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Expr)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr -> c Expr
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr -> c Expr
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr
    $ctoConstr :: Expr -> Constr
    toConstr :: Expr -> Constr
    $cdataTypeOf :: Expr -> DataType
    dataTypeOf :: Expr -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Expr)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Expr)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
    $cgmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
    gmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    Data, Typeable)

    data Imports
      = AllIdentifiers
      | SomeIdentifiers [Identifier]
      | NoIdentifiers
      deriving (Int -> Imports -> ShowS
    [Imports] -> ShowS
    Imports -> String
    (Int -> Imports -> ShowS)
    -> (Imports -> String) -> ([Imports] -> ShowS) -> Show Imports
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Imports -> ShowS
    showsPrec :: Int -> Imports -> ShowS
    $cshow :: Imports -> String
    show :: Imports -> String
    $cshowList :: [Imports] -> ShowS
    showList :: [Imports] -> ShowS
    Show, Eq Imports
    Eq Imports
    -> (Imports -> Imports -> Ordering)
    -> (Imports -> Imports -> Bool)
    -> (Imports -> Imports -> Bool)
    -> (Imports -> Imports -> Bool)
    -> (Imports -> Imports -> Bool)
    -> (Imports -> Imports -> Imports)
    -> (Imports -> Imports -> Imports)
    -> Ord Imports
    Imports -> Imports -> Bool
    Imports -> Imports -> Ordering
    Imports -> Imports -> Imports
    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 :: Imports -> Imports -> Ordering
    compare :: Imports -> Imports -> Ordering
    $c< :: Imports -> Imports -> Bool
    < :: Imports -> Imports -> Bool
    $c<= :: Imports -> Imports -> Bool
    <= :: Imports -> Imports -> Bool
    $c> :: Imports -> Imports -> Bool
    > :: Imports -> Imports -> Bool
    $c>= :: Imports -> Imports -> Bool
    >= :: Imports -> Imports -> Bool
    $cmax :: Imports -> Imports -> Imports
    max :: Imports -> Imports -> Imports
    $cmin :: Imports -> Imports -> Imports
    min :: Imports -> Imports -> Imports
    Ord, Imports -> Imports -> Bool
    (Imports -> Imports -> Bool)
    -> (Imports -> Imports -> Bool) -> Eq Imports
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Imports -> Imports -> Bool
    == :: Imports -> Imports -> Bool
    $c/= :: Imports -> Imports -> Bool
    /= :: Imports -> Imports -> Bool
    Eq, Typeable Imports
    Typeable Imports
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Imports -> c Imports)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Imports)
    -> (Imports -> Constr)
    -> (Imports -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Imports))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Imports))
    -> ((forall b. Data b => b -> b) -> Imports -> Imports)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Imports -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Imports -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Imports -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Imports -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Imports -> m Imports)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Imports -> m Imports)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Imports -> m Imports)
    -> Data Imports
    Imports -> Constr
    Imports -> DataType
    (forall b. Data b => b -> b) -> Imports -> Imports
    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) -> Imports -> u
    forall u. (forall d. Data d => d -> u) -> Imports -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Imports -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Imports -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Imports
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Imports -> c Imports
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Imports)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Imports)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Imports -> c Imports
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Imports -> c Imports
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Imports
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Imports
    $ctoConstr :: Imports -> Constr
    toConstr :: Imports -> Constr
    $cdataTypeOf :: Imports -> DataType
    dataTypeOf :: Imports -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Imports)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Imports)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Imports)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Imports)
    $cgmapT :: (forall b. Data b => b -> b) -> Imports -> Imports
    gmapT :: (forall b. Data b => b -> b) -> Imports -> Imports
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Imports -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Imports -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Imports -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Imports -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Imports -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Imports -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Imports -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Imports -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports
    Data, Typeable)