    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE TemplateHaskell #-}
    {-# LANGUAGE FlexibleInstances #-}
    module Text.Hamlet.Parse
        ( Binding (..)
        , specialOrIdent
        , DataConstr (..)
        , Module (..)
        )
        where

    import Data.Data (Data)
    import Data.Typeable (Typeable)
    import Text.Shakespeare.Base (Ident(..))

    data Binding = BindVar Ident
                 | BindAs Ident Binding
                 | BindConstr DataConstr [Binding]
                 | BindTuple [Binding]
                 | BindList [Binding]
                 | BindRecord DataConstr [(Ident, Binding)] Bool
        deriving (Binding -> Binding -> Bool
    (Binding -> Binding -> Bool)
    -> (Binding -> Binding -> Bool) -> Eq Binding
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Binding -> Binding -> Bool
    $c/= :: Binding -> Binding -> Bool
    == :: Binding -> Binding -> Bool
    $c== :: Binding -> Binding -> Bool
    Eq, Int -> Binding -> ShowS
    [Binding] -> ShowS
    Binding -> String
    (Int -> Binding -> ShowS)
    -> (Binding -> String) -> ([Binding] -> ShowS) -> Show Binding
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Binding] -> ShowS
    $cshowList :: [Binding] -> ShowS
    show :: Binding -> String
    $cshow :: Binding -> String
    showsPrec :: Int -> Binding -> ShowS
    $cshowsPrec :: Int -> Binding -> ShowS
    Show, ReadPrec [Binding]
    ReadPrec Binding
    Int -> ReadS Binding
    ReadS [Binding]
    (Int -> ReadS Binding)
    -> ReadS [Binding]
    -> ReadPrec Binding
    -> ReadPrec [Binding]
    -> Read Binding
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Binding]
    $creadListPrec :: ReadPrec [Binding]
    readPrec :: ReadPrec Binding
    $creadPrec :: ReadPrec Binding
    readList :: ReadS [Binding]
    $creadList :: ReadS [Binding]
    readsPrec :: Int -> ReadS Binding
    $creadsPrec :: Int -> ReadS Binding
    Read, Typeable Binding
    Constr
    DataType
    Typeable Binding =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Binding -> c Binding)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Binding)
    -> (Binding -> Constr)
    -> (Binding -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Binding))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binding))
    -> ((forall b. Data b => b -> b) -> Binding -> Binding)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Binding -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Binding -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Binding -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Binding -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Binding -> m Binding)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Binding -> m Binding)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Binding -> m Binding)
    -> Data Binding
    Binding -> Constr
    Binding -> DataType
    (forall b. Data b => b -> b) -> Binding -> Binding
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binding -> c Binding
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Binding
    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) -> Binding -> u
    forall u. (forall d. Data d => d -> u) -> Binding -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binding -> m Binding
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binding -> m Binding
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Binding
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binding -> c Binding
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Binding)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binding)
    $cBindRecord :: Constr
    $cBindList :: Constr
    $cBindTuple :: Constr
    $cBindConstr :: Constr
    $cBindAs :: Constr
    $cBindVar :: Constr
    $tBinding :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> Binding -> m Binding
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binding -> m Binding
    gmapMp :: (forall d. Data d => d -> m d) -> Binding -> m Binding
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binding -> m Binding
    gmapM :: (forall d. Data d => d -> m d) -> Binding -> m Binding
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binding -> m Binding
    gmapQi :: Int -> (forall d. Data d => d -> u) -> Binding -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binding -> u
    gmapQ :: (forall d. Data d => d -> u) -> Binding -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Binding -> [u]
    gmapQr :: (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding -> r
    gmapQl :: (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding -> r
    gmapT :: (forall b. Data b => b -> b) -> Binding -> Binding
    $cgmapT :: (forall b. Data b => b -> b) -> Binding -> Binding
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binding)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binding)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Binding)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Binding)
    dataTypeOf :: Binding -> DataType
    $cdataTypeOf :: Binding -> DataType
    toConstr :: Binding -> Constr
    $ctoConstr :: Binding -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Binding
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Binding
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binding -> c Binding
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binding -> c Binding
    $cp1Data :: Typeable Binding
    Data, Typeable)

    data DataConstr = DCQualified Module Ident
                    | DCUnqualified Ident
        deriving (DataConstr -> DataConstr -> Bool
    (DataConstr -> DataConstr -> Bool)
    -> (DataConstr -> DataConstr -> Bool) -> Eq DataConstr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DataConstr -> DataConstr -> Bool
    $c/= :: DataConstr -> DataConstr -> Bool
    == :: DataConstr -> DataConstr -> Bool
    $c== :: DataConstr -> DataConstr -> Bool
    Eq, Int -> DataConstr -> ShowS
    [DataConstr] -> ShowS
    DataConstr -> String
    (Int -> DataConstr -> ShowS)
    -> (DataConstr -> String)
    -> ([DataConstr] -> ShowS)
    -> Show DataConstr
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [DataConstr] -> ShowS
    $cshowList :: [DataConstr] -> ShowS
    show :: DataConstr -> String
    $cshow :: DataConstr -> String
    showsPrec :: Int -> DataConstr -> ShowS
    $cshowsPrec :: Int -> DataConstr -> ShowS
    Show, ReadPrec [DataConstr]
    ReadPrec DataConstr
    Int -> ReadS DataConstr
    ReadS [DataConstr]
    (Int -> ReadS DataConstr)
    -> ReadS [DataConstr]
    -> ReadPrec DataConstr
    -> ReadPrec [DataConstr]
    -> Read DataConstr
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [DataConstr]
    $creadListPrec :: ReadPrec [DataConstr]
    readPrec :: ReadPrec DataConstr
    $creadPrec :: ReadPrec DataConstr
    readList :: ReadS [DataConstr]
    $creadList :: ReadS [DataConstr]
    readsPrec :: Int -> ReadS DataConstr
    $creadsPrec :: Int -> ReadS DataConstr
    Read, Typeable DataConstr
    Constr
    DataType
    Typeable DataConstr =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DataConstr -> c DataConstr)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DataConstr)
    -> (DataConstr -> Constr)
    -> (DataConstr -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DataConstr))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DataConstr))
    -> ((forall b. Data b => b -> b) -> DataConstr -> DataConstr)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DataConstr -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DataConstr -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DataConstr -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DataConstr -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr)
    -> Data DataConstr
    DataConstr -> Constr
    DataConstr -> DataType
    (forall b. Data b => b -> b) -> DataConstr -> DataConstr
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataConstr -> c DataConstr
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataConstr
    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) -> DataConstr -> u
    forall u. (forall d. Data d => d -> u) -> DataConstr -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConstr -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConstr -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataConstr
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataConstr -> c DataConstr
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataConstr)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConstr)
    $cDCUnqualified :: Constr
    $cDCQualified :: Constr
    $tDataConstr :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr
    gmapMp :: (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr
    gmapM :: (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataConstr -> m DataConstr
    gmapQi :: Int -> (forall d. Data d => d -> u) -> DataConstr -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataConstr -> u
    gmapQ :: (forall d. Data d => d -> u) -> DataConstr -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataConstr -> [u]
    gmapQr :: (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConstr -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConstr -> r
    gmapQl :: (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConstr -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConstr -> r
    gmapT :: (forall b. Data b => b -> b) -> DataConstr -> DataConstr
    $cgmapT :: (forall b. Data b => b -> b) -> DataConstr -> DataConstr
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConstr)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConstr)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DataConstr)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataConstr)
    dataTypeOf :: DataConstr -> DataType
    $cdataTypeOf :: DataConstr -> DataType
    toConstr :: DataConstr -> Constr
    $ctoConstr :: DataConstr -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataConstr
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataConstr
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataConstr -> c DataConstr
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataConstr -> c DataConstr
    $cp1Data :: Typeable DataConstr
    Data, Typeable)

    newtype Module = Module [String]
        deriving (Module -> Module -> Bool
    (Module -> Module -> Bool)
    -> (Module -> Module -> Bool) -> Eq Module
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Module -> Module -> Bool
    $c/= :: Module -> Module -> Bool
    == :: Module -> Module -> Bool
    $c== :: Module -> Module -> Bool
    Eq, Int -> Module -> ShowS
    [Module] -> ShowS
    Module -> String
    (Int -> Module -> ShowS)
    -> (Module -> String) -> ([Module] -> ShowS) -> Show Module
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Module] -> ShowS
    $cshowList :: [Module] -> ShowS
    show :: Module -> String
    $cshow :: Module -> String
    showsPrec :: Int -> Module -> ShowS
    $cshowsPrec :: Int -> Module -> ShowS
    Show, ReadPrec [Module]
    ReadPrec Module
    Int -> ReadS Module
    ReadS [Module]
    (Int -> ReadS Module)
    -> ReadS [Module]
    -> ReadPrec Module
    -> ReadPrec [Module]
    -> Read Module
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Module]
    $creadListPrec :: ReadPrec [Module]
    readPrec :: ReadPrec Module
    $creadPrec :: ReadPrec Module
    readList :: ReadS [Module]
    $creadList :: ReadS [Module]
    readsPrec :: Int -> ReadS Module
    $creadsPrec :: Int -> ReadS Module
    Read, Typeable Module
    Constr
    DataType
    Typeable Module =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Module -> c Module)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Module)
    -> (Module -> Constr)
    -> (Module -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Module))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module))
    -> ((forall b. Data b => b -> b) -> Module -> Module)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Module -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Module -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Module -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Module -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Module -> m Module)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Module -> m Module)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Module -> m Module)
    -> Data Module
    Module -> Constr
    Module -> DataType
    (forall b. Data b => b -> b) -> Module -> Module
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    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) -> Module -> u
    forall u. (forall d. Data d => d -> u) -> Module -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
    $cModule :: Constr
    $tModule :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> Module -> m Module
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    gmapMp :: (forall d. Data d => d -> m d) -> Module -> m Module
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    gmapM :: (forall d. Data d => d -> m d) -> Module -> m Module
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
    gmapQ :: (forall d. Data d => d -> u) -> Module -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
    gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    gmapT :: (forall b. Data b => b -> b) -> Module -> Module
    $cgmapT :: (forall b. Data b => b -> b) -> Module -> Module
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Module)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module)
    dataTypeOf :: Module -> DataType
    $cdataTypeOf :: Module -> DataType
    toConstr :: Module -> Constr
    $ctoConstr :: Module -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    $cp1Data :: Typeable Module
    Data, Typeable)

    -- | This funny hack is to allow us to refer to the 'or' function without
    -- requiring the user to have it in scope. See how this function is used in
    -- Text.Hamlet.
    specialOrIdent :: Ident
    specialOrIdent :: Ident
    specialOrIdent = String -> Ident
    Ident "__or__hamlet__special"