ghc-8.0.1: The GHC API

Safe HaskellNone
LanguageHaskell2010

HsBinds

Synopsis

Documentation

data HsLocalBindsLR idL idR Source #

Bindings in a 'let' expression or a 'where' clause

Instances

(DataId idL, DataId idR) => Data (HsLocalBindsLR idL idR) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsLocalBindsLR idL idR -> c (HsLocalBindsLR idL idR) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsLocalBindsLR idL idR) Source #

toConstr :: HsLocalBindsLR idL idR -> Constr Source #

dataTypeOf :: HsLocalBindsLR idL idR -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsLocalBindsLR idL idR)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsLocalBindsLR idL idR)) Source #

gmapT :: (forall b. Data b => b -> b) -> HsLocalBindsLR idL idR -> HsLocalBindsLR idL idR Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsLocalBindsLR idL idR -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsLocalBindsLR idL idR -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsLocalBindsLR idL idR -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsLocalBindsLR idL idR -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsLocalBindsLR idL idR -> m (HsLocalBindsLR idL idR) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsLocalBindsLR idL idR -> m (HsLocalBindsLR idL idR) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsLocalBindsLR idL idR -> m (HsLocalBindsLR idL idR) Source #

(OutputableBndr idL, OutputableBndr idR) => Outputable (HsLocalBindsLR idL idR) # 

Methods

ppr :: HsLocalBindsLR idL idR -> SDoc Source #

pprPrec :: Rational -> HsLocalBindsLR idL idR -> SDoc Source #

data HsValBindsLR idL idR Source #

Value bindings (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindings

Constructors

ValBindsIn (LHsBindsLR idL idR) [LSig idR]

Before renaming RHS; idR is always RdrName Not dependency analysed Recursive by default

ValBindsOut [(RecFlag, LHsBinds idL)] [LSig Name]

After renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones.

Instances

(DataId idL, DataId idR) => Data (HsValBindsLR idL idR) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsValBindsLR idL idR -> c (HsValBindsLR idL idR) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsValBindsLR idL idR) Source #

toConstr :: HsValBindsLR idL idR -> Constr Source #

dataTypeOf :: HsValBindsLR idL idR -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsValBindsLR idL idR)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsValBindsLR idL idR)) Source #

gmapT :: (forall b. Data b => b -> b) -> HsValBindsLR idL idR -> HsValBindsLR idL idR Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsValBindsLR idL idR -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsValBindsLR idL idR -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsValBindsLR idL idR -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsValBindsLR idL idR -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsValBindsLR idL idR -> m (HsValBindsLR idL idR) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsValBindsLR idL idR -> m (HsValBindsLR idL idR) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsValBindsLR idL idR -> m (HsValBindsLR idL idR) Source #

(OutputableBndr idL, OutputableBndr idR) => Outputable (HsValBindsLR idL idR) # 

Methods

ppr :: HsValBindsLR idL idR -> SDoc Source #

pprPrec :: Rational -> HsValBindsLR idL idR -> SDoc Source #

type LHsBind id = LHsBindLR id id Source #

type LHsBinds id = LHsBindsLR id id Source #

type HsBind id = HsBindLR id id Source #

type LHsBindsLR idL idR = Bag (LHsBindLR idL idR) Source #

type LHsBindLR idL idR = Located (HsBindLR idL idR) Source #

data HsBindLR idL idR Source #

Constructors

FunBind

FunBind is used for both functions f x = e and variables f = x -> e

Reason 1: Special case for type inference: see tcMonoBinds.

Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds

But note that the form f :: a->a = ... parses as a pattern binding, just like (f :: a -> a) = ...

AnnKeywordIds

