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

-----------------------------------------------------------------------------
-- |
-- Module      :  Language.Haskell.Syntax
-- Copyright   :  (c) The GHC Team, 1997-2000
-- License     :  BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer  :  libraries@haskell.org
-- Stability   :  experimental
-- 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
--
-- This module has been changed so that show is a real show.
-- For GHC, we also derive Typeable and 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
/= :: SrcLoc -> SrcLoc -> Bool
$c/= :: SrcLoc -> SrcLoc -> Bool
== :: SrcLoc -> SrcLoc -> Bool
$c== :: 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
min :: SrcLoc -> SrcLoc -> SrcLoc
$cmin :: SrcLoc -> SrcLoc -> SrcLoc
max :: SrcLoc -> SrcLoc -> SrcLoc
$cmax :: SrcLoc -> SrcLoc -> SrcLoc
>= :: SrcLoc -> SrcLoc -> Bool
$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
compare :: SrcLoc -> SrcLoc -> Ordering
$ccompare :: SrcLoc -> SrcLoc -> Ordering
$cp1Ord :: Eq 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
showList :: [SrcLoc] -> ShowS
$cshowList :: [SrcLoc] -> ShowS
show :: SrcLoc -> String
$cshow :: SrcLoc -> String
showsPrec :: Int -> SrcLoc -> ShowS
$cshowsPrec :: Int -> SrcLoc -> ShowS
Show,Typeable,Typeable SrcLoc
DataType
Constr
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 -> DataType
SrcLoc -> Constr
(forall b. Data b => b -> b) -> SrcLoc -> SrcLoc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcLoc -> c SrcLoc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cSrcLoc :: Constr
$tSrcLoc :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc
gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcLoc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SrcLoc -> u
gmapQ :: (forall d. Data d => d -> u) -> SrcLoc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SrcLoc -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r
gmapT :: (forall b. Data b => b -> b) -> SrcLoc -> SrcLoc
$cgmapT :: (forall b. Data b => b -> b) -> SrcLoc -> SrcLoc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcLoc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcLoc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SrcLoc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SrcLoc)
dataTypeOf :: SrcLoc -> DataType
$cdataTypeOf :: SrcLoc -> DataType
toConstr :: SrcLoc -> Constr
$ctoConstr :: SrcLoc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcLoc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcLoc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcLoc -> c SrcLoc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcLoc -> c SrcLoc
$cp1Data :: Typeable 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
/= :: Module -> Module -> Bool
$c/= :: Module -> Module -> Bool
== :: Module -> Module -> Bool
$c== :: 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
min :: Module -> Module -> Module
$cmin :: Module -> Module -> Module
max :: Module -> Module -> Module
$cmax :: Module -> Module -> Module
>= :: Module -> Module -> Bool
$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
compare :: Module -> Module -> Ordering
$ccompare :: Module -> Module -> Ordering
$cp1Ord :: Eq 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
showList :: [Module] -> ShowS
$cshowList :: [Module] -> ShowS
show :: Module -> String
$cshow :: Module -> String
showsPrec :: Int -> Module -> ShowS
$cshowsPrec :: Int -> Module -> ShowS
Show,Typeable,Typeable Module
DataType
Constr
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 -> DataType
Module -> Constr
(forall b. Data b => b -> b) -> Module -> Module
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
forall u. (forall d. Data d => d -> u) -> Module -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cModule :: Constr
$tModule :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapMp :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapM :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
gmapQ :: (forall d. Data d => d -> u) -> Module -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapT :: (forall b. Data b => b -> b) -> Module -> Module
$cgmapT :: (forall b. Data b => b -> b) -> Module -> Module
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Module)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
dataTypeOf :: Module -> DataType
$cdataTypeOf :: Module -> DataType
toConstr :: Module -> Constr
$ctoConstr :: Module -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
$cp1Data :: Typeable Module
Data)
#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
/= :: HsSpecialCon -> HsSpecialCon -> Bool
$c/= :: HsSpecialCon -> HsSpecialCon -> Bool
== :: HsSpecialCon -> HsSpecialCon -> Bool
$c== :: 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
min :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon
$cmin :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon
max :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon
$cmax :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon
>= :: HsSpecialCon -> HsSpecialCon -> Bool
$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
compare :: HsSpecialCon -> HsSpecialCon -> Ordering
$ccompare :: HsSpecialCon -> HsSpecialCon -> Ordering
$cp1Ord :: Eq 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
showList :: [HsSpecialCon] -> ShowS
$cshowList :: [HsSpecialCon] -> ShowS
show :: HsSpecialCon -> String
$cshow :: HsSpecialCon -> String
showsPrec :: Int -> HsSpecialCon -> ShowS
$cshowsPrec :: Int -> HsSpecialCon -> ShowS
Show,Typeable,Typeable HsSpecialCon
DataType
Constr
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 -> DataType
HsSpecialCon -> Constr
(forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsCons :: Constr
$cHsTupleCon :: Constr
$cHsFunCon :: Constr
$cHsListCon :: Constr
$cHsUnitCon :: Constr
$tHsSpecialCon :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u
gmapQ :: (forall d. Data d => d -> u) -> HsSpecialCon -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsSpecialCon -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
gmapT :: (forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon
$cgmapT :: (forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsSpecialCon)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsSpecialCon)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsSpecialCon)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsSpecialCon)
dataTypeOf :: HsSpecialCon -> DataType
$cdataTypeOf :: HsSpecialCon -> DataType
toConstr :: HsSpecialCon -> Constr
$ctoConstr :: HsSpecialCon -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsSpecialCon
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsSpecialCon
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon
$cp1Data :: Typeable 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
/= :: HsQName -> HsQName -> Bool
$c/= :: HsQName -> HsQName -> Bool
== :: HsQName -> HsQName -> Bool
$c== :: 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
min :: HsQName -> HsQName -> HsQName
$cmin :: HsQName -> HsQName -> HsQName
max :: HsQName -> HsQName -> HsQName
$cmax :: HsQName -> HsQName -> HsQName
>= :: HsQName -> HsQName -> Bool
$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
compare :: HsQName -> HsQName -> Ordering
$ccompare :: HsQName -> HsQName -> Ordering
$cp1Ord :: Eq 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
showList :: [HsQName] -> ShowS
$cshowList :: [HsQName] -> ShowS
show :: HsQName -> String
$cshow :: HsQName -> String
showsPrec :: Int -> HsQName -> ShowS
$cshowsPrec :: Int -> HsQName -> ShowS
Show,Typeable,Typeable HsQName
DataType
Constr
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 -> DataType
HsQName -> Constr
(forall b. Data b => b -> b) -> HsQName -> HsQName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQName -> c HsQName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cSpecial :: Constr
$cUnQual :: Constr
$cQual :: Constr
$tHsQName :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsQName -> m HsQName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsQName -> m HsQName
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQName -> u
gmapQ :: (forall d. Data d => d -> u) -> HsQName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQName -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsQName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsQName -> r
gmapT :: (forall b. Data b => b -> b) -> HsQName -> HsQName
$cgmapT :: (forall b. Data b => b -> b) -> HsQName -> HsQName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsQName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsQName)
dataTypeOf :: HsQName -> DataType
$cdataTypeOf :: HsQName -> DataType
toConstr :: HsQName -> Constr
$ctoConstr :: HsQName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsQName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsQName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQName -> c HsQName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQName -> c HsQName
$cp1Data :: Typeable 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
/= :: HsName -> HsName -> Bool
$c/= :: HsName -> HsName -> Bool
== :: HsName -> HsName -> Bool
$c== :: 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
min :: HsName -> HsName -> HsName
$cmin :: HsName -> HsName -> HsName
max :: HsName -> HsName -> HsName
$cmax :: HsName -> HsName -> HsName
>= :: HsName -> HsName -> Bool
$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
compare :: HsName -> HsName -> Ordering
$ccompare :: HsName -> HsName -> Ordering
$cp1Ord :: Eq 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
showList :: [HsName] -> ShowS
$cshowList :: [HsName] -> ShowS
show :: HsName -> String
$cshow :: HsName -> String
showsPrec :: Int -> HsName -> ShowS
$cshowsPrec :: Int -> HsName -> ShowS
Show,Typeable,Typeable HsName
DataType
Constr
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 -> DataType
HsName -> Constr
(forall b. Data b => b -> b) -> HsName -> HsName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsName -> c HsName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsSymbol :: Constr
$cHsIdent :: Constr
$tHsName :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsName -> m HsName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsName -> m HsName
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsName -> u
gmapQ :: (forall d. Data d => d -> u) -> HsName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsName -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
gmapT :: (forall b. Data b => b -> b) -> HsName -> HsName
$cgmapT :: (forall b. Data b => b -> b) -> HsName -> HsName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsName)
dataTypeOf :: HsName -> DataType
$cdataTypeOf :: HsName -> DataType
toConstr :: HsName -> Constr
$ctoConstr :: HsName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsName -> c HsName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsName -> c HsName
$cp1Data :: Typeable 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
/= :: HsQOp -> HsQOp -> Bool
$c/= :: HsQOp -> HsQOp -> Bool
== :: HsQOp -> HsQOp -> Bool
$c== :: 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
min :: HsQOp -> HsQOp -> HsQOp
$cmin :: HsQOp -> HsQOp -> HsQOp
max :: HsQOp -> HsQOp -> HsQOp
$cmax :: HsQOp -> HsQOp -> HsQOp
>= :: HsQOp -> HsQOp -> Bool
$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
compare :: HsQOp -> HsQOp -> Ordering
$ccompare :: HsQOp -> HsQOp -> Ordering
$cp1Ord :: Eq 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
showList :: [HsQOp] -> ShowS
$cshowList :: [HsQOp] -> ShowS
show :: HsQOp -> String
$cshow :: HsQOp -> String
showsPrec :: Int -> HsQOp -> ShowS
$cshowsPrec :: Int -> HsQOp -> ShowS
Show,Typeable,Typeable HsQOp
DataType
Constr
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 -> DataType
HsQOp -> Constr
(forall b. Data b => b -> b) -> HsQOp -> HsQOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQOp -> c HsQOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsQConOp :: Constr
$cHsQVarOp :: Constr
$tHsQOp :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQOp -> u
gmapQ :: (forall d. Data d => d -> u) -> HsQOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQOp -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
gmapT :: (forall b. Data b => b -> b) -> HsQOp -> HsQOp
$cgmapT :: (forall b. Data b => b -> b) -> HsQOp -> HsQOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsQOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsQOp)
dataTypeOf :: HsQOp -> DataType
$cdataTypeOf :: HsQOp -> DataType
toConstr :: HsQOp -> Constr
$ctoConstr :: HsQOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsQOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsQOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQOp -> c HsQOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQOp -> c HsQOp
$cp1Data :: Typeable 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
/= :: HsOp -> HsOp -> Bool
$c/= :: HsOp -> HsOp -> Bool
== :: HsOp -> HsOp -> Bool
$c== :: 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
min :: HsOp -> HsOp -> HsOp
$cmin :: HsOp -> HsOp -> HsOp
max :: HsOp -> HsOp -> HsOp
$cmax :: HsOp -> HsOp -> HsOp
>= :: HsOp -> HsOp -> Bool
$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
compare :: HsOp -> HsOp -> Ordering
$ccompare :: HsOp -> HsOp -> Ordering
$cp1Ord :: Eq 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
showList :: [HsOp] -> ShowS
$cshowList :: [HsOp] -> ShowS
show :: HsOp -> String
$cshow :: HsOp -> String
showsPrec :: Int -> HsOp -> ShowS
$cshowsPrec :: Int -> HsOp -> ShowS
Show,Typeable,Typeable HsOp
DataType
Constr
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 -> DataType
HsOp -> Constr
(forall b. Data b => b -> b) -> HsOp -> HsOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsOp -> c HsOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsConOp :: Constr
$cHsVarOp :: Constr
$tHsOp :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsOp -> m HsOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsOp -> m HsOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsOp -> u
gmapQ :: (forall d. Data d => d -> u) -> HsOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsOp -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
gmapT :: (forall b. Data b => b -> b) -> HsOp -> HsOp
$cgmapT :: (forall b. Data b => b -> b) -> HsOp -> HsOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsOp)
dataTypeOf :: HsOp -> DataType
$cdataTypeOf :: HsOp -> DataType
toConstr :: HsOp -> Constr
$ctoConstr :: HsOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsOp -> c HsOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsOp -> c HsOp
$cp1Data :: Typeable 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
/= :: HsCName -> HsCName -> Bool
$c/= :: HsCName -> HsCName -> Bool
== :: HsCName -> HsCName -> Bool
$c== :: 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
min :: HsCName -> HsCName -> HsCName
$cmin :: HsCName -> HsCName -> HsCName
max :: HsCName -> HsCName -> HsCName
$cmax :: HsCName -> HsCName -> HsCName
>= :: HsCName -> HsCName -> Bool
$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
compare :: HsCName -> HsCName -> Ordering
$ccompare :: HsCName -> HsCName -> Ordering
$cp1Ord :: Eq 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
showList :: [HsCName] -> ShowS
$cshowList :: [HsCName] -> ShowS
show :: HsCName -> String
$cshow :: HsCName -> String
showsPrec :: Int -> HsCName -> ShowS
$cshowsPrec :: Int -> HsCName -> ShowS
Show,Typeable,Typeable HsCName
DataType
Constr
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 -> DataType
HsCName -> Constr
(forall b. Data b => b -> b) -> HsCName -> HsCName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsCName -> c HsCName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsConName :: Constr
$cHsVarName :: Constr
$tHsCName :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsCName -> m HsCName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsCName -> m HsCName
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsCName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsCName -> u
gmapQ :: (forall d. Data d => d -> u) -> HsCName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsCName -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsCName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsCName -> r
gmapT :: (forall b. Data b => b -> b) -> HsCName -> HsCName
$cgmapT :: (forall b. Data b => b -> b) -> HsCName -> HsCName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsCName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsCName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsCName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsCName)
dataTypeOf :: HsCName -> DataType
$cdataTypeOf :: HsCName -> DataType
toConstr :: HsCName -> Constr
$ctoConstr :: HsCName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsCName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsCName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsCName -> c HsCName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsCName -> c HsCName
$cp1Data :: Typeable 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 (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
showList :: [HsModule] -> ShowS
$cshowList :: [HsModule] -> ShowS
show :: HsModule -> String
$cshow :: HsModule -> String
showsPrec :: Int -> HsModule -> ShowS
$cshowsPrec :: Int -> HsModule -> ShowS
Show,Typeable,Typeable HsModule
DataType
Constr
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 -> DataType
HsModule -> Constr
(forall b. Data b => b -> b) -> HsModule -> HsModule
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsModule -> c HsModule
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsModule :: Constr
$tHsModule :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsModule -> m HsModule
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsModule -> m HsModule
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsModule -> u
gmapQ :: (forall d. Data d => d -> u) -> HsModule -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsModule -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsModule -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsModule -> r
gmapT :: (forall b. Data b => b -> b) -> HsModule -> HsModule
$cgmapT :: (forall b. Data b => b -> b) -> HsModule -> HsModule
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsModule)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsModule)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsModule)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsModule)
dataTypeOf :: HsModule -> DataType
$cdataTypeOf :: HsModule -> DataType
toConstr :: HsModule -> Constr
$ctoConstr :: HsModule -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsModule
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsModule
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsModule -> c HsModule
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsModule -> c HsModule
$cp1Data :: Typeable HsModule
Data)
#else
  deriving (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
/= :: HsExportSpec -> HsExportSpec -> Bool
$c/= :: HsExportSpec -> HsExportSpec -> Bool
== :: HsExportSpec -> HsExportSpec -> Bool
$c== :: 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
showList :: [HsExportSpec] -> ShowS
$cshowList :: [HsExportSpec] -> ShowS
show :: HsExportSpec -> String
$cshow :: HsExportSpec -> String
showsPrec :: Int -> HsExportSpec -> ShowS
$cshowsPrec :: Int -> HsExportSpec -> ShowS
Show,Typeable,Typeable HsExportSpec
DataType
Constr
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 -> DataType
HsExportSpec -> Constr
(forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsEModuleContents :: Constr
$cHsEThingWith :: Constr
$cHsEThingAll :: Constr
$cHsEAbs :: Constr
$cHsEVar :: Constr
$tHsExportSpec :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u
gmapQ :: (forall d. Data d => d -> u) -> HsExportSpec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsExportSpec -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
gmapT :: (forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec
$cgmapT :: (forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsExportSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsExportSpec)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsExportSpec)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsExportSpec)
dataTypeOf :: HsExportSpec -> DataType
$cdataTypeOf :: HsExportSpec -> DataType
toConstr :: HsExportSpec -> Constr
$ctoConstr :: HsExportSpec -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsExportSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsExportSpec
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec
$cp1Data :: Typeable 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
/= :: HsImportDecl -> HsImportDecl -> Bool
$c/= :: HsImportDecl -> HsImportDecl -> Bool
== :: HsImportDecl -> HsImportDecl -> Bool
$c== :: 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
showList :: [HsImportDecl] -> ShowS
$cshowList :: [HsImportDecl] -> ShowS
show :: HsImportDecl -> String
$cshow :: HsImportDecl -> String
showsPrec :: Int -> HsImportDecl -> ShowS
$cshowsPrec :: Int -> HsImportDecl -> ShowS
Show,Typeable,Typeable HsImportDecl
DataType
Constr
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 -> DataType
HsImportDecl -> Constr
(forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsImportDecl :: Constr
$tHsImportDecl :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u
gmapQ :: (forall d. Data d => d -> u) -> HsImportDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportDecl -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
gmapT :: (forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl
$cgmapT :: (forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsImportDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsImportDecl)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsImportDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsImportDecl)
dataTypeOf :: HsImportDecl -> DataType
$cdataTypeOf :: HsImportDecl -> DataType
toConstr :: HsImportDecl -> Constr
$ctoConstr :: HsImportDecl -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsImportDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsImportDecl
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl
$cp1Data :: Typeable 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
/= :: HsImportSpec -> HsImportSpec -> Bool
$c/= :: HsImportSpec -> HsImportSpec -> Bool
== :: HsImportSpec -> HsImportSpec -> Bool
$c== :: 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
showList :: [HsImportSpec] -> ShowS
$cshowList :: [HsImportSpec] -> ShowS
show :: HsImportSpec -> String
$cshow :: HsImportSpec -> String
showsPrec :: Int -> HsImportSpec -> ShowS
$cshowsPrec :: Int -> HsImportSpec -> ShowS
Show,Typeable,Typeable HsImportSpec
DataType
Constr
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 -> DataType
HsImportSpec -> Constr
(forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsIThingWith :: Constr
$cHsIThingAll :: Constr
$cHsIAbs :: Constr
$cHsIVar :: Constr
$tHsImportSpec :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u
gmapQ :: (forall d. Data d => d -> u) -> HsImportSpec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportSpec -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
gmapT :: (forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec
$cgmapT :: (forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsImportSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsImportSpec)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsImportSpec)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsImportSpec)
dataTypeOf :: HsImportSpec -> DataType
$cdataTypeOf :: HsImportSpec -> DataType
toConstr :: HsImportSpec -> Constr
$ctoConstr :: HsImportSpec -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsImportSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsImportSpec
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec
$cp1Data :: Typeable 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
/= :: HsAssoc -> HsAssoc -> Bool
$c/= :: HsAssoc -> HsAssoc -> Bool
== :: HsAssoc -> HsAssoc -> Bool
$c== :: 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
showList :: [HsAssoc] -> ShowS
$cshowList :: [HsAssoc] -> ShowS
show :: HsAssoc -> String
$cshow :: HsAssoc -> String
showsPrec :: Int -> HsAssoc -> ShowS
$cshowsPrec :: Int -> HsAssoc -> ShowS
Show,Typeable,Typeable HsAssoc
DataType
Constr
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 -> DataType
HsAssoc -> Constr
(forall b. Data b => b -> b) -> HsAssoc -> HsAssoc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsAssoc -> c HsAssoc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsAssocRight :: Constr
$cHsAssocLeft :: Constr
$cHsAssocNone :: Constr
$tHsAssoc :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsAssoc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsAssoc -> u
gmapQ :: (forall d. Data d => d -> u) -> HsAssoc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsAssoc -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
gmapT :: (forall b. Data b => b -> b) -> HsAssoc -> HsAssoc
$cgmapT :: (forall b. Data b => b -> b) -> HsAssoc -> HsAssoc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAssoc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAssoc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsAssoc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsAssoc)
dataTypeOf :: HsAssoc -> DataType
$cdataTypeOf :: HsAssoc -> DataType
toConstr :: HsAssoc -> Constr
$ctoConstr :: HsAssoc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsAssoc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsAssoc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsAssoc -> c HsAssoc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsAssoc -> c HsAssoc
$cp1Data :: Typeable 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
/= :: HsDecl -> HsDecl -> Bool
$c/= :: HsDecl -> HsDecl -> Bool
== :: HsDecl -> HsDecl -> Bool
$c== :: 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
showList :: [HsDecl] -> ShowS
$cshowList :: [HsDecl] -> ShowS
show :: HsDecl -> String
$cshow :: HsDecl -> String
showsPrec :: Int -> HsDecl -> ShowS
$cshowsPrec :: Int -> HsDecl -> ShowS
Show,Typeable,Typeable HsDecl
DataType
Constr
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 -> DataType
HsDecl -> Constr
(forall b. Data b => b -> b) -> HsDecl -> HsDecl
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsDecl -> c HsDecl
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsForeignExport :: Constr
$cHsForeignImport :: Constr
$cHsPatBind :: Constr
$cHsFunBind :: Constr
$cHsTypeSig :: Constr
$cHsDefaultDecl :: Constr
$cHsInstDecl :: Constr
$cHsClassDecl :: Constr
$cHsNewTypeDecl :: Constr
$cHsInfixDecl :: Constr
$cHsDataDecl :: Constr
$cHsTypeDecl :: Constr
$tHsDecl :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsDecl -> u
gmapQ :: (forall d. Data d => d -> u) -> HsDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsDecl -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
gmapT :: (forall b. Data b => b -> b) -> HsDecl -> HsDecl
$cgmapT :: (forall b. Data b => b -> b) -> HsDecl -> HsDecl
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDecl)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsDecl)
dataTypeOf :: HsDecl -> DataType
$cdataTypeOf :: HsDecl -> DataType
toConstr :: HsDecl -> Constr
$ctoConstr :: HsDecl -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsDecl
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsDecl -> c HsDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsDecl -> c HsDecl
$cp1Data :: Typeable 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
/= :: HsMatch -> HsMatch -> Bool
$c/= :: HsMatch -> HsMatch -> Bool
== :: HsMatch -> HsMatch -> Bool
$c== :: 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
showList :: [HsMatch] -> ShowS
$cshowList :: [HsMatch] -> ShowS
show :: HsMatch -> String
$cshow :: HsMatch -> String
showsPrec :: Int -> HsMatch -> ShowS
$cshowsPrec :: Int -> HsMatch -> ShowS
Show,Typeable,Typeable HsMatch
DataType
Constr
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 -> DataType
HsMatch -> Constr
(forall b. Data b => b -> b) -> HsMatch -> HsMatch
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsMatch -> c HsMatch
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsMatch :: Constr
$tHsMatch :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMatch -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsMatch -> u
gmapQ :: (forall d. Data d => d -> u) -> HsMatch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsMatch -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsMatch -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsMatch -> r
gmapT :: (forall b. Data b => b -> b) -> HsMatch -> HsMatch
$cgmapT :: (forall b. Data b => b -> b) -> HsMatch -> HsMatch
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsMatch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsMatch)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsMatch)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsMatch)
dataTypeOf :: HsMatch -> DataType
$cdataTypeOf :: HsMatch -> DataType
toConstr :: HsMatch -> Constr
$ctoConstr :: HsMatch -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsMatch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsMatch
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsMatch -> c HsMatch
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsMatch -> c HsMatch
$cp1Data :: Typeable 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
/= :: HsConDecl -> HsConDecl -> Bool
$c/= :: HsConDecl -> HsConDecl -> Bool
== :: HsConDecl -> HsConDecl -> Bool
$c== :: 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
showList :: [HsConDecl] -> ShowS
$cshowList :: [HsConDecl] -> ShowS
show :: HsConDecl -> String
$cshow :: HsConDecl -> String
showsPrec :: Int -> HsConDecl -> ShowS
$cshowsPrec :: Int -> HsConDecl -> ShowS
Show,Typeable,Typeable HsConDecl
DataType
Constr
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 -> DataType
HsConDecl -> Constr
(forall b. Data b => b -> b) -> HsConDecl -> HsConDecl
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsConDecl -> c HsConDecl
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsRecDecl :: Constr
$cHsConDecl :: Constr
$tHsConDecl :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsConDecl -> u
gmapQ :: (forall d. Data d => d -> u) -> HsConDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsConDecl -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
gmapT :: (forall b. Data b => b -> b) -> HsConDecl -> HsConDecl
$cgmapT :: (forall b. Data b => b -> b) -> HsConDecl -> HsConDecl
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsConDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsConDecl)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsConDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsConDecl)
dataTypeOf :: HsConDecl -> DataType
$cdataTypeOf :: HsConDecl -> DataType
toConstr :: HsConDecl -> Constr
$ctoConstr :: HsConDecl -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsConDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsConDecl
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsConDecl -> c HsConDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsConDecl -> c HsConDecl
$cp1Data :: Typeable 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
/= :: HsBangType -> HsBangType -> Bool
$c/= :: HsBangType -> HsBangType -> Bool
== :: HsBangType -> HsBangType -> Bool
$c== :: 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
showList :: [HsBangType] -> ShowS
$cshowList :: [HsBangType] -> ShowS
show :: HsBangType -> String
$cshow :: HsBangType -> String
showsPrec :: Int -> HsBangType -> ShowS
$cshowsPrec :: Int -> HsBangType -> ShowS
Show,Typeable,Typeable HsBangType
DataType
Constr
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 -> DataType
HsBangType -> Constr
(forall b. Data b => b -> b) -> HsBangType -> HsBangType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsBangType -> c HsBangType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsUnBangedTy :: Constr
$cHsBangedTy :: Constr
$tHsBangType :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBangType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsBangType -> u
gmapQ :: (forall d. Data d => d -> u) -> HsBangType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsBangType -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsBangType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsBangType -> r
gmapT :: (forall b. Data b => b -> b) -> HsBangType -> HsBangType
$cgmapT :: (forall b. Data b => b -> b) -> HsBangType -> HsBangType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsBangType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsBangType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsBangType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsBangType)
dataTypeOf :: HsBangType -> DataType
$cdataTypeOf :: HsBangType -> DataType
toConstr :: HsBangType -> Constr
$ctoConstr :: HsBangType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsBangType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsBangType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsBangType -> c HsBangType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsBangType -> c HsBangType
$cp1Data :: Typeable 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
/= :: HsRhs -> HsRhs -> Bool
$c/= :: HsRhs -> HsRhs -> Bool
== :: HsRhs -> HsRhs -> Bool
$c== :: 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
showList :: [HsRhs] -> ShowS
$cshowList :: [HsRhs] -> ShowS
show :: HsRhs -> String
$cshow :: HsRhs -> String
showsPrec :: Int -> HsRhs -> ShowS
$cshowsPrec :: Int -> HsRhs -> ShowS
Show,Typeable,Typeable HsRhs
DataType
Constr
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 -> DataType
HsRhs -> Constr
(forall b. Data b => b -> b) -> HsRhs -> HsRhs
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsRhs -> c HsRhs
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsGuardedRhss :: Constr
$cHsUnGuardedRhs :: Constr
$tHsRhs :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRhs -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsRhs -> u
gmapQ :: (forall d. Data d => d -> u) -> HsRhs -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsRhs -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
gmapT :: (forall b. Data b => b -> b) -> HsRhs -> HsRhs
$cgmapT :: (forall b. Data b => b -> b) -> HsRhs -> HsRhs
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRhs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRhs)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsRhs)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsRhs)
dataTypeOf :: HsRhs -> DataType
$cdataTypeOf :: HsRhs -> DataType
toConstr :: HsRhs -> Constr
$ctoConstr :: HsRhs -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsRhs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsRhs
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsRhs -> c HsRhs
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsRhs -> c HsRhs
$cp1Data :: Typeable 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
/= :: HsGuardedRhs -> HsGuardedRhs -> Bool
$c/= :: HsGuardedRhs -> HsGuardedRhs -> Bool
== :: HsGuardedRhs -> HsGuardedRhs -> Bool
$c== :: 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
showList :: [HsGuardedRhs] -> ShowS
$cshowList :: [HsGuardedRhs] -> ShowS
show :: HsGuardedRhs -> String
$cshow :: HsGuardedRhs -> String
showsPrec :: Int -> HsGuardedRhs -> ShowS
$cshowsPrec :: Int -> HsGuardedRhs -> ShowS
Show,Typeable,Typeable HsGuardedRhs
DataType
Constr
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 -> DataType
HsGuardedRhs -> Constr
(forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsGuardedRhs :: Constr
$tHsGuardedRhs :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u
gmapQ :: (forall d. Data d => d -> u) -> HsGuardedRhs -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedRhs -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
gmapT :: (forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs
$cgmapT :: (forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsGuardedRhs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsGuardedRhs)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsGuardedRhs)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsGuardedRhs)
dataTypeOf :: HsGuardedRhs -> DataType
$cdataTypeOf :: HsGuardedRhs -> DataType
toConstr :: HsGuardedRhs -> Constr
$ctoConstr :: HsGuardedRhs -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsGuardedRhs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsGuardedRhs
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs
$cp1Data :: Typeable 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
/= :: HsSafety -> HsSafety -> Bool
$c/= :: HsSafety -> HsSafety -> Bool
== :: HsSafety -> HsSafety -> Bool
$c== :: 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
min :: HsSafety -> HsSafety -> HsSafety
$cmin :: HsSafety -> HsSafety -> HsSafety
max :: HsSafety -> HsSafety -> HsSafety
$cmax :: HsSafety -> HsSafety -> HsSafety
>= :: HsSafety -> HsSafety -> Bool
$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
compare :: HsSafety -> HsSafety -> Ordering
$ccompare :: HsSafety -> HsSafety -> Ordering
$cp1Ord :: Eq 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
showList :: [HsSafety] -> ShowS
$cshowList :: [HsSafety] -> ShowS
show :: HsSafety -> String
$cshow :: HsSafety -> String
showsPrec :: Int -> HsSafety -> ShowS
$cshowsPrec :: Int -> HsSafety -> ShowS
Show,Typeable,Typeable HsSafety
DataType
Constr
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 -> DataType
HsSafety -> Constr
(forall b. Data b => b -> b) -> HsSafety -> HsSafety
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsSafety -> c HsSafety
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsUnsafe :: Constr
$cHsSafe :: Constr
$tHsSafety :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSafety -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsSafety -> u
gmapQ :: (forall d. Data d => d -> u) -> HsSafety -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsSafety -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsSafety -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsSafety -> r
gmapT :: (forall b. Data b => b -> b) -> HsSafety -> HsSafety
$cgmapT :: (forall b. Data b => b -> b) -> HsSafety -> HsSafety
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSafety)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSafety)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsSafety)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsSafety)
dataTypeOf :: HsSafety -> DataType
$cdataTypeOf :: HsSafety -> DataType
toConstr :: HsSafety -> Constr
$ctoConstr :: HsSafety -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsSafety
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsSafety
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsSafety -> c HsSafety
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsSafety -> c HsSafety
$cp1Data :: Typeable 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
/= :: HsQualType -> HsQualType -> Bool
$c/= :: HsQualType -> HsQualType -> Bool
== :: HsQualType -> HsQualType -> Bool
$c== :: 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
showList :: [HsQualType] -> ShowS
$cshowList :: [HsQualType] -> ShowS
show :: HsQualType -> String
$cshow :: HsQualType -> String
showsPrec :: Int -> HsQualType -> ShowS
$cshowsPrec :: Int -> HsQualType -> ShowS
Show,Typeable,Typeable HsQualType
DataType
Constr
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 -> DataType
HsQualType -> Constr
(forall b. Data b => b -> b) -> HsQualType -> HsQualType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQualType -> c HsQualType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsQualType :: Constr
$tHsQualType :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQualType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQualType -> u
gmapQ :: (forall d. Data d => d -> u) -> HsQualType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQualType -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsQualType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsQualType -> r
gmapT :: (forall b. Data b => b -> b) -> HsQualType -> HsQualType
$cgmapT :: (forall b. Data b => b -> b) -> HsQualType -> HsQualType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQualType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQualType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsQualType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsQualType)
dataTypeOf :: HsQualType -> DataType
$cdataTypeOf :: HsQualType -> DataType
toConstr :: HsQualType -> Constr
$ctoConstr :: HsQualType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsQualType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsQualType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQualType -> c HsQualType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsQualType -> c HsQualType
$cp1Data :: Typeable 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
/= :: HsType -> HsType -> Bool
$c/= :: HsType -> HsType -> Bool
== :: HsType -> HsType -> Bool
$c== :: 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
showList :: [HsType] -> ShowS
$cshowList :: [HsType] -> ShowS
show :: HsType -> String
$cshow :: HsType -> String
showsPrec :: Int -> HsType -> ShowS
$cshowsPrec :: Int -> HsType -> ShowS
Show,Typeable,Typeable HsType
DataType
Constr
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 -> DataType
HsType -> Constr
(forall b. Data b => b -> b) -> HsType -> HsType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsType -> c HsType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsTyCon :: Constr
$cHsTyVar :: Constr
$cHsTyApp :: Constr
$cHsTyTuple :: Constr
$cHsTyFun :: Constr
$tHsType :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsType -> m HsType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsType -> m HsType
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsType -> u
gmapQ :: (forall d. Data d => d -> u) -> HsType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsType -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
gmapT :: (forall b. Data b => b -> b) -> HsType -> HsType
$cgmapT :: (forall b. Data b => b -> b) -> HsType -> HsType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsType)
dataTypeOf :: HsType -> DataType
$cdataTypeOf :: HsType -> DataType
toConstr :: HsType -> Constr
$ctoConstr :: HsType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsType -> c HsType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsType -> c HsType
$cp1Data :: Typeable 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
/= :: HsLiteral -> HsLiteral -> Bool
$c/= :: HsLiteral -> HsLiteral -> Bool
== :: HsLiteral -> HsLiteral -> Bool
$c== :: 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
showList :: [HsLiteral] -> ShowS
$cshowList :: [HsLiteral] -> ShowS
show :: HsLiteral -> String
$cshow :: HsLiteral -> String
showsPrec :: Int -> HsLiteral -> ShowS
$cshowsPrec :: Int -> HsLiteral -> ShowS
Show,Typeable,Typeable HsLiteral
DataType
Constr
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 -> DataType
HsLiteral -> Constr
(forall b. Data b => b -> b) -> HsLiteral -> HsLiteral
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsLiteral -> c HsLiteral
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsDoublePrim :: Constr
$cHsFloatPrim :: Constr
$cHsIntPrim :: Constr
$cHsStringPrim :: Constr
$cHsCharPrim :: Constr
$cHsFrac :: Constr
$cHsInt :: Constr
$cHsString :: Constr
$cHsChar :: Constr
$tHsLiteral :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsLiteral -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsLiteral -> u
gmapQ :: (forall d. Data d => d -> u) -> HsLiteral -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsLiteral -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
gmapT :: (forall b. Data b => b -> b) -> HsLiteral -> HsLiteral
$cgmapT :: (forall b. Data b => b -> b) -> HsLiteral -> HsLiteral
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLiteral)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLiteral)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsLiteral)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsLiteral)
dataTypeOf :: HsLiteral -> DataType
$cdataTypeOf :: HsLiteral -> DataType
toConstr :: HsLiteral -> Constr
$ctoConstr :: HsLiteral -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsLiteral
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsLiteral
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsLiteral -> c HsLiteral
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsLiteral -> c HsLiteral
$cp1Data :: Typeable 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
/= :: HsExp -> HsExp -> Bool
$c/= :: HsExp -> HsExp -> Bool
== :: HsExp -> HsExp -> Bool
$c== :: 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
showList :: [HsExp] -> ShowS
$cshowList :: [HsExp] -> ShowS
show :: HsExp -> String
$cshow :: HsExp -> String
showsPrec :: Int -> HsExp -> ShowS
$cshowsPrec :: Int -> HsExp -> ShowS
Show,Typeable,Typeable HsExp
DataType
Constr
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 -> DataType
HsExp -> Constr
(forall b. Data b => b -> b) -> HsExp -> HsExp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsExp -> c HsExp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsIrrPat :: Constr
$cHsWildCard :: Constr
$cHsAsPat :: Constr
$cHsExpTypeSig :: Constr
$cHsListComp :: Constr
$cHsEnumFromThenTo :: Constr
$cHsEnumFromThen :: Constr
$cHsEnumFromTo :: Constr
$cHsEnumFrom :: Constr
$cHsRecUpdate :: Constr
$cHsRecConstr :: Constr
$cHsRightSection :: Constr
$cHsLeftSection :: Constr
$cHsParen :: Constr
$cHsList :: Constr
$cHsTuple :: Constr
$cHsDo :: Constr
$cHsCase :: Constr
$cHsIf :: Constr
$cHsLet :: Constr
$cHsLambda :: Constr
$cHsNegApp :: Constr
$cHsApp :: Constr
$cHsInfixApp :: Constr
$cHsLit :: Constr
$cHsCon :: Constr
$cHsVar :: Constr
$tHsExp :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsExp -> m HsExp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsExp -> m HsExp
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsExp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsExp -> u
gmapQ :: (forall d. Data d => d -> u) -> HsExp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsExp -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
gmapT :: (forall b. Data b => b -> b) -> HsExp -> HsExp
$cgmapT :: (forall b. Data b => b -> b) -> HsExp -> HsExp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsExp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsExp)
dataTypeOf :: HsExp -> DataType
$cdataTypeOf :: HsExp -> DataType
toConstr :: HsExp -> Constr
$ctoConstr :: HsExp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsExp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsExp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsExp -> c HsExp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsExp -> c HsExp
$cp1Data :: Typeable 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
/= :: HsPat -> HsPat -> Bool
$c/= :: HsPat -> HsPat -> Bool
== :: HsPat -> HsPat -> Bool
$c== :: 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
showList :: [HsPat] -> ShowS
$cshowList :: [HsPat] -> ShowS
show :: HsPat -> String
$cshow :: HsPat -> String
showsPrec :: Int -> HsPat -> ShowS
$cshowsPrec :: Int -> HsPat -> ShowS
Show,Typeable,Typeable HsPat
DataType
Constr
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 -> DataType
HsPat -> Constr
(forall b. Data b => b -> b) -> HsPat -> HsPat
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsPat -> c HsPat
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsPIrrPat :: Constr
$cHsPWildCard :: Constr
$cHsPAsPat :: Constr
$cHsPRec :: Constr
$cHsPParen :: Constr
$cHsPList :: Constr
$cHsPTuple :: Constr
$cHsPApp :: Constr
$cHsPInfixApp :: Constr
$cHsPNeg :: Constr
$cHsPLit :: Constr
$cHsPVar :: Constr
$tHsPat :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsPat -> m HsPat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsPat -> m HsPat
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsPat -> u
gmapQ :: (forall d. Data d => d -> u) -> HsPat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsPat -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
gmapT :: (forall b. Data b => b -> b) -> HsPat -> HsPat
$cgmapT :: (forall b. Data b => b -> b) -> HsPat -> HsPat
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPat)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsPat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsPat)
dataTypeOf :: HsPat -> DataType
$cdataTypeOf :: HsPat -> DataType
toConstr :: HsPat -> Constr
$ctoConstr :: HsPat -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsPat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsPat
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsPat -> c HsPat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsPat -> c HsPat
$cp1Data :: Typeable 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
/= :: HsPatField -> HsPatField -> Bool
$c/= :: HsPatField -> HsPatField -> Bool
== :: HsPatField -> HsPatField -> Bool
$c== :: 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
showList :: [HsPatField] -> ShowS
$cshowList :: [HsPatField] -> ShowS
show :: HsPatField -> String
$cshow :: HsPatField -> String
showsPrec :: Int -> HsPatField -> ShowS
$cshowsPrec :: Int -> HsPatField -> ShowS
Show,Typeable,Typeable HsPatField
DataType
Constr
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 -> DataType
HsPatField -> Constr
(forall b. Data b => b -> b) -> HsPatField -> HsPatField
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsPatField -> c HsPatField
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsPFieldPat :: Constr
$tHsPatField :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPatField -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsPatField -> u
gmapQ :: (forall d. Data d => d -> u) -> HsPatField -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsPatField -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsPatField -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsPatField -> r
gmapT :: (forall b. Data b => b -> b) -> HsPatField -> HsPatField
$cgmapT :: (forall b. Data b => b -> b) -> HsPatField -> HsPatField
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPatField)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPatField)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsPatField)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsPatField)
dataTypeOf :: HsPatField -> DataType
$cdataTypeOf :: HsPatField -> DataType
toConstr :: HsPatField -> Constr
$ctoConstr :: HsPatField -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsPatField
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsPatField
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsPatField -> c HsPatField
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsPatField -> c HsPatField
$cp1Data :: Typeable 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
/= :: HsStmt -> HsStmt -> Bool
$c/= :: HsStmt -> HsStmt -> Bool
== :: HsStmt -> HsStmt -> Bool
$c== :: 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
showList :: [HsStmt] -> ShowS
$cshowList :: [HsStmt] -> ShowS
show :: HsStmt -> String
$cshow :: HsStmt -> String
showsPrec :: Int -> HsStmt -> ShowS
$cshowsPrec :: Int -> HsStmt -> ShowS
Show,Typeable,Typeable HsStmt
DataType
Constr
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 -> DataType
HsStmt -> Constr
(forall b. Data b => b -> b) -> HsStmt -> HsStmt
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsStmt -> c HsStmt
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsLetStmt :: Constr
$cHsQualifier :: Constr
$cHsGenerator :: Constr
$tHsStmt :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsStmt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsStmt -> u
gmapQ :: (forall d. Data d => d -> u) -> HsStmt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsStmt -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
gmapT :: (forall b. Data b => b -> b) -> HsStmt -> HsStmt
$cgmapT :: (forall b. Data b => b -> b) -> HsStmt -> HsStmt
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsStmt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsStmt)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsStmt)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsStmt)
dataTypeOf :: HsStmt -> DataType
$cdataTypeOf :: HsStmt -> DataType
toConstr :: HsStmt -> Constr
$ctoConstr :: HsStmt -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsStmt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsStmt
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsStmt -> c HsStmt
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsStmt -> c HsStmt
$cp1Data :: Typeable 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
/= :: HsFieldUpdate -> HsFieldUpdate -> Bool
$c/= :: HsFieldUpdate -> HsFieldUpdate -> Bool
== :: HsFieldUpdate -> HsFieldUpdate -> Bool
$c== :: 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
showList :: [HsFieldUpdate] -> ShowS
$cshowList :: [HsFieldUpdate] -> ShowS
show :: HsFieldUpdate -> String
$cshow :: HsFieldUpdate -> String
showsPrec :: Int -> HsFieldUpdate -> ShowS
$cshowsPrec :: Int -> HsFieldUpdate -> ShowS
Show,Typeable,Typeable HsFieldUpdate
DataType
Constr
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 -> DataType
HsFieldUpdate -> Constr
(forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsFieldUpdate :: Constr
$tHsFieldUpdate :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u
gmapQ :: (forall d. Data d => d -> u) -> HsFieldUpdate -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsFieldUpdate -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
gmapT :: (forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate
$cgmapT :: (forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsFieldUpdate)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsFieldUpdate)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsFieldUpdate)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsFieldUpdate)
dataTypeOf :: HsFieldUpdate -> DataType
$cdataTypeOf :: HsFieldUpdate -> DataType
toConstr :: HsFieldUpdate -> Constr
$ctoConstr :: HsFieldUpdate -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsFieldUpdate
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsFieldUpdate
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate
$cp1Data :: Typeable 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
/= :: HsAlt -> HsAlt -> Bool
$c/= :: HsAlt -> HsAlt -> Bool
== :: HsAlt -> HsAlt -> Bool
$c== :: 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
showList :: [HsAlt] -> ShowS
$cshowList :: [HsAlt] -> ShowS
show :: HsAlt -> String
$cshow :: HsAlt -> String
showsPrec :: Int -> HsAlt -> ShowS
$cshowsPrec :: Int -> HsAlt -> ShowS
Show,Typeable,Typeable HsAlt
DataType
Constr
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 -> DataType
HsAlt -> Constr
(forall b. Data b => b -> b) -> HsAlt -> HsAlt
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsAlt -> c HsAlt
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsAlt :: Constr
$tHsAlt :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsAlt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsAlt -> u
gmapQ :: (forall d. Data d => d -> u) -> HsAlt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsAlt -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
gmapT :: (forall b. Data b => b -> b) -> HsAlt -> HsAlt
$cgmapT :: (forall b. Data b => b -> b) -> HsAlt -> HsAlt
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAlt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAlt)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsAlt)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsAlt)
dataTypeOf :: HsAlt -> DataType
$cdataTypeOf :: HsAlt -> DataType
toConstr :: HsAlt -> Constr
$ctoConstr :: HsAlt -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsAlt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsAlt
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsAlt -> c HsAlt
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsAlt -> c HsAlt
$cp1Data :: Typeable 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
/= :: HsGuardedAlts -> HsGuardedAlts -> Bool
$c/= :: HsGuardedAlts -> HsGuardedAlts -> Bool
== :: HsGuardedAlts -> HsGuardedAlts -> Bool
$c== :: 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
showList :: [HsGuardedAlts] -> ShowS
$cshowList :: [HsGuardedAlts] -> ShowS
show :: HsGuardedAlts -> String
$cshow :: HsGuardedAlts -> String
showsPrec :: Int -> HsGuardedAlts -> ShowS
$cshowsPrec :: Int -> HsGuardedAlts -> ShowS
Show,Typeable,Typeable HsGuardedAlts
DataType
Constr
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 -> DataType
HsGuardedAlts -> Constr
(forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsGuardedAlts :: Constr
$cHsUnGuardedAlt :: Constr
$tHsGuardedAlts :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u
gmapQ :: (forall d. Data d => d -> u) -> HsGuardedAlts -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlts -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
gmapT :: (forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts
$cgmapT :: (forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsGuardedAlts)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsGuardedAlts)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlts)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlts)
dataTypeOf :: HsGuardedAlts -> DataType
$cdataTypeOf :: HsGuardedAlts -> DataType
toConstr :: HsGuardedAlts -> Constr
$ctoConstr :: HsGuardedAlts -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsGuardedAlts
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsGuardedAlts
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts
$cp1Data :: Typeable 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
/= :: HsGuardedAlt -> HsGuardedAlt -> Bool
$c/= :: HsGuardedAlt -> HsGuardedAlt -> Bool
== :: HsGuardedAlt -> HsGuardedAlt -> Bool
$c== :: 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
showList :: [HsGuardedAlt] -> ShowS
$cshowList :: [HsGuardedAlt] -> ShowS
show :: HsGuardedAlt -> String
$cshow :: HsGuardedAlt -> String
showsPrec :: Int -> HsGuardedAlt -> ShowS
$cshowsPrec :: Int -> HsGuardedAlt -> ShowS
Show,Typeable,Typeable HsGuardedAlt
DataType
Constr
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 -> DataType
HsGuardedAlt -> Constr
(forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cHsGuardedAlt :: Constr
$tHsGuardedAlt :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u
gmapQ :: (forall d. Data d => d -> u) -> HsGuardedAlt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlt -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
gmapT :: (forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt
$cgmapT :: (forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsGuardedAlt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsGuardedAlt)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlt)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlt)
dataTypeOf :: HsGuardedAlt -> DataType
$cdataTypeOf :: HsGuardedAlt -> DataType
toConstr :: HsGuardedAlt -> Constr
$ctoConstr :: HsGuardedAlt -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsGuardedAlt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsGuardedAlt
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt
$cp1Data :: Typeable HsGuardedAlt
Data)
#else
  deriving (Eq,Show)
#endif

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

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

main_name :: HsName
main_name :: HsName
main_name             = String -> HsName
HsIdent "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 i :: Int
i      = HsSpecialCon -> HsQName
Special (Int -> HsSpecialCon
HsTupleCon (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+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 i :: 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 i :: 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 i :: Int
i         = HsQName -> HsType
HsTyCon (Int -> HsQName
tuple_tycon_name Int
i)