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

-----------------------------------------------------------------------------
-- |
-- Module      :  Language.Haskell.Syntax
-- Copyright   :  (c) The GHC Team, 1997-2000
-- License     :  BSD-3-Clause
--
-- Maintainer  :  Andreas Abel
-- Stability   :  stable
-- Portability :  portable
--
-- A suite of datatypes describing the abstract syntax of
-- <http://www.haskell.org/onlinereport/ Haskell 98> plus a few extensions:
--
--   * multi-parameter type classes
--
--   * parameters of type class assertions are unrestricted
--
-- For GHC, we also derive '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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> SrcLoc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SrcLoc -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SrcLoc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SrcLoc -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsSpecialCon -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsSpecialCon -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQName -> m HsQName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQName -> m HsQName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQName -> m HsQName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQName -> m HsQName
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsQName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQName -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsQName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQName -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsQName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsQName -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsName -> m HsName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsName -> m HsName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsName -> m HsName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsName -> m HsName
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsName -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsName -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQOp -> m HsQOp
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsQOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsQOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsOp -> m HsOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsOp -> m HsOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsOp -> m HsOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsOp -> m HsOp
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsCName -> m HsCName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsCName -> m HsCName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsCName -> m HsCName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsCName -> m HsCName
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsCName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsCName -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsCName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsCName -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsCName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsCName -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data)
#else
  deriving (Eq,Ord,Show)
#endif

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

-- | Export specification.
data HsExportSpec
         = HsEVar HsQName                       -- ^ Variable.
         | HsEAbs HsQName                       -- ^ @T@:
                        -- A class or datatype exported abstractly,
                        -- or a type synonym.
         | HsEThingAll HsQName                  -- ^ @T(..)@:
                        -- A class exported with all of its methods, or
                        -- a datatype exported with all of its constructors.
         | HsEThingWith HsQName [HsCName]       -- ^ @T(C_1,...,C_n)@:
                        -- A class exported with some of its methods, or
                        -- a datatype exported with some of its constructors.
         | HsEModuleContents Module             -- ^ @module M@:
                        -- Re-export a module.
#ifdef __GLASGOW_HASKELL__
  deriving (HsExportSpec -> HsExportSpec -> Bool
(HsExportSpec -> HsExportSpec -> Bool)
-> (HsExportSpec -> HsExportSpec -> Bool) -> Eq HsExportSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: 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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsExportSpec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsExportSpec -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportSpec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsImportSpec -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsAssoc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsAssoc -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsAssoc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsAssoc -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsAssoc -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsDecl -> m HsDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsMatch -> m HsMatch
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsMatch -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsMatch -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsMatch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsMatch -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsMatch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsMatch -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsConDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsConDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsConDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsConDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsConDecl -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsBangType -> m HsBangType
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsBangType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsBangType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsBangType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsBangType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsBangType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsBangType -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsRhs -> m HsRhs
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsRhs -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsRhs -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsRhs -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsRhs -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedRhs -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedRhs -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsSafety -> m HsSafety
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsSafety -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsSafety -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsSafety -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsSafety -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsSafety -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsSafety -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsQualType -> m HsQualType
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsQualType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsQualType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsQualType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsQualType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsQualType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsQualType -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsType -> m HsType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsType -> m HsType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsType -> m HsType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsType -> m HsType
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsLiteral -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsLiteral -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsLiteral -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsLiteral -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsLiteral -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsExp -> m HsExp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsExp -> m HsExp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsExp -> m HsExp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsExp -> m HsExp
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsExp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsExp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsExp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsExp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsPat -> m HsPat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsPat -> m HsPat
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsPat -> m HsPat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsPat -> m HsPat
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsPat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsPat -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsPat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsPat -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsPatField -> m HsPatField
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsPatField -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsPatField -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsPatField -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsPatField -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsPatField -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsPatField -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsStmt -> m HsStmt
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsStmt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsStmt -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsStmt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsStmt -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsFieldUpdate -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsFieldUpdate -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsAlt -> m HsAlt
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsAlt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsAlt -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsAlt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsAlt -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlts -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlts -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsGuardedAlt -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data)
#else
  deriving (Eq,Show)
#endif

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

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

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

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

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

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

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

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

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

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

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

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