Fields

  • fun_id :: Located idL
     
  • fun_matches :: MatchGroup idR (LHsExpr idR)

    The payload

  • fun_co_fn :: HsWrapper

    Coercion from the type of the MatchGroup to the type of the Id. Example:

         f :: Int -> forall a. a -> a
         f x y = y
    

    Then the MatchGroup will have type (Int -> a' -> a') (with a free type variable a'). The coercion will take a CoreExpr of this type and convert it to a CoreExpr of type Int -> forall a'. a' -> a' Notice that the coercion captures the free a'.

  • bind_fvs :: PostRn idL NameSet

    After the renamer, this contains the locally-bound free variables of this defn. See Note [Bind free vars]

  • fun_tick :: [Tickish Id]

    Ticks to put on the rhs, if any

PatBind

The pattern is never a simple variable; That case is done by FunBind

Fields

VarBind

Dictionary binding and suchlike. All VarBinds are introduced by the type checker

Fields

AbsBinds 

Fields

AbsBindsSig 

Fields

PatSynBind (PatSynBind idL idR)

Instances

(DataId idL, DataId idR) => Data (HsBindLR idL idR) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBindLR idL idR -> c (HsBindLR idL idR) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBindLR idL idR) Source #

toConstr :: HsBindLR idL idR -> Constr Source #

dataTypeOf :: HsBindLR idL idR -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsBindLR idL idR)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsBindLR idL idR)) Source #

gmapT :: (forall b. Data b => b -> b) -> HsBindLR idL idR -> HsBindLR idL idR Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBindLR idL idR -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBindLR idL idR -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsBindLR idL idR -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBindLR idL idR -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBindLR idL idR -> m (HsBindLR idL idR) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBindLR idL idR -> m (HsBindLR idL idR) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBindLR idL idR -> m (HsBindLR idL idR) Source #

(OutputableBndr idL, OutputableBndr idR) => Outputable (HsBindLR idL idR) # 

Methods

ppr :: HsBindLR idL idR -> SDoc Source #

pprPrec :: Rational -> HsBindLR idL idR -> SDoc Source #

data ABExport id Source #

Constructors

ABE 

Fields

Instances

Data id => Data (ABExport id) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ABExport id -> c (ABExport id) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ABExport id) Source #

toConstr :: ABExport id -> Constr Source #

dataTypeOf :: ABExport id -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ABExport id)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ABExport id)) Source #

gmapT :: (forall b. Data b => b -> b) -> ABExport id -> ABExport id Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ABExport id -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ABExport id -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ABExport id -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ABExport id -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ABExport id -> m (ABExport id) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ABExport id -> m (ABExport id) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ABExport id -> m (ABExport id) Source #

OutputableBndr id => Outputable (ABExport id) # 

data PatSynBind idL idR Source #

Constructors

PSB 

Fields

Instances

(DataId idL, DataId idR) => Data (PatSynBind idL idR) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynBind idL idR -> c (PatSynBind idL idR) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PatSynBind idL idR) Source #

toConstr :: PatSynBind idL idR -> Constr Source #

dataTypeOf :: PatSynBind idL idR -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (PatSynBind idL idR)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PatSynBind idL idR)) Source #

gmapT :: (forall b. Data b => b -> b) -> PatSynBind idL idR -> PatSynBind idL idR Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynBind idL idR -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynBind idL idR -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> PatSynBind idL idR -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynBind idL idR -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynBind idL idR -> m (PatSynBind idL idR) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynBind idL idR -> m (PatSynBind idL idR) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynBind idL idR -> m (PatSynBind idL idR) Source #

(OutputableBndr idL, OutputableBndr idR) => Outputable (PatSynBind idL idR) # 

Methods

ppr :: PatSynBind idL idR -> SDoc Source #

pprPrec :: Rational -> PatSynBind idL idR -> SDoc Source #

data HsIPBinds id Source #

Constructors

IPBinds [LIPBind id] TcEvBinds 

Instances

DataId id => Data (HsIPBinds id) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsIPBinds id -> c (HsIPBinds id) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsIPBinds id) Source #

