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

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Language.Haskell.Syntax
    -- Copyright   :  (c) The GHC Team, 1997-2000
    -- License     :  BSD-3-Clause
    --
    -- Maintainer  :  Andreas Abel
    -- Stability   :  stable
    -- Portability :  portable
    --
    -- A suite of datatypes describing the abstract syntax of
    -- <http://www.haskell.org/onlinereport/ Haskell 98> plus a few extensions:
    --
    --   * multi-parameter type classes
    --
    --   * parameters of type class assertions are unrestricted
    --
    -- For GHC, we also derive 'Data' for all types.

    -----------------------------------------------------------------------------

    module Language.Haskell.Syntax (
        -- * Modules
        HsModule(..), HsExportSpec(..),
        HsImportDecl(..), HsImportSpec(..), HsAssoc(..),
        -- * Declarations
        HsDecl(..), HsConDecl(..), HsBangType(..),
        HsMatch(..), HsRhs(..), HsGuardedRhs(..),
        HsSafety(..),
        -- * Class Assertions and Contexts
        HsQualType(..), HsContext, HsAsst,
        -- * Types
        HsType(..),
        -- * Expressions
        HsExp(..), HsStmt(..), HsFieldUpdate(..),
        HsAlt(..), HsGuardedAlts(..), HsGuardedAlt(..),
        -- * Patterns
        HsPat(..), HsPatField(..),
        -- * Literals
        HsLiteral(..),
        -- * Variables, Constructors and Operators
        Module(..), HsQName(..), HsName(..), HsQOp(..), HsOp(..),
        HsSpecialCon(..), HsCName(..),

        -- * Builtin names

        -- ** Modules
        prelude_mod, main_mod,
        -- ** Main function of a program
        main_name,
        -- ** Constructors
        unit_con_name, tuple_con_name, list_cons_name,
        unit_con, tuple_con,
        -- ** Type constructors
        unit_tycon_name, fun_tycon_name, list_tycon_name, tuple_tycon_name,
        unit_tycon, fun_tycon, list_tycon, tuple_tycon,

        -- * Source coordinates
        SrcLoc(..),
      ) where

    #ifdef __GLASGOW_HASKELL__
    import           Data.Generics.Basics
    import           Data.Generics.Instances ()
    #endif

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

    -- | The name of a Haskell module.
    newtype Module = Module String
    #ifdef __GLASGOW_HASKELL__
      deriving (Module -> Module -> Bool
    (Module -> Module -> Bool)
    -> (Module -> Module -> Bool) -> Eq Module
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Module -> Module -> Bool
    == :: Module -> Module -> Bool
    $c/= :: Module -> Module -> Bool
    /= :: Module -> Module -> Bool
    Eq,Eq Module
    Eq Module =>
    (Module -> Module -> Ordering)
    -> (Module -> Module -> Bool)
    -> (Module -> Module -> Bool)
    -> (Module -> Module -> Bool)
    -> (Module -> Module -> Bool)
    -> (Module -> Module -> Module)
    -> (Module -> Module -> Module)
    -> Ord Module
    Module -> Module -> Bool
    Module -> Module -> Ordering
    Module -> Module -> Module
    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 :: Module -> Module -> Ordering
    compare :: Module -> Module -> Ordering
    $c< :: Module -> Module -> Bool
    < :: Module -> Module -> Bool
    $c<= :: Module -> Module -> Bool
    <= :: Module -> Module -> Bool
    $c> :: Module -> Module -> Bool
    > :: Module -> Module -> Bool
    $c>= :: Module -> Module -> Bool
    >= :: Module -> Module -> Bool
    $cmax :: Module -> Module -> Module
    max :: Module -> Module -> Module
    $cmin :: Module -> Module -> Module
    min :: Module -> Module -> Module
    Ord,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
    $cshowsPrec :: Int -> Module -> ShowS
    showsPrec :: Int -> Module -> ShowS
    $cshow :: Module -> String
    show :: Module -> String
    $cshowList :: [Module] -> ShowS
    showList :: [Module] -> ShowS
    Show,Typeable Module
    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 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)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module
    $ctoConstr :: Module -> Constr
    toConstr :: Module -> Constr
    $cdataTypeOf :: Module -> DataType
    dataTypeOf :: Module -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
    $cgmapT :: (forall b. Data b => b -> b) -> Module -> Module
    gmapT :: (forall b. Data b => b -> b) -> Module -> Module
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    gmapQl :: forall r r'.
    (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
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (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
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (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
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module
    Data)
    #else
      deriving (Eq,Ord,Show)
    #endif

    -- | Constructors with special syntax.
    -- These names are never qualified, and always refer to builtin type or
    -- data constructors.

    data HsSpecialCon
            = HsUnitCon             -- ^ Unit type and data constructor @()@.
            | HsListCon             -- ^ List type constructor @[]@.
            | HsFunCon              -- ^ Function type constructor @->@.
            | HsTupleCon Int        -- ^ /n/-ary tuple type and data
                                    --   constructors @(,)@ etc.
            | HsCons                -- ^ List data constructor @(:)@.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsSpecialCon -> HsSpecialCon -> Bool
    (HsSpecialCon -> HsSpecialCon -> Bool)
    -> (HsSpecialCon -> HsSpecialCon -> Bool) -> Eq HsSpecialCon
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsSpecialCon -> HsSpecialCon -> Bool
    == :: HsSpecialCon -> HsSpecialCon -> Bool
    $c/= :: HsSpecialCon -> HsSpecialCon -> Bool
    /= :: HsSpecialCon -> HsSpecialCon -> Bool
    Eq,Eq HsSpecialCon
    Eq HsSpecialCon =>
    (HsSpecialCon -> HsSpecialCon -> Ordering)
    -> (HsSpecialCon -> HsSpecialCon -> Bool)
    -> (HsSpecialCon -> HsSpecialCon -> Bool)
    -> (HsSpecialCon -> HsSpecialCon -> Bool)
    -> (HsSpecialCon -> HsSpecialCon -> Bool)
    -> (HsSpecialCon -> HsSpecialCon -> HsSpecialCon)
    -> (HsSpecialCon -> HsSpecialCon -> HsSpecialCon)
    -> Ord HsSpecialCon
    HsSpecialCon -> HsSpecialCon -> Bool
    HsSpecialCon -> HsSpecialCon -> Ordering
    HsSpecialCon -> HsSpecialCon -> HsSpecialCon
    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 :: HsSpecialCon -> HsSpecialCon -> Ordering
    compare :: HsSpecialCon -> HsSpecialCon -> Ordering
    $c< :: HsSpecialCon -> HsSpecialCon -> Bool
    < :: HsSpecialCon -> HsSpecialCon -> Bool
    $c<= :: HsSpecialCon -> HsSpecialCon -> Bool
    <= :: HsSpecialCon -> HsSpecialCon -> Bool
    $c> :: HsSpecialCon -> HsSpecialCon -> Bool
    > :: HsSpecialCon -> HsSpecialCon -> Bool
    $c>= :: HsSpecialCon -> HsSpecialCon -> Bool
    >= :: HsSpecialCon -> HsSpecialCon -> Bool
    $cmax :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon
    max :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon
    $cmin :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon
    min :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon
    Ord,Int -> HsSpecialCon -> ShowS
    [HsSpecialCon] -> ShowS
    HsSpecialCon -> String
    (Int -> HsSpecialCon -> ShowS)
    -> (HsSpecialCon -> String)
    -> ([HsSpecialCon] -> ShowS)
    -> Show HsSpecialCon
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsSpecialCon -> ShowS
    showsPrec :: Int -> HsSpecialCon -> ShowS
    $cshow :: HsSpecialCon -> String
    show :: HsSpecialCon -> String
    $cshowList :: [HsSpecialCon] -> ShowS
    showList :: [HsSpecialCon] -> ShowS
    Show,Typeable HsSpecialCon
    Typeable HsSpecialCon =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsSpecialCon)
    -> (HsSpecialCon -> Constr)
    -> (HsSpecialCon -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsSpecialCon))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsSpecialCon))
    -> ((forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsSpecialCon -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon)
    -> Data HsSpecialCon
    HsSpecialCon -> Constr
    HsSpecialCon -> DataType
    (forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon
    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) -> HsSpecialCon -> u
    forall u. (forall d. Data d => d -> u) -> HsSpecialCon -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsSpecialCon
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsSpecialCon)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsSpecialCon)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsSpecialCon
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsSpecialCon
    $ctoConstr :: HsSpecialCon -> Constr
    toConstr :: HsSpecialCon -> Constr
    $cdataTypeOf :: HsSpecialCon -> DataType
    dataTypeOf :: HsSpecialCon -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsSpecialCon)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsSpecialCon)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsSpecialCon)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsSpecialCon)
    $cgmapT :: (forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon
    gmapT :: (forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsSpecialCon -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsSpecialCon -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
    Data)
    #else
      deriving (Eq,Ord,Show)
    #endif

    -- | This type is used to represent qualified variables, and also
    -- qualified constructors.
    data HsQName
            = Qual Module HsName    -- ^ Name qualified with a module name.
            | UnQual HsName         -- ^ Unqualified name.
            | Special HsSpecialCon  -- ^ Built-in constructor with special syntax.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsQName -> HsQName -> Bool
    (HsQName -> HsQName -> Bool)
    -> (HsQName -> HsQName -> Bool) -> Eq HsQName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsQName -> HsQName -> Bool
    == :: HsQName -> HsQName -> Bool
    $c/= :: HsQName -> HsQName -> Bool
    /= :: HsQName -> HsQName -> Bool
    Eq,Eq HsQName
    Eq HsQName =>
    (HsQName -> HsQName -> Ordering)
    -> (HsQName -> HsQName -> Bool)
    -> (HsQName -> HsQName -> Bool)
    -> (HsQName -> HsQName -> Bool)
    -> (HsQName -> HsQName -> Bool)
    -> (HsQName -> HsQName -> HsQName)
    -> (HsQName -> HsQName -> HsQName)
    -> Ord HsQName
    HsQName -> HsQName -> Bool
    HsQName -> HsQName -> Ordering
    HsQName -> HsQName -> HsQName
    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 :: HsQName -> HsQName -> Ordering
    compare :: HsQName -> HsQName -> Ordering
    $c< :: HsQName -> HsQName -> Bool
    < :: HsQName -> HsQName -> Bool
    $c<= :: HsQName -> HsQName -> Bool
    <= :: HsQName -> HsQName -> Bool
    $c> :: HsQName -> HsQName -> Bool
    > :: HsQName -> HsQName -> Bool
    $c>= :: HsQName -> HsQName -> Bool
    >= :: HsQName -> HsQName -> Bool
    $cmax :: HsQName -> HsQName -> HsQName
    max :: HsQName -> HsQName -> HsQName
    $cmin :: HsQName -> HsQName -> HsQName
    min :: HsQName -> HsQName -> HsQName
    Ord,Int -> HsQName -> ShowS
    [HsQName] -> ShowS
    HsQName -> String
    (Int -> HsQName -> ShowS)
    -> (HsQName -> String) -> ([HsQName] -> ShowS) -> Show HsQName
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsQName -> ShowS
    showsPrec :: Int -> HsQName -> ShowS
    $cshow :: HsQName -> String
    show :: HsQName -> String
    $cshowList :: [HsQName] -> ShowS
    showList :: [HsQName] -> ShowS
    Show,Typeable HsQName
    Typeable HsQName =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsQName -> c HsQName)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsQName)
    -> (HsQName -> Constr)
    -> (HsQName -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsQName))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQName))
    -> ((forall b. Data b => b -> b) -> HsQName -> HsQName)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsQName -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsQName -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsQName -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsQName -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsQName -> m HsQName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsQName -> m HsQName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsQName -> m HsQName)
    -> Data HsQName
    HsQName -> Constr
    HsQName -> DataType
    (forall b. Data b => b -> b) -> HsQName -> HsQName
    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) -> HsQName -> u
    forall u. (forall d. Data d => d -> u) -> HsQName -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQName -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQName -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQName -> m HsQName
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQName -> m HsQName
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQName
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQName -> c HsQName
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQName)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQName)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQName -> c HsQName
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQName -> c HsQName
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQName
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQName
    $ctoConstr :: HsQName -> Constr
    toConstr :: HsQName -> Constr
    $cdataTypeOf :: HsQName -> DataType
    dataTypeOf :: HsQName -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQName)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQName)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQName)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQName)
    $cgmapT :: (forall b. Data b => b -> b) -> HsQName -> HsQName
    gmapT :: (forall b. Data b => b -> b) -> HsQName -> HsQName
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQName -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQName -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQName -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQName -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQName -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsQName -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQName -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQName -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQName -> m HsQName
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQName -> m HsQName
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQName -> m HsQName
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQName -> m HsQName
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQName -> m HsQName
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQName -> m HsQName
    Data)
    #else
      deriving (Eq,Ord,Show)
    #endif

    -- | This type is used to represent variables, and also constructors.
    data HsName
            = HsIdent String        -- ^ /varid/ or /conid/.
            | HsSymbol String       -- ^ /varsym/ or /consym/.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsName -> HsName -> Bool
    (HsName -> HsName -> Bool)
    -> (HsName -> HsName -> Bool) -> Eq HsName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsName -> HsName -> Bool
    == :: HsName -> HsName -> Bool
    $c/= :: HsName -> HsName -> Bool
    /= :: HsName -> HsName -> Bool
    Eq,Eq HsName
    Eq HsName =>
    (HsName -> HsName -> Ordering)
    -> (HsName -> HsName -> Bool)
    -> (HsName -> HsName -> Bool)
    -> (HsName -> HsName -> Bool)
    -> (HsName -> HsName -> Bool)
    -> (HsName -> HsName -> HsName)
    -> (HsName -> HsName -> HsName)
    -> Ord HsName
    HsName -> HsName -> Bool
    HsName -> HsName -> Ordering
    HsName -> HsName -> HsName
    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 :: HsName -> HsName -> Ordering
    compare :: HsName -> HsName -> Ordering
    $c< :: HsName -> HsName -> Bool
    < :: HsName -> HsName -> Bool
    $c<= :: HsName -> HsName -> Bool
    <= :: HsName -> HsName -> Bool
    $c> :: HsName -> HsName -> Bool
    > :: HsName -> HsName -> Bool
    $c>= :: HsName -> HsName -> Bool
    >= :: HsName -> HsName -> Bool
    $cmax :: HsName -> HsName -> HsName
    max :: HsName -> HsName -> HsName
    $cmin :: HsName -> HsName -> HsName
    min :: HsName -> HsName -> HsName
    Ord,Int -> HsName -> ShowS
    [HsName] -> ShowS
    HsName -> String
    (Int -> HsName -> ShowS)
    -> (HsName -> String) -> ([HsName] -> ShowS) -> Show HsName
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsName -> ShowS
    showsPrec :: Int -> HsName -> ShowS
    $cshow :: HsName -> String
    show :: HsName -> String
    $cshowList :: [HsName] -> ShowS
    showList :: [HsName] -> ShowS
    Show,Typeable HsName
    Typeable HsName =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsName -> c HsName)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsName)
    -> (HsName -> Constr)
    -> (HsName -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsName))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsName))
    -> ((forall b. Data b => b -> b) -> HsName -> HsName)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsName -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsName -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsName -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsName -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsName -> m HsName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsName -> m HsName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsName -> m HsName)
    -> Data HsName
    HsName -> Constr
    HsName -> DataType
    (forall b. Data b => b -> b) -> HsName -> HsName
    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) -> HsName -> u
    forall u. (forall d. Data d => d -> u) -> HsName -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsName -> m HsName
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsName -> m HsName
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsName
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsName -> c HsName
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsName)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsName)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsName -> c HsName
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsName -> c HsName
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsName
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsName
    $ctoConstr :: HsName -> Constr
    toConstr :: HsName -> Constr
    $cdataTypeOf :: HsName -> DataType
    dataTypeOf :: HsName -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsName)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsName)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsName)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsName)
    $cgmapT :: (forall b. Data b => b -> b) -> HsName -> HsName
    gmapT :: (forall b. Data b => b -> b) -> HsName -> HsName
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsName -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsName -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsName -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsName -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsName -> m HsName
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsName -> m HsName
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsName -> m HsName
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsName -> m HsName
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsName -> m HsName
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsName -> m HsName
    Data)
    #else
      deriving (Eq,Ord,Show)
    #endif

    -- | Possibly qualified infix operators (/qop/), appearing in expressions.
    data HsQOp
            = HsQVarOp HsQName      -- ^ Variable operator (/qvarop/).
            | HsQConOp HsQName      -- ^ Constructor operator (/qconop/).
    #ifdef __GLASGOW_HASKELL__
      deriving (HsQOp -> HsQOp -> Bool
    (HsQOp -> HsQOp -> Bool) -> (HsQOp -> HsQOp -> Bool) -> Eq HsQOp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsQOp -> HsQOp -> Bool
    == :: HsQOp -> HsQOp -> Bool
    $c/= :: HsQOp -> HsQOp -> Bool
    /= :: HsQOp -> HsQOp -> Bool
    Eq,Eq HsQOp
    Eq HsQOp =>
    (HsQOp -> HsQOp -> Ordering)
    -> (HsQOp -> HsQOp -> Bool)
    -> (HsQOp -> HsQOp -> Bool)
    -> (HsQOp -> HsQOp -> Bool)
    -> (HsQOp -> HsQOp -> Bool)
    -> (HsQOp -> HsQOp -> HsQOp)
    -> (HsQOp -> HsQOp -> HsQOp)
    -> Ord HsQOp
    HsQOp -> HsQOp -> Bool
    HsQOp -> HsQOp -> Ordering
    HsQOp -> HsQOp -> HsQOp
    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 :: HsQOp -> HsQOp -> Ordering
    compare :: HsQOp -> HsQOp -> Ordering
    $c< :: HsQOp -> HsQOp -> Bool
    < :: HsQOp -> HsQOp -> Bool
    $c<= :: HsQOp -> HsQOp -> Bool
    <= :: HsQOp -> HsQOp -> Bool
    $c> :: HsQOp -> HsQOp -> Bool
    > :: HsQOp -> HsQOp -> Bool
    $c>= :: HsQOp -> HsQOp -> Bool
    >= :: HsQOp -> HsQOp -> Bool
    $cmax :: HsQOp -> HsQOp -> HsQOp
    max :: HsQOp -> HsQOp -> HsQOp
    $cmin :: HsQOp -> HsQOp -> HsQOp
    min :: HsQOp -> HsQOp -> HsQOp
    Ord,Int -> HsQOp -> ShowS
    [HsQOp] -> ShowS
    HsQOp -> String
    (Int -> HsQOp -> ShowS)
    -> (HsQOp -> String) -> ([HsQOp] -> ShowS) -> Show HsQOp
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsQOp -> ShowS
    showsPrec :: Int -> HsQOp -> ShowS
    $cshow :: HsQOp -> String
    show :: HsQOp -> String
    $cshowList :: [HsQOp] -> ShowS
    showList :: [HsQOp] -> ShowS
    Show,Typeable HsQOp
    Typeable HsQOp =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsQOp -> c HsQOp)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsQOp)
    -> (HsQOp -> Constr)
    -> (HsQOp -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsQOp))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQOp))
    -> ((forall b. Data b => b -> b) -> HsQOp -> HsQOp)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsQOp -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsQOp -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp)
    -> Data HsQOp
    HsQOp -> Constr
    HsQOp -> DataType
    (forall b. Data b => b -> b) -> HsQOp -> HsQOp
    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) -> HsQOp -> u
    forall u. (forall d. Data d => d -> u) -> HsQOp -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQOp
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQOp -> c HsQOp
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQOp)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQOp)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQOp -> c HsQOp
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQOp -> c HsQOp
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQOp
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQOp
    $ctoConstr :: HsQOp -> Constr
    toConstr :: HsQOp -> Constr
    $cdataTypeOf :: HsQOp -> DataType
    dataTypeOf :: HsQOp -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQOp)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQOp)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQOp)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQOp)
    $cgmapT :: (forall b. Data b => b -> b) -> HsQOp -> HsQOp
    gmapT :: (forall b. Data b => b -> b) -> HsQOp -> HsQOp
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQOp -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsQOp -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQOp -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQOp -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
    Data)
    #else
      deriving (Eq,Ord,Show)
    #endif

    -- | Operators, appearing in @infix@ declarations.
    data HsOp
            = HsVarOp HsName        -- ^ Variable operator (/varop/).
            | HsConOp HsName        -- ^ Constructor operator (/conop/).
    #ifdef __GLASGOW_HASKELL__
      deriving (HsOp -> HsOp -> Bool
    (HsOp -> HsOp -> Bool) -> (HsOp -> HsOp -> Bool) -> Eq HsOp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsOp -> HsOp -> Bool
    == :: HsOp -> HsOp -> Bool
    $c/= :: HsOp -> HsOp -> Bool
    /= :: HsOp -> HsOp -> Bool
    Eq,Eq HsOp
    Eq HsOp =>
    (HsOp -> HsOp -> Ordering)
    -> (HsOp -> HsOp -> Bool)
    -> (HsOp -> HsOp -> Bool)
    -> (HsOp -> HsOp -> Bool)
    -> (HsOp -> HsOp -> Bool)
    -> (HsOp -> HsOp -> HsOp)
    -> (HsOp -> HsOp -> HsOp)
    -> Ord HsOp
    HsOp -> HsOp -> Bool
    HsOp -> HsOp -> Ordering
    HsOp -> HsOp -> HsOp
    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 :: HsOp -> HsOp -> Ordering
    compare :: HsOp -> HsOp -> Ordering
    $c< :: HsOp -> HsOp -> Bool
    < :: HsOp -> HsOp -> Bool
    $c<= :: HsOp -> HsOp -> Bool
    <= :: HsOp -> HsOp -> Bool
    $c> :: HsOp -> HsOp -> Bool
    > :: HsOp -> HsOp -> Bool
    $c>= :: HsOp -> HsOp -> Bool
    >= :: HsOp -> HsOp -> Bool
    $cmax :: HsOp -> HsOp -> HsOp
    max :: HsOp -> HsOp -> HsOp
    $cmin :: HsOp -> HsOp -> HsOp
    min :: HsOp -> HsOp -> HsOp
    Ord,Int -> HsOp -> ShowS
    [HsOp] -> ShowS
    HsOp -> String
    (Int -> HsOp -> ShowS)
    -> (HsOp -> String) -> ([HsOp] -> ShowS) -> Show HsOp
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsOp -> ShowS
    showsPrec :: Int -> HsOp -> ShowS
    $cshow :: HsOp -> String
    show :: HsOp -> String
    $cshowList :: [HsOp] -> ShowS
    showList :: [HsOp] -> ShowS
    Show,Typeable HsOp
    Typeable HsOp =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsOp -> c HsOp)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsOp)
    -> (HsOp -> Constr)
    -> (HsOp -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsOp))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsOp))
    -> ((forall b. Data b => b -> b) -> HsOp -> HsOp)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsOp -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsOp -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsOp -> m HsOp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsOp -> m HsOp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsOp -> m HsOp)
    -> Data HsOp
    HsOp -> Constr
    HsOp -> DataType
    (forall b. Data b => b -> b) -> HsOp -> HsOp
    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) -> HsOp -> u
    forall u. (forall d. Data d => d -> u) -> HsOp -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsOp -> m HsOp
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsOp -> m HsOp
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsOp
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsOp -> c HsOp
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsOp)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsOp)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsOp -> c HsOp
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsOp -> c HsOp
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsOp
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsOp
    $ctoConstr :: HsOp -> Constr
    toConstr :: HsOp -> Constr
    $cdataTypeOf :: HsOp -> DataType
    dataTypeOf :: HsOp -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsOp)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsOp)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsOp)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsOp)
    $cgmapT :: (forall b. Data b => b -> b) -> HsOp -> HsOp
    gmapT :: (forall b. Data b => b -> b) -> HsOp -> HsOp
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsOp -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsOp -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsOp -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsOp -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsOp -> m HsOp
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsOp -> m HsOp
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsOp -> m HsOp
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsOp -> m HsOp
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsOp -> m HsOp
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsOp -> m HsOp
    Data)
    #else
      deriving (Eq,Ord,Show)
    #endif

    -- | A name (/cname/) of a component of a class or data type in an @import@
    -- or export specification.
    data HsCName
            = HsVarName HsName      -- ^ Name of a method or field.
            | HsConName HsName      -- ^ Name of a data constructor.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsCName -> HsCName -> Bool
    (HsCName -> HsCName -> Bool)
    -> (HsCName -> HsCName -> Bool) -> Eq HsCName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsCName -> HsCName -> Bool
    == :: HsCName -> HsCName -> Bool
    $c/= :: HsCName -> HsCName -> Bool
    /= :: HsCName -> HsCName -> Bool
    Eq,Eq HsCName
    Eq HsCName =>
    (HsCName -> HsCName -> Ordering)
    -> (HsCName -> HsCName -> Bool)
    -> (HsCName -> HsCName -> Bool)
    -> (HsCName -> HsCName -> Bool)
    -> (HsCName -> HsCName -> Bool)
    -> (HsCName -> HsCName -> HsCName)
    -> (HsCName -> HsCName -> HsCName)
    -> Ord HsCName
    HsCName -> HsCName -> Bool
    HsCName -> HsCName -> Ordering
    HsCName -> HsCName -> HsCName
    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 :: HsCName -> HsCName -> Ordering
    compare :: HsCName -> HsCName -> Ordering
    $c< :: HsCName -> HsCName -> Bool
    < :: HsCName -> HsCName -> Bool
    $c<= :: HsCName -> HsCName -> Bool
    <= :: HsCName -> HsCName -> Bool
    $c> :: HsCName -> HsCName -> Bool
    > :: HsCName -> HsCName -> Bool
    $c>= :: HsCName -> HsCName -> Bool
    >= :: HsCName -> HsCName -> Bool
    $cmax :: HsCName -> HsCName -> HsCName
    max :: HsCName -> HsCName -> HsCName
    $cmin :: HsCName -> HsCName -> HsCName
    min :: HsCName -> HsCName -> HsCName
    Ord,Int -> HsCName -> ShowS
    [HsCName] -> ShowS
    HsCName -> String
    (Int -> HsCName -> ShowS)
    -> (HsCName -> String) -> ([HsCName] -> ShowS) -> Show HsCName
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsCName -> ShowS
    showsPrec :: Int -> HsCName -> ShowS
    $cshow :: HsCName -> String
    show :: HsCName -> String
    $cshowList :: [HsCName] -> ShowS
    showList :: [HsCName] -> ShowS
    Show,Typeable HsCName
    Typeable HsCName =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsCName -> c HsCName)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsCName)
    -> (HsCName -> Constr)
    -> (HsCName -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsCName))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsCName))
    -> ((forall b. Data b => b -> b) -> HsCName -> HsCName)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsCName -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsCName -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsCName -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsCName -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsCName -> m HsCName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsCName -> m HsCName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsCName -> m HsCName)
    -> Data HsCName
    HsCName -> Constr
    HsCName -> DataType
    (forall b. Data b => b -> b) -> HsCName -> HsCName
    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) -> HsCName -> u
    forall u. (forall d. Data d => d -> u) -> HsCName -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsCName -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsCName -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsCName -> m HsCName
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsCName -> m HsCName
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsCName
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsCName -> c HsCName
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsCName)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsCName)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsCName -> c HsCName
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsCName -> c HsCName
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsCName
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsCName
    $ctoConstr :: HsCName -> Constr
    toConstr :: HsCName -> Constr
    $cdataTypeOf :: HsCName -> DataType
    dataTypeOf :: HsCName -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsCName)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsCName)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsCName)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsCName)
    $cgmapT :: (forall b. Data b => b -> b) -> HsCName -> HsCName
    gmapT :: (forall b. Data b => b -> b) -> HsCName -> HsCName
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsCName -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsCName -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsCName -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsCName -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsCName -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsCName -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsCName -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsCName -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsCName -> m HsCName
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsCName -> m HsCName
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsCName -> m HsCName
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsCName -> m HsCName
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsCName -> m HsCName
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsCName -> m HsCName
    Data)
    #else
      deriving (Eq,Ord,Show)
    #endif

    -- | A Haskell source module.
    data HsModule = HsModule SrcLoc Module (Maybe [HsExportSpec])
                             [HsImportDecl] [HsDecl]
    #ifdef __GLASGOW_HASKELL__
      deriving (HsModule -> HsModule -> Bool
    (HsModule -> HsModule -> Bool)
    -> (HsModule -> HsModule -> Bool) -> Eq HsModule
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsModule -> HsModule -> Bool
    == :: HsModule -> HsModule -> Bool
    $c/= :: HsModule -> HsModule -> Bool
    /= :: HsModule -> HsModule -> Bool
    Eq,Int -> HsModule -> ShowS
    [HsModule] -> ShowS
    HsModule -> String
    (Int -> HsModule -> ShowS)
    -> (HsModule -> String) -> ([HsModule] -> ShowS) -> Show HsModule
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsModule -> ShowS
    showsPrec :: Int -> HsModule -> ShowS
    $cshow :: HsModule -> String
    show :: HsModule -> String
    $cshowList :: [HsModule] -> ShowS
    showList :: [HsModule] -> ShowS
    Show,Typeable HsModule
    Typeable HsModule =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsModule -> c HsModule)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsModule)
    -> (HsModule -> Constr)
    -> (HsModule -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsModule))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsModule))
    -> ((forall b. Data b => b -> b) -> HsModule -> HsModule)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsModule -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsModule -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsModule -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsModule -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsModule -> m HsModule)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsModule -> m HsModule)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsModule -> m HsModule)
    -> Data HsModule
    HsModule -> Constr
    HsModule -> DataType
    (forall b. Data b => b -> b) -> HsModule -> HsModule
    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) -> HsModule -> u
    forall u. (forall d. Data d => d -> u) -> HsModule -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsModule -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsModule -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsModule -> m HsModule
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsModule -> m HsModule
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsModule
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsModule -> c HsModule
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsModule)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsModule)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsModule -> c HsModule
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsModule -> c HsModule
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsModule
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsModule
    $ctoConstr :: HsModule -> Constr
    toConstr :: HsModule -> Constr
    $cdataTypeOf :: HsModule -> DataType
    dataTypeOf :: HsModule -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsModule)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsModule)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsModule)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsModule)
    $cgmapT :: (forall b. Data b => b -> b) -> HsModule -> HsModule
    gmapT :: (forall b. Data b => b -> b) -> HsModule -> HsModule
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsModule -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsModule -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsModule -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsModule -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsModule -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsModule -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsModule -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsModule -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsModule -> m HsModule
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsModule -> m HsModule
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsModule -> m HsModule
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsModule -> m HsModule
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsModule -> m HsModule
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsModule -> m HsModule
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Export specification.
    data HsExportSpec
             = HsEVar HsQName                       -- ^ Variable.
             | HsEAbs HsQName                       -- ^ @T@:
                            -- A class or datatype exported abstractly,
                            -- or a type synonym.
             | HsEThingAll HsQName                  -- ^ @T(..)@:
                            -- A class exported with all of its methods, or
                            -- a datatype exported with all of its constructors.
             | HsEThingWith HsQName [HsCName]       -- ^ @T(C_1,...,C_n)@:
                            -- A class exported with some of its methods, or
                            -- a datatype exported with some of its constructors.
             | HsEModuleContents Module             -- ^ @module M@:
                            -- Re-export a module.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsExportSpec -> HsExportSpec -> Bool
    (HsExportSpec -> HsExportSpec -> Bool)
    -> (HsExportSpec -> HsExportSpec -> Bool) -> Eq HsExportSpec
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsExportSpec -> HsExportSpec -> Bool
    == :: HsExportSpec -> HsExportSpec -> Bool
    $c/= :: HsExportSpec -> HsExportSpec -> Bool
    /= :: HsExportSpec -> HsExportSpec -> Bool
    Eq,Int -> HsExportSpec -> ShowS
    [HsExportSpec] -> ShowS
    HsExportSpec -> String
    (Int -> HsExportSpec -> ShowS)
    -> (HsExportSpec -> String)
    -> ([HsExportSpec] -> ShowS)
    -> Show HsExportSpec
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsExportSpec -> ShowS
    showsPrec :: Int -> HsExportSpec -> ShowS
    $cshow :: HsExportSpec -> String
    show :: HsExportSpec -> String
    $cshowList :: [HsExportSpec] -> ShowS
    showList :: [HsExportSpec] -> ShowS
    Show,Typeable HsExportSpec
    Typeable HsExportSpec =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsExportSpec)
    -> (HsExportSpec -> Constr)
    -> (HsExportSpec -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsExportSpec))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsExportSpec))
    -> ((forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsExportSpec -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec)
    -> Data HsExportSpec
    HsExportSpec -> Constr
    HsExportSpec -> DataType
    (forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec
    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) -> HsExportSpec -> u
    forall u. (forall d. Data d => d -> u) -> HsExportSpec -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsExportSpec
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsExportSpec)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsExportSpec)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsExportSpec
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsExportSpec
    $ctoConstr :: HsExportSpec -> Constr
    toConstr :: HsExportSpec -> Constr
    $cdataTypeOf :: HsExportSpec -> DataType
    dataTypeOf :: HsExportSpec -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsExportSpec)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsExportSpec)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsExportSpec)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsExportSpec)
    $cgmapT :: (forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec
    gmapT :: (forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsExportSpec -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsExportSpec -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Import declaration.
    data HsImportDecl = HsImportDecl
            { HsImportDecl -> SrcLoc
    importLoc       :: SrcLoc        -- ^ Position of the @import@ keyword.
            , HsImportDecl -> Module
    importModule    :: Module        -- ^ Name of the module imported.
            , HsImportDecl -> Bool
    importQualified :: Bool          -- ^ Imported @qualified@?
            , HsImportDecl -> Maybe Module
    importAs        :: Maybe Module
                            -- ^ Optional alias name in an @as@ clause.
            , HsImportDecl -> Maybe (Bool, [HsImportSpec])
    importSpecs     :: Maybe (Bool,[HsImportSpec])
                            -- ^ Optional list of import specifications.
                            -- The 'Bool' is 'True' if the names are excluded
                            -- by @hiding@.
            }
    #ifdef __GLASGOW_HASKELL__
      deriving (HsImportDecl -> HsImportDecl -> Bool
    (HsImportDecl -> HsImportDecl -> Bool)
    -> (HsImportDecl -> HsImportDecl -> Bool) -> Eq HsImportDecl
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsImportDecl -> HsImportDecl -> Bool
    == :: HsImportDecl -> HsImportDecl -> Bool
    $c/= :: HsImportDecl -> HsImportDecl -> Bool
    /= :: HsImportDecl -> HsImportDecl -> Bool
    Eq,Int -> HsImportDecl -> ShowS
    [HsImportDecl] -> ShowS
    HsImportDecl -> String
    (Int -> HsImportDecl -> ShowS)
    -> (HsImportDecl -> String)
    -> ([HsImportDecl] -> ShowS)
    -> Show HsImportDecl
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsImportDecl -> ShowS
    showsPrec :: Int -> HsImportDecl -> ShowS
    $cshow :: HsImportDecl -> String
    show :: HsImportDecl -> String
    $cshowList :: [HsImportDecl] -> ShowS
    showList :: [HsImportDecl] -> ShowS
    Show,Typeable HsImportDecl
    Typeable HsImportDecl =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsImportDecl)
    -> (HsImportDecl -> Constr)
    -> (HsImportDecl -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsImportDecl))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsImportDecl))
    -> ((forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsImportDecl -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl)
    -> Data HsImportDecl
    HsImportDecl -> Constr
    HsImportDecl -> DataType
    (forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl
    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) -> HsImportDecl -> u
    forall u. (forall d. Data d => d -> u) -> HsImportDecl -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsImportDecl
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsImportDecl)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsImportDecl)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsImportDecl
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsImportDecl
    $ctoConstr :: HsImportDecl -> Constr
    toConstr :: HsImportDecl -> Constr
    $cdataTypeOf :: HsImportDecl -> DataType
    dataTypeOf :: HsImportDecl -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsImportDecl)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsImportDecl)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsImportDecl)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsImportDecl)
    $cgmapT :: (forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl
    gmapT :: (forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportDecl -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportDecl -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Import specification.
    data HsImportSpec
             = HsIVar HsName                        -- ^ Variable.
             | HsIAbs HsName                        -- ^ @T@:
                            -- The name of a class, datatype or type synonym.
             | HsIThingAll HsName                   -- ^ @T(..)@:
                            -- A class imported with all of its methods, or
                            -- a datatype imported with all of its constructors.
             | HsIThingWith HsName [HsCName]        -- ^ @T(C_1,...,C_n)@:
                            -- A class imported with some of its methods, or
                            -- a datatype imported with some of its constructors.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsImportSpec -> HsImportSpec -> Bool
    (HsImportSpec -> HsImportSpec -> Bool)
    -> (HsImportSpec -> HsImportSpec -> Bool) -> Eq HsImportSpec
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsImportSpec -> HsImportSpec -> Bool
    == :: HsImportSpec -> HsImportSpec -> Bool
    $c/= :: HsImportSpec -> HsImportSpec -> Bool
    /= :: HsImportSpec -> HsImportSpec -> Bool
    Eq,Int -> HsImportSpec -> ShowS
    [HsImportSpec] -> ShowS
    HsImportSpec -> String
    (Int -> HsImportSpec -> ShowS)
    -> (HsImportSpec -> String)
    -> ([HsImportSpec] -> ShowS)
    -> Show HsImportSpec
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsImportSpec -> ShowS
    showsPrec :: Int -> HsImportSpec -> ShowS
    $cshow :: HsImportSpec -> String
    show :: HsImportSpec -> String
    $cshowList :: [HsImportSpec] -> ShowS
    showList :: [HsImportSpec] -> ShowS
    Show,Typeable HsImportSpec
    Typeable HsImportSpec =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsImportSpec)
    -> (HsImportSpec -> Constr)
    -> (HsImportSpec -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsImportSpec))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsImportSpec))
    -> ((forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsImportSpec -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec)
    -> Data HsImportSpec
    HsImportSpec -> Constr
    HsImportSpec -> DataType
    (forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec
    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) -> HsImportSpec -> u
    forall u. (forall d. Data d => d -> u) -> HsImportSpec -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsImportSpec
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsImportSpec)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsImportSpec)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsImportSpec
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsImportSpec
    $ctoConstr :: HsImportSpec -> Constr
    toConstr :: HsImportSpec -> Constr
    $cdataTypeOf :: HsImportSpec -> DataType
    dataTypeOf :: HsImportSpec -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsImportSpec)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsImportSpec)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsImportSpec)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsImportSpec)
    $cgmapT :: (forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec
    gmapT :: (forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportSpec -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportSpec -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Associativity of an operator.
    data HsAssoc
             = HsAssocNone  -- ^ Non-associative operator (declared with @infix@).
             | HsAssocLeft  -- ^ Left-associative operator (declared with @infixl@).
             | HsAssocRight -- ^ Right-associative operator (declared with @infixr@).
    #ifdef __GLASGOW_HASKELL__
      deriving (HsAssoc -> HsAssoc -> Bool
    (HsAssoc -> HsAssoc -> Bool)
    -> (HsAssoc -> HsAssoc -> Bool) -> Eq HsAssoc
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsAssoc -> HsAssoc -> Bool
    == :: HsAssoc -> HsAssoc -> Bool
    $c/= :: HsAssoc -> HsAssoc -> Bool
    /= :: HsAssoc -> HsAssoc -> Bool
    Eq,Int -> HsAssoc -> ShowS
    [HsAssoc] -> ShowS
    HsAssoc -> String
    (Int -> HsAssoc -> ShowS)
    -> (HsAssoc -> String) -> ([HsAssoc] -> ShowS) -> Show HsAssoc
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsAssoc -> ShowS
    showsPrec :: Int -> HsAssoc -> ShowS
    $cshow :: HsAssoc -> String
    show :: HsAssoc -> String
    $cshowList :: [HsAssoc] -> ShowS
    showList :: [HsAssoc] -> ShowS
    Show,Typeable HsAssoc
    Typeable HsAssoc =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsAssoc -> c HsAssoc)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsAssoc)
    -> (HsAssoc -> Constr)
    -> (HsAssoc -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsAssoc))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAssoc))
    -> ((forall b. Data b => b -> b) -> HsAssoc -> HsAssoc)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsAssoc -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsAssoc -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc)
    -> Data HsAssoc
    HsAssoc -> Constr
    HsAssoc -> DataType
    (forall b. Data b => b -> b) -> HsAssoc -> HsAssoc
    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) -> HsAssoc -> u
    forall u. (forall d. Data d => d -> u) -> HsAssoc -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsAssoc
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsAssoc -> c HsAssoc
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsAssoc)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAssoc)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsAssoc -> c HsAssoc
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsAssoc -> c HsAssoc
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsAssoc
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsAssoc
    $ctoConstr :: HsAssoc -> Constr
    toConstr :: HsAssoc -> Constr
    $cdataTypeOf :: HsAssoc -> DataType
    dataTypeOf :: HsAssoc -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsAssoc)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsAssoc)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAssoc)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAssoc)
    $cgmapT :: (forall b. Data b => b -> b) -> HsAssoc -> HsAssoc
    gmapT :: (forall b. Data b => b -> b) -> HsAssoc -> HsAssoc
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsAssoc -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsAssoc -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsAssoc -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsAssoc -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
    Data)
    #else
      deriving (Eq,Show)
    #endif

    data HsDecl
             = HsTypeDecl    SrcLoc HsName [HsName] HsType
             | HsDataDecl    SrcLoc HsContext HsName [HsName] [HsConDecl] [HsQName]
             | HsInfixDecl   SrcLoc HsAssoc Int [HsOp]
             | HsNewTypeDecl SrcLoc HsContext HsName [HsName] HsConDecl [HsQName]
             | HsClassDecl   SrcLoc HsContext HsName [HsName] [HsDecl]
             | HsInstDecl    SrcLoc HsContext HsQName [HsType] [HsDecl]
             | HsDefaultDecl SrcLoc [HsType]
             | HsTypeSig     SrcLoc [HsName] HsQualType
             | HsFunBind     [HsMatch]
             | HsPatBind     SrcLoc HsPat HsRhs {-where-} [HsDecl]
             | HsForeignImport SrcLoc String HsSafety String HsName HsType
             | HsForeignExport SrcLoc String String HsName HsType
    #ifdef __GLASGOW_HASKELL__
      deriving (HsDecl -> HsDecl -> Bool
    (HsDecl -> HsDecl -> Bool)
    -> (HsDecl -> HsDecl -> Bool) -> Eq HsDecl
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsDecl -> HsDecl -> Bool
    == :: HsDecl -> HsDecl -> Bool
    $c/= :: HsDecl -> HsDecl -> Bool
    /= :: HsDecl -> HsDecl -> Bool
    Eq,Int -> HsDecl -> ShowS
    [HsDecl] -> ShowS
    HsDecl -> String
    (Int -> HsDecl -> ShowS)
    -> (HsDecl -> String) -> ([HsDecl] -> ShowS) -> Show HsDecl
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsDecl -> ShowS
    showsPrec :: Int -> HsDecl -> ShowS
    $cshow :: HsDecl -> String
    show :: HsDecl -> String
    $cshowList :: [HsDecl] -> ShowS
    showList :: [HsDecl] -> ShowS
    Show,Typeable HsDecl
    Typeable HsDecl =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsDecl -> c HsDecl)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsDecl)
    -> (HsDecl -> Constr)
    -> (HsDecl -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsDecl))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDecl))
    -> ((forall b. Data b => b -> b) -> HsDecl -> HsDecl)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsDecl -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsDecl -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsDecl -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsDecl -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl)
    -> Data HsDecl
    HsDecl -> Constr
    HsDecl -> DataType
    (forall b. Data b => b -> b) -> HsDecl -> HsDecl
    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) -> HsDecl -> u
    forall u. (forall d. Data d => d -> u) -> HsDecl -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsDecl
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsDecl -> c HsDecl
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsDecl)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDecl)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsDecl -> c HsDecl
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsDecl -> c HsDecl
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsDecl
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsDecl
    $ctoConstr :: HsDecl -> Constr
    toConstr :: HsDecl -> Constr
    $cdataTypeOf :: HsDecl -> DataType
    dataTypeOf :: HsDecl -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsDecl)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsDecl)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDecl)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDecl)
    $cgmapT :: (forall b. Data b => b -> b) -> HsDecl -> HsDecl
    gmapT :: (forall b. Data b => b -> b) -> HsDecl -> HsDecl
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsDecl -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsDecl -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsDecl -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsDecl -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Clauses of a function binding.
    data HsMatch
             = HsMatch SrcLoc HsName [HsPat] HsRhs {-where-} [HsDecl]
    #ifdef __GLASGOW_HASKELL__
      deriving (HsMatch -> HsMatch -> Bool
    (HsMatch -> HsMatch -> Bool)
    -> (HsMatch -> HsMatch -> Bool) -> Eq HsMatch
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsMatch -> HsMatch -> Bool
    == :: HsMatch -> HsMatch -> Bool
    $c/= :: HsMatch -> HsMatch -> Bool
    /= :: HsMatch -> HsMatch -> Bool
    Eq,Int -> HsMatch -> ShowS
    [HsMatch] -> ShowS
    HsMatch -> String
    (Int -> HsMatch -> ShowS)
    -> (HsMatch -> String) -> ([HsMatch] -> ShowS) -> Show HsMatch
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsMatch -> ShowS
    showsPrec :: Int -> HsMatch -> ShowS
    $cshow :: HsMatch -> String
    show :: HsMatch -> String
    $cshowList :: [HsMatch] -> ShowS
    showList :: [HsMatch] -> ShowS
    Show,Typeable HsMatch
    Typeable HsMatch =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsMatch -> c HsMatch)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsMatch)
    -> (HsMatch -> Constr)
    -> (HsMatch -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsMatch))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsMatch))
    -> ((forall b. Data b => b -> b) -> HsMatch -> HsMatch)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsMatch -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsMatch -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsMatch -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsMatch -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch)
    -> Data HsMatch
    HsMatch -> Constr
    HsMatch -> DataType
    (forall b. Data b => b -> b) -> HsMatch -> HsMatch
    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) -> HsMatch -> u
    forall u. (forall d. Data d => d -> u) -> HsMatch -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsMatch -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsMatch -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsMatch
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsMatch -> c HsMatch
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsMatch)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsMatch)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsMatch -> c HsMatch
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsMatch -> c HsMatch
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsMatch
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsMatch
    $ctoConstr :: HsMatch -> Constr
    toConstr :: HsMatch -> Constr
    $cdataTypeOf :: HsMatch -> DataType
    dataTypeOf :: HsMatch -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsMatch)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsMatch)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsMatch)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsMatch)
    $cgmapT :: (forall b. Data b => b -> b) -> HsMatch -> HsMatch
    gmapT :: (forall b. Data b => b -> b) -> HsMatch -> HsMatch
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsMatch -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsMatch -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsMatch -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsMatch -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsMatch -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsMatch -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsMatch -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsMatch -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Declaration of a data constructor.
    data HsConDecl
             = HsConDecl SrcLoc HsName [HsBangType]
                                    -- ^ Ordinary data constructor.
             | HsRecDecl SrcLoc HsName [([HsName],HsBangType)]
                                    -- ^ Record constructor.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsConDecl -> HsConDecl -> Bool
    (HsConDecl -> HsConDecl -> Bool)
    -> (HsConDecl -> HsConDecl -> Bool) -> Eq HsConDecl
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsConDecl -> HsConDecl -> Bool
    == :: HsConDecl -> HsConDecl -> Bool
    $c/= :: HsConDecl -> HsConDecl -> Bool
    /= :: HsConDecl -> HsConDecl -> Bool
    Eq,Int -> HsConDecl -> ShowS
    [HsConDecl] -> ShowS
    HsConDecl -> String
    (Int -> HsConDecl -> ShowS)
    -> (HsConDecl -> String)
    -> ([HsConDecl] -> ShowS)
    -> Show HsConDecl
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsConDecl -> ShowS
    showsPrec :: Int -> HsConDecl -> ShowS
    $cshow :: HsConDecl -> String
    show :: HsConDecl -> String
    $cshowList :: [HsConDecl] -> ShowS
    showList :: [HsConDecl] -> ShowS
    Show,Typeable HsConDecl
    Typeable HsConDecl =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsConDecl -> c HsConDecl)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsConDecl)
    -> (HsConDecl -> Constr)
    -> (HsConDecl -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsConDecl))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsConDecl))
    -> ((forall b. Data b => b -> b) -> HsConDecl -> HsConDecl)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsConDecl -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsConDecl -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl)
    -> Data HsConDecl
    HsConDecl -> Constr
    HsConDecl -> DataType
    (forall b. Data b => b -> b) -> HsConDecl -> HsConDecl
    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) -> HsConDecl -> u
    forall u. (forall d. Data d => d -> u) -> HsConDecl -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsConDecl
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsConDecl -> c HsConDecl
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsConDecl)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsConDecl)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsConDecl -> c HsConDecl
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsConDecl -> c HsConDecl
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsConDecl
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsConDecl
    $ctoConstr :: HsConDecl -> Constr
    toConstr :: HsConDecl -> Constr
    $cdataTypeOf :: HsConDecl -> DataType
    dataTypeOf :: HsConDecl -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsConDecl)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsConDecl)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsConDecl)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsConDecl)
    $cgmapT :: (forall b. Data b => b -> b) -> HsConDecl -> HsConDecl
    gmapT :: (forall b. Data b => b -> b) -> HsConDecl -> HsConDecl
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsConDecl -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsConDecl -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsConDecl -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsConDecl -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | The type of a constructor argument or field, optionally including
    -- a strictness annotation.
    data HsBangType
             = HsBangedTy   HsType  -- ^ Strict component, marked with \"@!@\".
             | HsUnBangedTy HsType  -- ^ Non-strict component.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsBangType -> HsBangType -> Bool
    (HsBangType -> HsBangType -> Bool)
    -> (HsBangType -> HsBangType -> Bool) -> Eq HsBangType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsBangType -> HsBangType -> Bool
    == :: HsBangType -> HsBangType -> Bool
    $c/= :: HsBangType -> HsBangType -> Bool
    /= :: HsBangType -> HsBangType -> Bool
    Eq,Int -> HsBangType -> ShowS
    [HsBangType] -> ShowS
    HsBangType -> String
    (Int -> HsBangType -> ShowS)
    -> (HsBangType -> String)
    -> ([HsBangType] -> ShowS)
    -> Show HsBangType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsBangType -> ShowS
    showsPrec :: Int -> HsBangType -> ShowS
    $cshow :: HsBangType -> String
    show :: HsBangType -> String
    $cshowList :: [HsBangType] -> ShowS
    showList :: [HsBangType] -> ShowS
    Show,Typeable HsBangType
    Typeable HsBangType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsBangType -> c HsBangType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsBangType)
    -> (HsBangType -> Constr)
    -> (HsBangType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsBangType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsBangType))
    -> ((forall b. Data b => b -> b) -> HsBangType -> HsBangType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsBangType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsBangType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsBangType -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsBangType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType)
    -> Data HsBangType
    HsBangType -> Constr
    HsBangType -> DataType
    (forall b. Data b => b -> b) -> HsBangType -> HsBangType
    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) -> HsBangType -> u
    forall u. (forall d. Data d => d -> u) -> HsBangType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsBangType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsBangType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsBangType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsBangType -> c HsBangType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsBangType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsBangType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsBangType -> c HsBangType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsBangType -> c HsBangType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsBangType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsBangType
    $ctoConstr :: HsBangType -> Constr
    toConstr :: HsBangType -> Constr
    $cdataTypeOf :: HsBangType -> DataType
    dataTypeOf :: HsBangType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsBangType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsBangType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsBangType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsBangType)
    $cgmapT :: (forall b. Data b => b -> b) -> HsBangType -> HsBangType
    gmapT :: (forall b. Data b => b -> b) -> HsBangType -> HsBangType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsBangType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsBangType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsBangType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsBangType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsBangType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsBangType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsBangType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsBangType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | The right hand side of a function or pattern binding.
    data HsRhs
             = HsUnGuardedRhs HsExp -- ^ Unguarded right hand side (/exp/).
             | HsGuardedRhss  [HsGuardedRhs]
                                    -- ^ Guarded right hand side (/gdrhs/).
    #ifdef __GLASGOW_HASKELL__
      deriving (HsRhs -> HsRhs -> Bool
    (HsRhs -> HsRhs -> Bool) -> (HsRhs -> HsRhs -> Bool) -> Eq HsRhs
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsRhs -> HsRhs -> Bool
    == :: HsRhs -> HsRhs -> Bool
    $c/= :: HsRhs -> HsRhs -> Bool
    /= :: HsRhs -> HsRhs -> Bool
    Eq,Int -> HsRhs -> ShowS
    [HsRhs] -> ShowS
    HsRhs -> String
    (Int -> HsRhs -> ShowS)
    -> (HsRhs -> String) -> ([HsRhs] -> ShowS) -> Show HsRhs
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsRhs -> ShowS
    showsPrec :: Int -> HsRhs -> ShowS
    $cshow :: HsRhs -> String
    show :: HsRhs -> String
    $cshowList :: [HsRhs] -> ShowS
    showList :: [HsRhs] -> ShowS
    Show,Typeable HsRhs
    Typeable HsRhs =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsRhs -> c HsRhs)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsRhs)
    -> (HsRhs -> Constr)
    -> (HsRhs -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsRhs))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRhs))
    -> ((forall b. Data b => b -> b) -> HsRhs -> HsRhs)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsRhs -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsRhs -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs)
    -> Data HsRhs
    HsRhs -> Constr
    HsRhs -> DataType
    (forall b. Data b => b -> b) -> HsRhs -> HsRhs
    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) -> HsRhs -> u
    forall u. (forall d. Data d => d -> u) -> HsRhs -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRhs
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRhs -> c HsRhs
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRhs)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRhs)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRhs -> c HsRhs
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRhs -> c HsRhs
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRhs
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRhs
    $ctoConstr :: HsRhs -> Constr
    toConstr :: HsRhs -> Constr
    $cdataTypeOf :: HsRhs -> DataType
    dataTypeOf :: HsRhs -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRhs)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRhs)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRhs)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRhs)
    $cgmapT :: (forall b. Data b => b -> b) -> HsRhs -> HsRhs
    gmapT :: (forall b. Data b => b -> b) -> HsRhs -> HsRhs
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsRhs -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsRhs -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsRhs -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsRhs -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | A guarded right hand side @|@ /exp/ @=@ /exp/.
    -- The first expression will be Boolean-valued.
    data HsGuardedRhs
             = HsGuardedRhs SrcLoc HsExp HsExp
    #ifdef __GLASGOW_HASKELL__
      deriving (HsGuardedRhs -> HsGuardedRhs -> Bool
    (HsGuardedRhs -> HsGuardedRhs -> Bool)
    -> (HsGuardedRhs -> HsGuardedRhs -> Bool) -> Eq HsGuardedRhs
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsGuardedRhs -> HsGuardedRhs -> Bool
    == :: HsGuardedRhs -> HsGuardedRhs -> Bool
    $c/= :: HsGuardedRhs -> HsGuardedRhs -> Bool
    /= :: HsGuardedRhs -> HsGuardedRhs -> Bool
    Eq,Int -> HsGuardedRhs -> ShowS
    [HsGuardedRhs] -> ShowS
    HsGuardedRhs -> String
    (Int -> HsGuardedRhs -> ShowS)
    -> (HsGuardedRhs -> String)
    -> ([HsGuardedRhs] -> ShowS)
    -> Show HsGuardedRhs
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsGuardedRhs -> ShowS
    showsPrec :: Int -> HsGuardedRhs -> ShowS
    $cshow :: HsGuardedRhs -> String
    show :: HsGuardedRhs -> String
    $cshowList :: [HsGuardedRhs] -> ShowS
    showList :: [HsGuardedRhs] -> ShowS
    Show,Typeable HsGuardedRhs
    Typeable HsGuardedRhs =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsGuardedRhs)
    -> (HsGuardedRhs -> Constr)
    -> (HsGuardedRhs -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsGuardedRhs))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsGuardedRhs))
    -> ((forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsGuardedRhs -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs)
    -> Data HsGuardedRhs
    HsGuardedRhs -> Constr
    HsGuardedRhs -> DataType
    (forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs
    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) -> HsGuardedRhs -> u
    forall u. (forall d. Data d => d -> u) -> HsGuardedRhs -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedRhs
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedRhs)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedRhs)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedRhs
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedRhs
    $ctoConstr :: HsGuardedRhs -> Constr
    toConstr :: HsGuardedRhs -> Constr
    $cdataTypeOf :: HsGuardedRhs -> DataType
    dataTypeOf :: HsGuardedRhs -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedRhs)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedRhs)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedRhs)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedRhs)
    $cgmapT :: (forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs
    gmapT :: (forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedRhs -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedRhs -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Safety level for invoking a foreign entity.
    data HsSafety
            = HsSafe        -- ^ Call may generate callbacks.
            | HsUnsafe      -- ^ Call will not generate callbacks.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsSafety -> HsSafety -> Bool
    (HsSafety -> HsSafety -> Bool)
    -> (HsSafety -> HsSafety -> Bool) -> Eq HsSafety
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsSafety -> HsSafety -> Bool
    == :: HsSafety -> HsSafety -> Bool
    $c/= :: HsSafety -> HsSafety -> Bool
    /= :: HsSafety -> HsSafety -> Bool
    Eq,Eq HsSafety
    Eq HsSafety =>
    (HsSafety -> HsSafety -> Ordering)
    -> (HsSafety -> HsSafety -> Bool)
    -> (HsSafety -> HsSafety -> Bool)
    -> (HsSafety -> HsSafety -> Bool)
    -> (HsSafety -> HsSafety -> Bool)
    -> (HsSafety -> HsSafety -> HsSafety)
    -> (HsSafety -> HsSafety -> HsSafety)
    -> Ord HsSafety
    HsSafety -> HsSafety -> Bool
    HsSafety -> HsSafety -> Ordering
    HsSafety -> HsSafety -> HsSafety
    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 :: HsSafety -> HsSafety -> Ordering
    compare :: HsSafety -> HsSafety -> Ordering
    $c< :: HsSafety -> HsSafety -> Bool
    < :: HsSafety -> HsSafety -> Bool
    $c<= :: HsSafety -> HsSafety -> Bool
    <= :: HsSafety -> HsSafety -> Bool
    $c> :: HsSafety -> HsSafety -> Bool
    > :: HsSafety -> HsSafety -> Bool
    $c>= :: HsSafety -> HsSafety -> Bool
    >= :: HsSafety -> HsSafety -> Bool
    $cmax :: HsSafety -> HsSafety -> HsSafety
    max :: HsSafety -> HsSafety -> HsSafety
    $cmin :: HsSafety -> HsSafety -> HsSafety
    min :: HsSafety -> HsSafety -> HsSafety
    Ord,Int -> HsSafety -> ShowS
    [HsSafety] -> ShowS
    HsSafety -> String
    (Int -> HsSafety -> ShowS)
    -> (HsSafety -> String) -> ([HsSafety] -> ShowS) -> Show HsSafety
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsSafety -> ShowS
    showsPrec :: Int -> HsSafety -> ShowS
    $cshow :: HsSafety -> String
    show :: HsSafety -> String
    $cshowList :: [HsSafety] -> ShowS
    showList :: [HsSafety] -> ShowS
    Show,Typeable HsSafety
    Typeable HsSafety =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsSafety -> c HsSafety)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsSafety)
    -> (HsSafety -> Constr)
    -> (HsSafety -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsSafety))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSafety))
    -> ((forall b. Data b => b -> b) -> HsSafety -> HsSafety)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsSafety -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsSafety -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsSafety -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsSafety -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety)
    -> Data HsSafety
    HsSafety -> Constr
    HsSafety -> DataType
    (forall b. Data b => b -> b) -> HsSafety -> HsSafety
    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) -> HsSafety -> u
    forall u. (forall d. Data d => d -> u) -> HsSafety -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSafety -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSafety -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsSafety
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsSafety -> c HsSafety
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsSafety)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSafety)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsSafety -> c HsSafety
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsSafety -> c HsSafety
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsSafety
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsSafety
    $ctoConstr :: HsSafety -> Constr
    toConstr :: HsSafety -> Constr
    $cdataTypeOf :: HsSafety -> DataType
    dataTypeOf :: HsSafety -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsSafety)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsSafety)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSafety)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSafety)
    $cgmapT :: (forall b. Data b => b -> b) -> HsSafety -> HsSafety
    gmapT :: (forall b. Data b => b -> b) -> HsSafety -> HsSafety
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSafety -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSafety -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSafety -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsSafety -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsSafety -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsSafety -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsSafety -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsSafety -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
    Data)
    #else
      deriving (Eq,Ord,Show)
    #endif

    -- | A type qualified with a context.
    --   An unqualified type has an empty context.
    data HsQualType
             = HsQualType HsContext HsType
    #ifdef __GLASGOW_HASKELL__
      deriving (HsQualType -> HsQualType -> Bool
    (HsQualType -> HsQualType -> Bool)
    -> (HsQualType -> HsQualType -> Bool) -> Eq HsQualType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsQualType -> HsQualType -> Bool
    == :: HsQualType -> HsQualType -> Bool
    $c/= :: HsQualType -> HsQualType -> Bool
    /= :: HsQualType -> HsQualType -> Bool
    Eq,Int -> HsQualType -> ShowS
    [HsQualType] -> ShowS
    HsQualType -> String
    (Int -> HsQualType -> ShowS)
    -> (HsQualType -> String)
    -> ([HsQualType] -> ShowS)
    -> Show HsQualType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsQualType -> ShowS
    showsPrec :: Int -> HsQualType -> ShowS
    $cshow :: HsQualType -> String
    show :: HsQualType -> String
    $cshowList :: [HsQualType] -> ShowS
    showList :: [HsQualType] -> ShowS
    Show,Typeable HsQualType
    Typeable HsQualType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsQualType -> c HsQualType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsQualType)
    -> (HsQualType -> Constr)
    -> (HsQualType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsQualType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsQualType))
    -> ((forall b. Data b => b -> b) -> HsQualType -> HsQualType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsQualType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsQualType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsQualType -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsQualType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType)
    -> Data HsQualType
    HsQualType -> Constr
    HsQualType -> DataType
    (forall b. Data b => b -> b) -> HsQualType -> HsQualType
    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) -> HsQualType -> u
    forall u. (forall d. Data d => d -> u) -> HsQualType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQualType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQualType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQualType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQualType -> c HsQualType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQualType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQualType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQualType -> c HsQualType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsQualType -> c HsQualType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQualType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsQualType
    $ctoConstr :: HsQualType -> Constr
    toConstr :: HsQualType -> Constr
    $cdataTypeOf :: HsQualType -> DataType
    dataTypeOf :: HsQualType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQualType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsQualType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQualType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQualType)
    $cgmapT :: (forall b. Data b => b -> b) -> HsQualType -> HsQualType
    gmapT :: (forall b. Data b => b -> b) -> HsQualType -> HsQualType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQualType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQualType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQualType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsQualType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQualType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsQualType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQualType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQualType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Haskell types and type constructors.
    data HsType
             = HsTyFun   HsType HsType      -- ^ Function type.
             | HsTyTuple [HsType]           -- ^ Tuple type.
             | HsTyApp   HsType HsType      -- ^ Application of a type constructor.
             | HsTyVar   HsName             -- ^ Type variable.
             | HsTyCon   HsQName            -- ^ Named type or type constructor.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsType -> HsType -> Bool
    (HsType -> HsType -> Bool)
    -> (HsType -> HsType -> Bool) -> Eq HsType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsType -> HsType -> Bool
    == :: HsType -> HsType -> Bool
    $c/= :: HsType -> HsType -> Bool
    /= :: HsType -> HsType -> Bool
    Eq,Int -> HsType -> ShowS
    [HsType] -> ShowS
    HsType -> String
    (Int -> HsType -> ShowS)
    -> (HsType -> String) -> ([HsType] -> ShowS) -> Show HsType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsType -> ShowS
    showsPrec :: Int -> HsType -> ShowS
    $cshow :: HsType -> String
    show :: HsType -> String
    $cshowList :: [HsType] -> ShowS
    showList :: [HsType] -> ShowS
    Show,Typeable HsType
    Typeable HsType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsType -> c HsType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsType)
    -> (HsType -> Constr)
    -> (HsType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsType))
    -> ((forall b. Data b => b -> b) -> HsType -> HsType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsType -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsType -> m HsType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsType -> m HsType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsType -> m HsType)
    -> Data HsType
    HsType -> Constr
    HsType -> DataType
    (forall b. Data b => b -> b) -> HsType -> HsType
    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) -> HsType -> u
    forall u. (forall d. Data d => d -> u) -> HsType -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsType -> m HsType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsType -> m HsType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsType -> c HsType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsType -> c HsType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsType -> c HsType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsType
    $ctoConstr :: HsType -> Constr
    toConstr :: HsType -> Constr
    $cdataTypeOf :: HsType -> DataType
    dataTypeOf :: HsType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsType)
    $cgmapT :: (forall b. Data b => b -> b) -> HsType -> HsType
    gmapT :: (forall b. Data b => b -> b) -> HsType -> HsType
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsType -> m HsType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsType -> m HsType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsType -> m HsType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsType -> m HsType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsType -> m HsType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsType -> m HsType
    Data)
    #else
      deriving (Eq,Show)
    #endif

    type HsContext = [HsAsst]

    -- | Class assertions.
    --   In Haskell 98, the argument would be a /tyvar/, but this definition
    --   allows multiple parameters, and allows them to be /type/s.
    type HsAsst    = (HsQName,[HsType])

    -- | /literal/.
    -- Values of this type hold the abstract value of the literal, not the
    -- precise string representation used.  For example, @10@, @0o12@ and @0xa@
    -- have the same representation.
    data HsLiteral
            = HsChar        Char            -- ^ Character literal.
            | HsString      String          -- ^ String literal.
            | HsInt         Integer         -- ^ Integer literal.
            | HsFrac        Rational        -- ^ Floating point literal.
            | HsCharPrim    Char            -- ^ GHC unboxed character literal.
            | HsStringPrim  String          -- ^ GHC unboxed string literal.
            | HsIntPrim     Integer         -- ^ GHC unboxed integer literal.
            | HsFloatPrim   Rational        -- ^ GHC unboxed float literal.
            | HsDoublePrim  Rational        -- ^ GHC unboxed double literal.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsLiteral -> HsLiteral -> Bool
    (HsLiteral -> HsLiteral -> Bool)
    -> (HsLiteral -> HsLiteral -> Bool) -> Eq HsLiteral
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsLiteral -> HsLiteral -> Bool
    == :: HsLiteral -> HsLiteral -> Bool
    $c/= :: HsLiteral -> HsLiteral -> Bool
    /= :: HsLiteral -> HsLiteral -> Bool
    Eq,Int -> HsLiteral -> ShowS
    [HsLiteral] -> ShowS
    HsLiteral -> String
    (Int -> HsLiteral -> ShowS)
    -> (HsLiteral -> String)
    -> ([HsLiteral] -> ShowS)
    -> Show HsLiteral
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsLiteral -> ShowS
    showsPrec :: Int -> HsLiteral -> ShowS
    $cshow :: HsLiteral -> String
    show :: HsLiteral -> String
    $cshowList :: [HsLiteral] -> ShowS
    showList :: [HsLiteral] -> ShowS
    Show,Typeable HsLiteral
    Typeable HsLiteral =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsLiteral -> c HsLiteral)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsLiteral)
    -> (HsLiteral -> Constr)
    -> (HsLiteral -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsLiteral))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLiteral))
    -> ((forall b. Data b => b -> b) -> HsLiteral -> HsLiteral)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsLiteral -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsLiteral -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral)
    -> Data HsLiteral
    HsLiteral -> Constr
    HsLiteral -> DataType
    (forall b. Data b => b -> b) -> HsLiteral -> HsLiteral
    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) -> HsLiteral -> u
    forall u. (forall d. Data d => d -> u) -> HsLiteral -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsLiteral
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsLiteral -> c HsLiteral
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsLiteral)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLiteral)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsLiteral -> c HsLiteral
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsLiteral -> c HsLiteral
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsLiteral
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsLiteral
    $ctoConstr :: HsLiteral -> Constr
    toConstr :: HsLiteral -> Constr
    $cdataTypeOf :: HsLiteral -> DataType
    dataTypeOf :: HsLiteral -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsLiteral)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsLiteral)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLiteral)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLiteral)
    $cgmapT :: (forall b. Data b => b -> b) -> HsLiteral -> HsLiteral
    gmapT :: (forall b. Data b => b -> b) -> HsLiteral -> HsLiteral
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsLiteral -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsLiteral -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsLiteral -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsLiteral -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | Haskell expressions.
    --
    -- /Notes:/
    --
    -- * Because it is difficult for parsers to distinguish patterns from
    --   expressions, they typically parse them in the same way and then check
    --   that they have the appropriate form.  Hence the expression type
    --   includes some forms that are found only in patterns.  After these
    --   checks, these constructors should not be used.
    --
    -- * The parser does not take precedence and associativity into account,
    --   so it will leave 'HsInfixApp's associated to the left.
    --
    -- * The 'Language.Haskell.Pretty.Pretty' instance for 'HsExp' does not
    --   add parentheses in printing.

    data HsExp
            = HsVar HsQName                 -- ^ Variable.
            | HsCon HsQName                 -- ^ Data constructor.
            | HsLit HsLiteral               -- ^ Literal constant.
            | HsInfixApp HsExp HsQOp HsExp  -- ^ Infix application.
            | HsApp HsExp HsExp             -- ^ Ordinary application.
            | HsNegApp HsExp                -- ^ Negation expression @-@ /exp/.
            | HsLambda SrcLoc [HsPat] HsExp -- ^ Lambda expression.
            | HsLet [HsDecl] HsExp          -- ^ Local declarations with @let@.
            | HsIf HsExp HsExp HsExp        -- ^ @If@ /exp/ @then@ /exp/ @else@ /exp/.
            | HsCase HsExp [HsAlt]          -- ^ @Case@ /exp/ @of@ /alts/.
            | HsDo [HsStmt]                 -- ^ @Do@-expression:
                                            -- The last statement in the list
                                            -- should be an expression.
            | HsTuple [HsExp]               -- ^ Tuple expression.
            | HsList [HsExp]                -- ^ List expression.
            | HsParen HsExp                 -- ^ Parenthesized expression.
            | HsLeftSection HsExp HsQOp     -- ^ Left section @(@/exp/ /qop/@)@.
            | HsRightSection HsQOp HsExp    -- ^ Right section @(@/qop/ /exp/@)@.
            | HsRecConstr HsQName [HsFieldUpdate]
                                            -- ^ Record construction expression.
            | HsRecUpdate HsExp [HsFieldUpdate]
                                            -- ^ Record update expression.
            | HsEnumFrom HsExp              -- ^ Unbounded arithmetic sequence,
                                            -- incrementing by 1.
            | HsEnumFromTo HsExp HsExp      -- ^ Bounded arithmetic sequence,
                                            -- incrementing by 1.
            | HsEnumFromThen HsExp HsExp    -- ^ Unbounded arithmetic sequence,
                                            -- with first two elements given.
            | HsEnumFromThenTo HsExp HsExp HsExp
                                            -- ^ Bounded arithmetic sequence,
                                            -- with first two elements given.
            | HsListComp HsExp [HsStmt]     -- ^ List comprehension.
            | HsExpTypeSig SrcLoc HsExp HsQualType
                                            -- ^ Expression type signature.
            | HsAsPat HsName HsExp          -- ^ (patterns only)
            | HsWildCard                    -- ^ (patterns only)
            | HsIrrPat HsExp                -- ^ (patterns only)
    #ifdef __GLASGOW_HASKELL__
      deriving (HsExp -> HsExp -> Bool
    (HsExp -> HsExp -> Bool) -> (HsExp -> HsExp -> Bool) -> Eq HsExp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsExp -> HsExp -> Bool
    == :: HsExp -> HsExp -> Bool
    $c/= :: HsExp -> HsExp -> Bool
    /= :: HsExp -> HsExp -> Bool
    Eq,Int -> HsExp -> ShowS
    [HsExp] -> ShowS
    HsExp -> String
    (Int -> HsExp -> ShowS)
    -> (HsExp -> String) -> ([HsExp] -> ShowS) -> Show HsExp
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsExp -> ShowS
    showsPrec :: Int -> HsExp -> ShowS
    $cshow :: HsExp -> String
    show :: HsExp -> String
    $cshowList :: [HsExp] -> ShowS
    showList :: [HsExp] -> ShowS
    Show,Typeable HsExp
    Typeable HsExp =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsExp -> c HsExp)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsExp)
    -> (HsExp -> Constr)
    -> (HsExp -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsExp))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExp))
    -> ((forall b. Data b => b -> b) -> HsExp -> HsExp)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsExp -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsExp -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsExp -> m HsExp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsExp -> m HsExp)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsExp -> m HsExp)
    -> Data HsExp
    HsExp -> Constr
    HsExp -> DataType
    (forall b. Data b => b -> b) -> HsExp -> HsExp
    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) -> HsExp -> u
    forall u. (forall d. Data d => d -> u) -> HsExp -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsExp -> m HsExp
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExp -> m HsExp
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsExp
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsExp -> c HsExp
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsExp)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExp)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsExp -> c HsExp
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsExp -> c HsExp
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsExp
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsExp
    $ctoConstr :: HsExp -> Constr
    toConstr :: HsExp -> Constr
    $cdataTypeOf :: HsExp -> DataType
    dataTypeOf :: HsExp -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsExp)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsExp)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExp)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExp)
    $cgmapT :: (forall b. Data b => b -> b) -> HsExp -> HsExp
    gmapT :: (forall b. Data b => b -> b) -> HsExp -> HsExp
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsExp -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsExp -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsExp -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsExp -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsExp -> m HsExp
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsExp -> m HsExp
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExp -> m HsExp
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExp -> m HsExp
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExp -> m HsExp
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsExp -> m HsExp
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | A pattern, to be matched against a value.
    data HsPat
            = HsPVar HsName                 -- ^ Variable.
            | HsPLit HsLiteral              -- ^ Literal constant.
            | HsPNeg HsPat                  -- ^ Negated pattern.
            | HsPInfixApp HsPat HsQName HsPat
                                            -- ^ Pattern with infix data constructor.
            | HsPApp HsQName [HsPat]        -- ^ Data constructor and argument
                                            -- patterns.
            | HsPTuple [HsPat]              -- ^ Tuple pattern.
            | HsPList [HsPat]               -- ^ List pattern.
            | HsPParen HsPat                -- ^ Parenthesized pattern.
            | HsPRec HsQName [HsPatField]   -- ^ Labelled pattern.
            | HsPAsPat HsName HsPat         -- ^ @\@@-Pattern.
            | HsPWildCard                   -- ^ Wildcard pattern (@_@).
            | HsPIrrPat HsPat               -- ^ Irrefutable pattern (@~@).
    #ifdef __GLASGOW_HASKELL__
      deriving (HsPat -> HsPat -> Bool
    (HsPat -> HsPat -> Bool) -> (HsPat -> HsPat -> Bool) -> Eq HsPat
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsPat -> HsPat -> Bool
    == :: HsPat -> HsPat -> Bool
    $c/= :: HsPat -> HsPat -> Bool
    /= :: HsPat -> HsPat -> Bool
    Eq,Int -> HsPat -> ShowS
    [HsPat] -> ShowS
    HsPat -> String
    (Int -> HsPat -> ShowS)
    -> (HsPat -> String) -> ([HsPat] -> ShowS) -> Show HsPat
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsPat -> ShowS
    showsPrec :: Int -> HsPat -> ShowS
    $cshow :: HsPat -> String
    show :: HsPat -> String
    $cshowList :: [HsPat] -> ShowS
    showList :: [HsPat] -> ShowS
    Show,Typeable HsPat
    Typeable HsPat =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsPat -> c HsPat)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsPat)
    -> (HsPat -> Constr)
    -> (HsPat -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsPat))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPat))
    -> ((forall b. Data b => b -> b) -> HsPat -> HsPat)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsPat -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsPat -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsPat -> m HsPat)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsPat -> m HsPat)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsPat -> m HsPat)
    -> Data HsPat
    HsPat -> Constr
    HsPat -> DataType
    (forall b. Data b => b -> b) -> HsPat -> HsPat
    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) -> HsPat -> u
    forall u. (forall d. Data d => d -> u) -> HsPat -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsPat -> m HsPat
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPat -> m HsPat
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsPat
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsPat -> c HsPat
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsPat)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPat)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsPat -> c HsPat
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsPat -> c HsPat
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsPat
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsPat
    $ctoConstr :: HsPat -> Constr
    toConstr :: HsPat -> Constr
    $cdataTypeOf :: HsPat -> DataType
    dataTypeOf :: HsPat -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsPat)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsPat)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPat)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPat)
    $cgmapT :: (forall b. Data b => b -> b) -> HsPat -> HsPat
    gmapT :: (forall b. Data b => b -> b) -> HsPat -> HsPat
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsPat -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsPat -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsPat -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsPat -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsPat -> m HsPat
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsPat -> m HsPat
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPat -> m HsPat
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPat -> m HsPat
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPat -> m HsPat
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPat -> m HsPat
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | An /fpat/ in a labeled record pattern.
    data HsPatField
            = HsPFieldPat HsQName HsPat
    #ifdef __GLASGOW_HASKELL__
      deriving (HsPatField -> HsPatField -> Bool
    (HsPatField -> HsPatField -> Bool)
    -> (HsPatField -> HsPatField -> Bool) -> Eq HsPatField
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsPatField -> HsPatField -> Bool
    == :: HsPatField -> HsPatField -> Bool
    $c/= :: HsPatField -> HsPatField -> Bool
    /= :: HsPatField -> HsPatField -> Bool
    Eq,Int -> HsPatField -> ShowS
    [HsPatField] -> ShowS
    HsPatField -> String
    (Int -> HsPatField -> ShowS)
    -> (HsPatField -> String)
    -> ([HsPatField] -> ShowS)
    -> Show HsPatField
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsPatField -> ShowS
    showsPrec :: Int -> HsPatField -> ShowS
    $cshow :: HsPatField -> String
    show :: HsPatField -> String
    $cshowList :: [HsPatField] -> ShowS
    showList :: [HsPatField] -> ShowS
    Show,Typeable HsPatField
    Typeable HsPatField =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsPatField -> c HsPatField)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsPatField)
    -> (HsPatField -> Constr)
    -> (HsPatField -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsPatField))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsPatField))
    -> ((forall b. Data b => b -> b) -> HsPatField -> HsPatField)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsPatField -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsPatField -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsPatField -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsPatField -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField)
    -> Data HsPatField
    HsPatField -> Constr
    HsPatField -> DataType
    (forall b. Data b => b -> b) -> HsPatField -> HsPatField
    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) -> HsPatField -> u
    forall u. (forall d. Data d => d -> u) -> HsPatField -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsPatField -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsPatField -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsPatField
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsPatField -> c HsPatField
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsPatField)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPatField)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsPatField -> c HsPatField
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsPatField -> c HsPatField
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsPatField
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsPatField
    $ctoConstr :: HsPatField -> Constr
    toConstr :: HsPatField -> Constr
    $cdataTypeOf :: HsPatField -> DataType
    dataTypeOf :: HsPatField -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsPatField)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsPatField)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPatField)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPatField)
    $cgmapT :: (forall b. Data b => b -> b) -> HsPatField -> HsPatField
    gmapT :: (forall b. Data b => b -> b) -> HsPatField -> HsPatField
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsPatField -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsPatField -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsPatField -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsPatField -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsPatField -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsPatField -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsPatField -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsPatField -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | This type represents both /stmt/ in a @do@-expression,
    --   and /qual/ in a list comprehension.
    data HsStmt
            = HsGenerator SrcLoc HsPat HsExp
                                    -- ^ A generator /pat/ @<-@ /exp/.
            | HsQualifier HsExp     -- ^ An /exp/ by itself: in a @do@-expression,
                                    -- an action whose result is discarded;
                                    -- in a list comprehension, a guard expression.
            | HsLetStmt [HsDecl]    -- ^ Local bindings.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsStmt -> HsStmt -> Bool
    (HsStmt -> HsStmt -> Bool)
    -> (HsStmt -> HsStmt -> Bool) -> Eq HsStmt
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsStmt -> HsStmt -> Bool
    == :: HsStmt -> HsStmt -> Bool
    $c/= :: HsStmt -> HsStmt -> Bool
    /= :: HsStmt -> HsStmt -> Bool
    Eq,Int -> HsStmt -> ShowS
    [HsStmt] -> ShowS
    HsStmt -> String
    (Int -> HsStmt -> ShowS)
    -> (HsStmt -> String) -> ([HsStmt] -> ShowS) -> Show HsStmt
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsStmt -> ShowS
    showsPrec :: Int -> HsStmt -> ShowS
    $cshow :: HsStmt -> String
    show :: HsStmt -> String
    $cshowList :: [HsStmt] -> ShowS
    showList :: [HsStmt] -> ShowS
    Show,Typeable HsStmt
    Typeable HsStmt =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsStmt -> c HsStmt)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsStmt)
    -> (HsStmt -> Constr)
    -> (HsStmt -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsStmt))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsStmt))
    -> ((forall b. Data b => b -> b) -> HsStmt -> HsStmt)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsStmt -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsStmt -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsStmt -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsStmt -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt)
    -> Data HsStmt
    HsStmt -> Constr
    HsStmt -> DataType
    (forall b. Data b => b -> b) -> HsStmt -> HsStmt
    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) -> HsStmt -> u
    forall u. (forall d. Data d => d -> u) -> HsStmt -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsStmt
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsStmt -> c HsStmt
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsStmt)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsStmt)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsStmt -> c HsStmt
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsStmt -> c HsStmt
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsStmt
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsStmt
    $ctoConstr :: HsStmt -> Constr
    toConstr :: HsStmt -> Constr
    $cdataTypeOf :: HsStmt -> DataType
    dataTypeOf :: HsStmt -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsStmt)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsStmt)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsStmt)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsStmt)
    $cgmapT :: (forall b. Data b => b -> b) -> HsStmt -> HsStmt
    gmapT :: (forall b. Data b => b -> b) -> HsStmt -> HsStmt
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsStmt -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsStmt -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsStmt -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsStmt -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | An /fbind/ in a labeled record construction or update expression.
    data HsFieldUpdate
            = HsFieldUpdate HsQName HsExp
    #ifdef __GLASGOW_HASKELL__
      deriving (HsFieldUpdate -> HsFieldUpdate -> Bool
    (HsFieldUpdate -> HsFieldUpdate -> Bool)
    -> (HsFieldUpdate -> HsFieldUpdate -> Bool) -> Eq HsFieldUpdate
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsFieldUpdate -> HsFieldUpdate -> Bool
    == :: HsFieldUpdate -> HsFieldUpdate -> Bool
    $c/= :: HsFieldUpdate -> HsFieldUpdate -> Bool
    /= :: HsFieldUpdate -> HsFieldUpdate -> Bool
    Eq,Int -> HsFieldUpdate -> ShowS
    [HsFieldUpdate] -> ShowS
    HsFieldUpdate -> String
    (Int -> HsFieldUpdate -> ShowS)
    -> (HsFieldUpdate -> String)
    -> ([HsFieldUpdate] -> ShowS)
    -> Show HsFieldUpdate
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsFieldUpdate -> ShowS
    showsPrec :: Int -> HsFieldUpdate -> ShowS
    $cshow :: HsFieldUpdate -> String
    show :: HsFieldUpdate -> String
    $cshowList :: [HsFieldUpdate] -> ShowS
    showList :: [HsFieldUpdate] -> ShowS
    Show,Typeable HsFieldUpdate
    Typeable HsFieldUpdate =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsFieldUpdate)
    -> (HsFieldUpdate -> Constr)
    -> (HsFieldUpdate -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsFieldUpdate))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsFieldUpdate))
    -> ((forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsFieldUpdate -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate)
    -> Data HsFieldUpdate
    HsFieldUpdate -> Constr
    HsFieldUpdate -> DataType
    (forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate
    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) -> HsFieldUpdate -> u
    forall u. (forall d. Data d => d -> u) -> HsFieldUpdate -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsFieldUpdate
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsFieldUpdate)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsFieldUpdate)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsFieldUpdate
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsFieldUpdate
    $ctoConstr :: HsFieldUpdate -> Constr
    toConstr :: HsFieldUpdate -> Constr
    $cdataTypeOf :: HsFieldUpdate -> DataType
    dataTypeOf :: HsFieldUpdate -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsFieldUpdate)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsFieldUpdate)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsFieldUpdate)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsFieldUpdate)
    $cgmapT :: (forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate
    gmapT :: (forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsFieldUpdate -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsFieldUpdate -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | An /alt/ in a @case@ expression.
    data HsAlt
            = HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl]
    #ifdef __GLASGOW_HASKELL__
      deriving (HsAlt -> HsAlt -> Bool
    (HsAlt -> HsAlt -> Bool) -> (HsAlt -> HsAlt -> Bool) -> Eq HsAlt
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsAlt -> HsAlt -> Bool
    == :: HsAlt -> HsAlt -> Bool
    $c/= :: HsAlt -> HsAlt -> Bool
    /= :: HsAlt -> HsAlt -> Bool
    Eq,Int -> HsAlt -> ShowS
    [HsAlt] -> ShowS
    HsAlt -> String
    (Int -> HsAlt -> ShowS)
    -> (HsAlt -> String) -> ([HsAlt] -> ShowS) -> Show HsAlt
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsAlt -> ShowS
    showsPrec :: Int -> HsAlt -> ShowS
    $cshow :: HsAlt -> String
    show :: HsAlt -> String
    $cshowList :: [HsAlt] -> ShowS
    showList :: [HsAlt] -> ShowS
    Show,Typeable HsAlt
    Typeable HsAlt =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsAlt -> c HsAlt)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsAlt)
    -> (HsAlt -> Constr)
    -> (HsAlt -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsAlt))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAlt))
    -> ((forall b. Data b => b -> b) -> HsAlt -> HsAlt)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsAlt -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsAlt -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt)
    -> Data HsAlt
    HsAlt -> Constr
    HsAlt -> DataType
    (forall b. Data b => b -> b) -> HsAlt -> HsAlt
    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) -> HsAlt -> u
    forall u. (forall d. Data d => d -> u) -> HsAlt -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsAlt
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsAlt -> c HsAlt
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsAlt)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAlt)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsAlt -> c HsAlt
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsAlt -> c HsAlt
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsAlt
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsAlt
    $ctoConstr :: HsAlt -> Constr
    toConstr :: HsAlt -> Constr
    $cdataTypeOf :: HsAlt -> DataType
    dataTypeOf :: HsAlt -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsAlt)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsAlt)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAlt)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAlt)
    $cgmapT :: (forall b. Data b => b -> b) -> HsAlt -> HsAlt
    gmapT :: (forall b. Data b => b -> b) -> HsAlt -> HsAlt
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsAlt -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsAlt -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsAlt -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsAlt -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
    Data)
    #else
      deriving (Eq,Show)
    #endif

    data HsGuardedAlts
            = HsUnGuardedAlt HsExp          -- ^ @->@ /exp/.
            | HsGuardedAlts  [HsGuardedAlt] -- ^ /gdpat/.
    #ifdef __GLASGOW_HASKELL__
      deriving (HsGuardedAlts -> HsGuardedAlts -> Bool
    (HsGuardedAlts -> HsGuardedAlts -> Bool)
    -> (HsGuardedAlts -> HsGuardedAlts -> Bool) -> Eq HsGuardedAlts
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsGuardedAlts -> HsGuardedAlts -> Bool
    == :: HsGuardedAlts -> HsGuardedAlts -> Bool
    $c/= :: HsGuardedAlts -> HsGuardedAlts -> Bool
    /= :: HsGuardedAlts -> HsGuardedAlts -> Bool
    Eq,Int -> HsGuardedAlts -> ShowS
    [HsGuardedAlts] -> ShowS
    HsGuardedAlts -> String
    (Int -> HsGuardedAlts -> ShowS)
    -> (HsGuardedAlts -> String)
    -> ([HsGuardedAlts] -> ShowS)
    -> Show HsGuardedAlts
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsGuardedAlts -> ShowS
    showsPrec :: Int -> HsGuardedAlts -> ShowS
    $cshow :: HsGuardedAlts -> String
    show :: HsGuardedAlts -> String
    $cshowList :: [HsGuardedAlts] -> ShowS
    showList :: [HsGuardedAlts] -> ShowS
    Show,Typeable HsGuardedAlts
    Typeable HsGuardedAlts =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsGuardedAlts)
    -> (HsGuardedAlts -> Constr)
    -> (HsGuardedAlts -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlts))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsGuardedAlts))
    -> ((forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsGuardedAlts -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts)
    -> Data HsGuardedAlts
    HsGuardedAlts -> Constr
    HsGuardedAlts -> DataType
    (forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts
    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) -> HsGuardedAlts -> u
    forall u. (forall d. Data d => d -> u) -> HsGuardedAlts -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedAlts
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlts)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedAlts)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedAlts
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedAlts
    $ctoConstr :: HsGuardedAlts -> Constr
    toConstr :: HsGuardedAlts -> Constr
    $cdataTypeOf :: HsGuardedAlts -> DataType
    dataTypeOf :: HsGuardedAlts -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlts)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlts)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedAlts)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedAlts)
    $cgmapT :: (forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts
    gmapT :: (forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlts -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlts -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -- | A guarded alternative @|@ /exp/ @->@ /exp/.
    -- The first expression will be Boolean-valued.
    data HsGuardedAlt
            = HsGuardedAlt SrcLoc HsExp HsExp
    #ifdef __GLASGOW_HASKELL__
      deriving (HsGuardedAlt -> HsGuardedAlt -> Bool
    (HsGuardedAlt -> HsGuardedAlt -> Bool)
    -> (HsGuardedAlt -> HsGuardedAlt -> Bool) -> Eq HsGuardedAlt
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsGuardedAlt -> HsGuardedAlt -> Bool
    == :: HsGuardedAlt -> HsGuardedAlt -> Bool
    $c/= :: HsGuardedAlt -> HsGuardedAlt -> Bool
    /= :: HsGuardedAlt -> HsGuardedAlt -> Bool
    Eq,Int -> HsGuardedAlt -> ShowS
    [HsGuardedAlt] -> ShowS
    HsGuardedAlt -> String
    (Int -> HsGuardedAlt -> ShowS)
    -> (HsGuardedAlt -> String)
    -> ([HsGuardedAlt] -> ShowS)
    -> Show HsGuardedAlt
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HsGuardedAlt -> ShowS
    showsPrec :: Int -> HsGuardedAlt -> ShowS
    $cshow :: HsGuardedAlt -> String
    show :: HsGuardedAlt -> String
    $cshowList :: [HsGuardedAlt] -> ShowS
    showList :: [HsGuardedAlt] -> ShowS
    Show,Typeable HsGuardedAlt
    Typeable HsGuardedAlt =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsGuardedAlt)
    -> (HsGuardedAlt -> Constr)
    -> (HsGuardedAlt -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlt))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HsGuardedAlt))
    -> ((forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsGuardedAlt -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt)
    -> Data HsGuardedAlt
    HsGuardedAlt -> Constr
    HsGuardedAlt -> DataType
    (forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt
    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) -> HsGuardedAlt -> u
    forall u. (forall d. Data d => d -> u) -> HsGuardedAlt -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedAlt
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlt)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedAlt)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedAlt
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsGuardedAlt
    $ctoConstr :: HsGuardedAlt -> Constr
    toConstr :: HsGuardedAlt -> Constr
    $cdataTypeOf :: HsGuardedAlt -> DataType
    dataTypeOf :: HsGuardedAlt -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlt)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlt)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedAlt)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsGuardedAlt)
    $cgmapT :: (forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt
    gmapT :: (forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlt -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlt -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
    Data)
    #else
      deriving (Eq,Show)
    #endif

    -----------------------------------------------------------------------------
    -- Builtin names.

    prelude_mod, main_mod :: Module
    prelude_mod :: Module
    prelude_mod           = String -> Module
    Module String
    "Prelude"
    main_mod :: Module
    main_mod              = String -> Module
    Module String
    "Main"

    main_name :: HsName
    main_name :: HsName
    main_name             = String -> HsName
    HsIdent String
    "main"

    unit_con_name :: HsQName
    unit_con_name :: HsQName
    unit_con_name         = HsSpecialCon -> HsQName
    Special HsSpecialCon
    HsUnitCon

    tuple_con_name :: Int -> HsQName
    tuple_con_name :: Int -> HsQName
    tuple_con_name Int
    i      = HsSpecialCon -> HsQName
    Special (Int -> HsSpecialCon
    HsTupleCon (Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1))

    list_cons_name :: HsQName
    list_cons_name :: HsQName
    list_cons_name        = HsSpecialCon -> HsQName
    Special HsSpecialCon
    HsCons

    unit_con :: HsExp
    unit_con :: HsExp
    unit_con              = HsQName -> HsExp
    HsCon HsQName
    unit_con_name

    tuple_con :: Int -> HsExp
    tuple_con :: Int -> HsExp
    tuple_con Int
    i           = HsQName -> HsExp
    HsCon (Int -> HsQName
    tuple_con_name Int
    i)

    unit_tycon_name, fun_tycon_name, list_tycon_name :: HsQName
    unit_tycon_name :: HsQName
    unit_tycon_name       = HsQName
    unit_con_name
    fun_tycon_name :: HsQName
    fun_tycon_name        = HsSpecialCon -> HsQName
    Special HsSpecialCon
    HsFunCon
    list_tycon_name :: HsQName
    list_tycon_name       = HsSpecialCon -> HsQName
    Special HsSpecialCon
    HsListCon

    tuple_tycon_name :: Int -> HsQName
    tuple_tycon_name :: Int -> HsQName
    tuple_tycon_name Int
    i    = Int -> HsQName
    tuple_con_name Int
    i

    unit_tycon, fun_tycon, list_tycon :: HsType
    unit_tycon :: HsType
    unit_tycon            = HsQName -> HsType
    HsTyCon HsQName
    unit_tycon_name
    fun_tycon :: HsType
    fun_tycon             = HsQName -> HsType
    HsTyCon HsQName
    fun_tycon_name
    list_tycon :: HsType
    list_tycon            = HsQName -> HsType
    HsTyCon HsQName
    list_tycon_name

    tuple_tycon :: Int -> HsType
    tuple_tycon :: Int -> HsType
    tuple_tycon Int
    i         = HsQName -> HsType
    HsTyCon (Int -> HsQName
    tuple_tycon_name Int
    i)