toConstr :: HsIPBinds id -> Constr Source #

dataTypeOf :: HsIPBinds id -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsIPBinds id)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsIPBinds id)) Source #

gmapT :: (forall b. Data b => b -> b) -> HsIPBinds id -> HsIPBinds id Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsIPBinds id -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsIPBinds id -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsIPBinds id -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsIPBinds id -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsIPBinds id -> m (HsIPBinds id) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPBinds id -> m (HsIPBinds id) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPBinds id -> m (HsIPBinds id) Source #

OutputableBndr id => Outputable (HsIPBinds id) # 

type LIPBind id = Located (IPBind id) Source #

May have AnnKeywordId : AnnSemi when in a list

data IPBind id Source #

Implicit parameter bindings.

These bindings start off as (Left "x") in the parser and stay that way until after type-checking when they are replaced with (Right d), where "d" is the name of the dictionary holding the evidence for the implicit parameter.

Constructors

IPBind (Either (Located HsIPName) id) (LHsExpr id) 

Instances

DataId name => Data (IPBind name) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPBind name -> c (IPBind name) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IPBind name) Source #

toConstr :: IPBind name -> Constr Source #

dataTypeOf :: IPBind name -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (IPBind name)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind name)) Source #

gmapT :: (forall b. Data b => b -> b) -> IPBind name -> IPBind name Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPBind name -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPBind name -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> IPBind name -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IPBind name -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPBind name -> m (IPBind name) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBind name -> m (IPBind name) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBind name -> m (IPBind name) Source #

OutputableBndr id => Outputable (IPBind id) # 

Methods

ppr :: IPBind id -> SDoc Source #

pprPrec :: Rational -> IPBind id -> SDoc Source #

type LSig name = Located (Sig name) Source #

data Sig name Source #

Signatures and pragmas

Constructors

TypeSig [Located name] (LHsSigWcType name)

An ordinary type signature

f :: Num a => a -> a

After renaming, this list of Names contains the named and unnamed wildcards brought into scope by this signature. For a signature _ -> _a -> Bool, the renamer will give the unnamed wildcard _ a freshly generated name, e.g. _w. _w and the named wildcard _a are then both replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific.

PatSynSig (Located name) (LHsSigType name)

A pattern synonym type signature

pattern Single :: () => (Show a) => a -> [a]
ClassOpSig Bool [Located name] (LHsSigType name)

A signature for a class method False: ordinary class-method signature True: default class method signature e.g. class C a where op :: a -> a -- Ordinary default op :: Eq a => a -> a -- Generic default No wildcards allowed here

IdSig Id

A type signature in generated code, notably the code generated for record selectors. We simply record the desired Id itself, replete with its name, type and IdDetails. Otherwise it's just like a type signature: there should be an accompanying binding

FixSig (FixitySig name)

An ordinary fixity declaration

    infixl 8 ***
InlineSig (Located name) InlinePragma

An inline pragma

{#- INLINE f #-}
SpecSig (Located name) [LHsSigType name] InlinePragma

A specialisation pragma

{-# SPECIALISE f :: Int -> Int #-}
SpecInstSig SourceText (LHsSigType name)

A specialisation pragma for instance declarations only

{-# SPECIALISE instance Eq [Int] #-}

(Class tys); should be a specialisation of the current instance declaration

MinimalSig SourceText (LBooleanFormula (Located name))

A minimal complete definition pragma

{-# MINIMAL a | (b, c | (d | e)) #-}

Instances

DataId name => Data (Sig name) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sig name -> c (Sig name) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sig name) Source #

toConstr :: Sig name -> Constr Source #

dataTypeOf :: Sig name -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Sig name)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sig name)) Source #

gmapT :: (forall b. Data b => b -> b) -> Sig name -> Sig name Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sig name -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sig name -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Sig name -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sig name -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sig name -> m (Sig name) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sig name -> m (Sig name) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sig name -> m (Sig name) Source #

OutputableBndr name => Outputable (Sig name) # 

Methods

ppr :: Sig name -> SDoc Source #

pprPrec :: Rational -> Sig name -> SDoc Source #

type LFixitySig name = Located (FixitySig name) Source #

data FixitySig name Source #

Constructors

FixitySig [Located name] Fixity 

Instances

Data name => Data (FixitySig name) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixitySig name -> c (FixitySig name) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FixitySig name) Source #

toConstr :: FixitySig name -> Constr Source #

dataTypeOf :: FixitySig name -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FixitySig name)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FixitySig name)) Source #

gmapT :: (forall b. Data b => b -> b) -> FixitySig name -> FixitySig name Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixitySig name -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixitySig name -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> FixitySig name -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FixitySig name -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixitySig name -> m (FixitySig name) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixitySig name -> m (FixitySig name) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixitySig name -> m (FixitySig name) Source #

OutputableBndr name => Outputable (FixitySig name) # 

Methods

ppr :: FixitySig name -> SDoc Source #

pprPrec :: Rational -> FixitySig name -> SDoc Source #

data TcSpecPrags Source #

TsSpecPrags conveys pragmas from the type checker to the desugarer

Constructors

IsDefaultMethod

Super-specialised: a default method should be macro-expanded at every call site

SpecPrags [LTcSpecPrag] 

Instances

Data TcSpecPrags # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TcSpecPrags -> c TcSpecPrags Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TcSpecPrags Source #

toConstr :: TcSpecPrags -> Constr Source #

dataTypeOf :: TcSpecPrags -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TcSpecPrags) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TcSpecPrags) Source #

gmapT :: (forall b. Data b => b -> b) -> TcSpecPrags -> TcSpecPrags Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TcSpecPrags -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TcSpecPrags -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> TcSpecPrags -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TcSpecPrags -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TcSpecPrags -> m TcSpecPrags Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TcSpecPrags -> m TcSpecPrags Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TcSpecPrags -> m TcSpecPrags Source #

data TcSpecPrag Source #

Constructors

SpecPrag Id HsWrapper InlinePragma

The Id to be specialised, an wrapper that specialises the polymorphic function, and inlining spec for the specialised function

Instances

Data TcSpecPrag # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TcSpecPrag -> c TcSpecPrag Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TcSpecPrag Source #

toConstr :: TcSpecPrag -> Constr Source #

dataTypeOf :: TcSpecPrag -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TcSpecPrag) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TcSpecPrag) Source #

gmapT :: (forall b. Data b => b -> b) -> TcSpecPrag -> TcSpecPrag Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TcSpecPrag -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TcSpecPrag -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> TcSpecPrag -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TcSpecPrag -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TcSpecPrag -> m TcSpecPrag Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TcSpecPrag -> m TcSpecPrag Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TcSpecPrag -> m TcSpecPrag Source #

Outputable TcSpecPrag # 

hsSigDoc :: Sig name -> SDoc Source #

ppr_sig :: OutputableBndr name => Sig name -> SDoc Source #

data HsPatSynDetails a Source #

Instances

Functor HsPatSynDetails # 
Foldable HsPatSynDetails # 

Methods

fold :: Monoid m => HsPatSynDetails m -> m Source #

foldMap :: Monoid m => (a -> m) -> HsPatSynDetails a -> m Source #

foldr :: (a -> b -> b) -> b -> HsPatSynDetails a -> b Source #

foldr' :: (a -> b -> b) -> b -> HsPatSynDetails a -> b Source #

foldl :: (b -> a -> b) -> b -> HsPatSynDetails a -> b Source #

foldl' :: (b -> a -> b) -> b -> HsPatSynDetails a -> b Source #

foldr1 :: (a -> a -> a) -> HsPatSynDetails a -> a Source #

foldl1 :: (a -> a -> a) -> HsPatSynDetails a -> a Source #

toList :: HsPatSynDetails a -> [a] Source #

null :: HsPatSynDetails a -> Bool Source #

length :: HsPatSynDetails a -> Int Source #

elem :: Eq a => a -> HsPatSynDetails a -> Bool Source #

maximum :: Ord a => HsPatSynDetails a -> a Source #

minimum :: Ord a => HsPatSynDetails a -> a Source #

sum :: Num a => HsPatSynDetails a -> a Source #

product :: Num a => HsPatSynDetails a -> a Source #

Traversable HsPatSynDetails # 
Data a => Data (HsPatSynDetails a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPatSynDetails a -> c (HsPatSynDetails a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsPatSynDetails a) Source #

toConstr :: HsPatSynDetails a -> Constr Source #

dataTypeOf :: HsPatSynDetails a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsPatSynDetails a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsPatSynDetails a)) Source #

gmapT :: (forall b. Data b => b -> b) -> HsPatSynDetails a -> HsPatSynDetails a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSynDetails a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSynDetails a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsPatSynDetails a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPatSynDetails a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPatSynDetails a -> m (HsPatSynDetails a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSynDetails a -> m (HsPatSynDetails a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSynDetails a -> m (HsPatSynDetails a) Source #

data RecordPatSynField a Source #

Instances

Functor RecordPatSynField # 
Foldable RecordPatSynField # 

Methods

fold :: Monoid m => RecordPatSynField m -> m Source #

foldMap :: Monoid m => (a -> m) -> RecordPatSynField a -> m Source #

foldr :: (a -> b -> b) -> b -> RecordPatSynField a -> b Source #

foldr' :: (a -> b -> b) -> b -> RecordPatSynField a -> b Source #

foldl :: (b -> a -> b) -> b -> RecordPatSynField a -> b Source #

foldl' :: (b -> a -> b) -> b -> RecordPatSynField a -> b Source #

foldr1 :: (a -> a -> a) -> RecordPatSynField a -> a Source #

foldl1 :: (a -> a -> a) -> RecordPatSynField a -> a Source #

toList :: RecordPatSynField a -> [a] Source #

null :: RecordPatSynField a -> Bool Source #

length :: RecordPatSynField a -> Int Source #

elem :: Eq a => a -> RecordPatSynField a -> Bool Source #

maximum :: Ord a => RecordPatSynField a -> a Source #

minimum :: Ord a => RecordPatSynField a -> a Source #

sum :: Num a => RecordPatSynField a -> a Source #

product :: Num a => RecordPatSynField a -> a Source #

Traversable RecordPatSynField # 
Data a => Data (RecordPatSynField a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RecordPatSynField a -> c (RecordPatSynField a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RecordPatSynField a) Source #

toConstr :: RecordPatSynField a -> Constr Source #

dataTypeOf :: RecordPatSynField a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (RecordPatSynField a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RecordPatSynField a)) Source #

gmapT :: (forall b. Data b => b -> b) -> RecordPatSynField a -> RecordPatSynField a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RecordPatSynField a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RecordPatSynField a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> RecordPatSynField a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RecordPatSynField a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) Source #

Outputable a => Outputable (RecordPatSynField a) # 

data HsPatSynDir id Source #

Instances

DataId id => Data (HsPatSynDir id) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPatSynDir id -> c (HsPatSynDir id) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsPatSynDir id) Source #

toConstr :: HsPatSynDir id -> Constr Source #

dataTypeOf :: HsPatSynDir id -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HsPatSynDir id)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsPatSynDir id)) Source #

gmapT :: (forall b. Data b => b -> b) -> HsPatSynDir id -> HsPatSynDir id Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSynDir id -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSynDir id -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsPatSynDir id -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPatSynDir id -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPatSynDir id -> m (HsPatSynDir id) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSynDir id -> m (HsPatSynDir id) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSynDir id -> m (HsPatSynDir id) Source #