HsBinds

Documentation

type HsLocalBinds id = HsLocalBindsLR id id

Haskell Local Bindings

type LHsLocalBinds id = Located (HsLocalBinds id)

Located Haskell local bindings

data HsLocalBindsLR idL idR

Haskell Local Bindings with separate Left and Right identifier types

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

Constructors

HsValBinds (HsValBindsLR idL idR)

Haskell Value Bindings

HsIPBinds (HsIPBinds idR)

Haskell Implicit Parameter Bindings

EmptyLocalBinds

Empty Local Bindings

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)

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

toConstr :: HsLocalBindsLR idL idR -> Constr

dataTypeOf :: HsLocalBindsLR idL idR -> DataType

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

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

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

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

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

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

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

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

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

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

(OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsLocalBindsLR idL idR)

Methods

ppr :: HsLocalBindsLR idL idR -> SDoc

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

type LHsLocalBindsLR idL idR = Located (HsLocalBindsLR idL idR)

type HsValBinds id = HsValBindsLR id id

Haskell Value Bindings

data HsValBindsLR idL idR

Haskell Value bindings with separate Left and Right identifier types (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindings

Constructors

ValBindsIn (LHsBindsLR idL idR) [LSig idR]

Value Bindings In

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

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

Value Bindings Out

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)

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

toConstr :: HsValBindsLR idL idR -> Constr

dataTypeOf :: HsValBindsLR idL idR -> DataType

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

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

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

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

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

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

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

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

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

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

(OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsValBindsLR idL idR)

Methods

ppr :: HsValBindsLR idL idR -> SDoc

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

type LHsBind id = LHsBindLR id id

Located Haskell Binding

type LHsBinds id = LHsBindsLR id id

Located Haskell Bindings

type HsBind id = HsBindLR id id

Haskell Binding

type LHsBindsLR idL idR = Bag (LHsBindLR idL idR)

Located Haskell Bindings with separate Left and Right identifier types

type LHsBindLR idL idR = Located (HsBindLR idL idR)

Located Haskell Binding with separate Left and Right identifier types

data HsBindLR idL idR

Haskell Binding with separate Left and Right id's

Constructors

FunBind

Function-like Binding

FunBind is used for both functions f x = e and variables f = x -> e and strict variables !x = x + 1

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) = ...

Strict bindings have their strictness recorded in the SrcStrictness of their MatchContext. See Note [Varieties of binding pattern matches] for details about the relationship between FunBind and PatBind.

AnnKeywordIds

• AnnFunId, attached to each element of fun_matches
• AnnEqual,AnnWhere, AnnOpen,AnnClose,

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

Pattern Binding

The pattern is never a simple variable; That case is done by FunBind. See Note [Varieties of binding pattern matches] for details about the relationship between FunBind and PatBind.

Fields

• pat_lhs :: LPat idL
• pat_rhs :: GRHSs idR (LHsExpr idR)
• pat_rhs_ty :: PostTc idR Type

  Type of the GRHSs

• bind_fvs :: PostRn idL NameSet

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

• pat_ticks :: ([Tickish Id], [[Tickish Id]])

  Ticks to put on the rhs, if any, and ticks to put on the bound variables.

VarBind

Variable Binding

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

Fields

• var_id :: idL
• var_rhs :: LHsExpr idR

  Located only for consistency

• var_inline :: Bool

  True = inline this binding regardless (used for implication constraints only)

AbsBinds

Abstraction Bindings

Fields

• abs_tvs :: [TyVar]
• abs_ev_vars :: [EvVar]

  Includes equality constraints

• abs_exports :: [ABExport idL]

  AbsBinds only gets used when idL = idR after renaming, but these need to be idL's for the collect... code in HsUtil to have the right type

• abs_ev_binds :: [TcEvBinds]

  Evidence bindings Why a list? See TcInstDcls Note [Typechecking plan for instance declarations]

• abs_binds :: LHsBinds idL

  Typechecked user bindings

AbsBindsSig

Abstraction Bindings Signature

Fields

• abs_tvs :: [TyVar]
• abs_ev_vars :: [EvVar]

  Includes equality constraints

• abs_sig_export :: idL
• abs_sig_prags :: TcSpecPrags
• abs_sig_ev_bind :: TcEvBinds
• abs_sig_bind :: LHsBind idL

PatSynBind (PatSynBind idL idR)

• AnnKeywordId : AnnPattern, AnnLarrow,AnnEqual, AnnWhere AnnOpen '{',AnnClose '}'

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)

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

toConstr :: HsBindLR idL idR -> Constr

dataTypeOf :: HsBindLR idL idR -> DataType

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

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

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

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

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

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

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

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

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

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

(OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsBindLR idL idR)

Methods

ppr :: HsBindLR idL idR -> SDoc

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

data ABExport id

Abtraction Bindings Export

Constructors

ABE

Fields

• abe_poly :: id

  Any INLINE pragmas is attached to this Id

• abe_mono :: id
• abe_wrap :: HsWrapper

  See Note [ABExport wrapper] Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_poly

• abe_prags :: TcSpecPrags

  SPECIALISE pragmas

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)

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

toConstr :: ABExport id -> Constr

dataTypeOf :: ABExport id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr id => Outputable (ABExport id)

Methods

ppr :: ABExport id -> SDoc

pprPrec :: Rational -> ABExport id -> SDoc

data PatSynBind idL idR

• AnnKeywordId : AnnPattern, AnnEqual,AnnLarrow AnnWhere,AnnOpen '{', AnnClose '}',

Pattern Synonym binding

Constructors

PSB

Fields

• psb_id :: Located idL

  Name of the pattern synonym

• psb_fvs :: PostRn idR NameSet

  See Note [Bind free vars]

• psb_args :: HsPatSynDetails (Located idR)

  Formal parameter names

• psb_def :: LPat idR

  Right-hand side

• psb_dir :: HsPatSynDir idR

  Directionality

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)

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

toConstr :: PatSynBind idL idR -> Constr

dataTypeOf :: PatSynBind idL idR -> DataType

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

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

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

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

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

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

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

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

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

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

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

Methods

ppr :: PatSynBind idL idR -> SDoc

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

pprLHsBinds :: (OutputableBndrId idL, OutputableBndrId idR) => LHsBindsLR idL idR -> SDoc

pprLHsBindsForUser :: (OutputableBndrId idL, OutputableBndrId idR, OutputableBndrId id2) => LHsBindsLR idL idR -> [LSig id2] -> [SDoc]

pprDeclList :: [SDoc] -> SDoc

emptyLocalBinds :: HsLocalBindsLR a b

isEmptyLocalBinds :: HsLocalBindsLR a b -> Bool

eqEmptyLocalBinds :: HsLocalBindsLR a b -> Bool

isEmptyValBinds :: HsValBindsLR a b -> Bool

emptyValBindsIn :: HsValBindsLR a b

emptyValBindsOut :: HsValBindsLR a b

emptyLHsBinds :: LHsBindsLR idL idR

isEmptyLHsBinds :: LHsBindsLR idL idR -> Bool

plusHsValBinds :: HsValBinds a -> HsValBinds a -> HsValBinds a

ppr_monobind :: (OutputableBndrId idL, OutputableBndrId idR) => HsBindLR idL idR -> SDoc

pprTicks :: SDoc -> SDoc -> SDoc

data HsIPBinds id

Haskell Implicit Parameter Bindings

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)

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

toConstr :: HsIPBinds id -> Constr

dataTypeOf :: HsIPBinds id -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId id => Outputable (HsIPBinds id)

Methods

ppr :: HsIPBinds id -> SDoc

pprPrec :: Rational -> HsIPBinds id -> SDoc

isEmptyIPBinds :: HsIPBinds id -> Bool

type LIPBind id = Located (IPBind id)

Located Implicit Parameter Binding

May have AnnKeywordId : AnnSemi when in a list

data IPBind id

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.

• AnnKeywordId : AnnEqual

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)

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

toConstr :: IPBind name -> Constr

dataTypeOf :: IPBind name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId id => Outputable (IPBind id)

Methods

ppr :: IPBind id -> SDoc

pprPrec :: Rational -> IPBind id -> SDoc

type LSig name = Located (Sig name)

Located Signature

data Sig name

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.

• AnnKeywordId : AnnDcolon, AnnComma

PatSynSig [Located name] (LHsSigType name)

A pattern synonym type signature

pattern Single :: () => (Show a) => a -> [a]

• AnnKeywordId : AnnPattern, AnnDcolon,AnnForall AnnDot,AnnDarrow

ClassOpSig Bool [Located name] (LHsSigType name)

A signature for a class method False: ordinary class-method signature True: generic-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

• AnnKeywordId : AnnDefault, AnnDcolon

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 ***

• AnnKeywordId : AnnInfix, AnnVal

InlineSig (Located name) InlinePragma

An inline pragma

{#- INLINE f #-}

• AnnKeywordId : AnnOpen '{-# INLINE' and '[', AnnClose,AnnOpen, AnnVal,AnnTilde, AnnClose

SpecSig (Located name) [LHsSigType name] InlinePragma

A specialisation pragma

{-# SPECIALISE f :: Int -> Int #-}

• AnnKeywordId : AnnOpen, AnnOpen '{-# SPECIALISE' and '[', AnnTilde, AnnVal, AnnClose ']' and '#-}', AnnDcolon

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

• AnnKeywordId : AnnOpen, AnnInstance,AnnClose

MinimalSig SourceText (LBooleanFormula (Located name))

A minimal complete definition pragma

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

• AnnKeywordId : AnnOpen, AnnVbar,AnnComma, AnnClose

SCCFunSig SourceText (Located name) (Maybe (Located StringLiteral))

A "set cost centre" pragma for declarations

{-# SCC funName #-}

or

{-# SCC funName "cost_centre_name" #-}

CompleteMatchSig SourceText (Located [Located name]) (Maybe (Located name))

A complete match pragma

{-# COMPLETE C, D [:: T] #-}

Used to inform the pattern match checker about additional complete matchings which, for example, arise from pattern synonym definitions.

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)

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

toConstr :: Sig name -> Constr

dataTypeOf :: Sig name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndrId name => Outputable (Sig name)

Methods

ppr :: Sig name -> SDoc

pprPrec :: Rational -> Sig name -> SDoc

type LFixitySig name = Located (FixitySig name)

Located Fixity Signature

data FixitySig name

Fixity Signature

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)

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

toConstr :: FixitySig name -> Constr

dataTypeOf :: FixitySig name -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr name => Outputable (FixitySig name)

Methods

ppr :: FixitySig name -> SDoc

pprPrec :: Rational -> FixitySig name -> SDoc

data TcSpecPrags

Type checker Specialisation Pragmas

TcSpecPrags conveys SPECIALISE 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

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

toConstr :: TcSpecPrags -> Constr

dataTypeOf :: TcSpecPrags -> DataType

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

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

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

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

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

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

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

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

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

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

type LTcSpecPrag = Located TcSpecPrag

Located Type checker Specification Pragmas

data TcSpecPrag

Type checker Specification Pragma

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

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

toConstr :: TcSpecPrag -> Constr

dataTypeOf :: TcSpecPrag -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable TcSpecPrag

Methods

ppr :: TcSpecPrag -> SDoc

pprPrec :: Rational -> TcSpecPrag -> SDoc

noSpecPrags :: TcSpecPrags

hasSpecPrags :: TcSpecPrags -> Bool

isDefaultMethod :: TcSpecPrags -> Bool

isFixityLSig :: LSig name -> Bool

isTypeLSig :: LSig name -> Bool

isSpecLSig :: LSig name -> Bool

isSpecInstLSig :: LSig name -> Bool

isPragLSig :: LSig name -> Bool

isInlineLSig :: LSig name -> Bool

isMinimalLSig :: LSig name -> Bool

isSCCFunSig :: LSig name -> Bool

isCompleteMatchSig :: LSig name -> Bool

hsSigDoc :: Sig name -> SDoc

ppr_sig :: OutputableBndrId name => Sig name -> SDoc

pragBrackets :: SDoc -> SDoc

pragSrcBrackets :: SourceText -> String -> SDoc -> SDoc

Using SourceText in case the pragma was spelled differently or used mixed case

pprVarSig :: OutputableBndr id => [id] -> SDoc -> SDoc

pprSpec :: OutputableBndr id => id -> SDoc -> InlinePragma -> SDoc

pprTcSpecPrags :: TcSpecPrags -> SDoc

pprMinimalSig :: OutputableBndr name => LBooleanFormula (Located name) -> SDoc

data HsPatSynDetails a

Haskell Pattern Synonym Details

Constructors

InfixPatSyn a a

Infix Pattern Synonym

PrefixPatSyn [a]

Prefix Pattern Synonym

RecordPatSyn [RecordPatSynField a]

Record Pattern Synonym

Instances

Functor HsPatSynDetails

Methods

fmap :: (a -> b) -> HsPatSynDetails a -> HsPatSynDetails b

(<$) :: a -> HsPatSynDetails b -> HsPatSynDetails a

Foldable HsPatSynDetails

Methods

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

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

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

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

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

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

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

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

toList :: HsPatSynDetails a -> [a]

null :: HsPatSynDetails a -> Bool

length :: HsPatSynDetails a -> Int

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

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

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

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

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

Traversable HsPatSynDetails

Methods

traverse :: Applicative f => (a -> f b) -> HsPatSynDetails a -> f (HsPatSynDetails b)

sequenceA :: Applicative f => HsPatSynDetails (f a) -> f (HsPatSynDetails a)

mapM :: Monad m => (a -> m b) -> HsPatSynDetails a -> m (HsPatSynDetails b)

sequence :: Monad m => HsPatSynDetails (m a) -> m (HsPatSynDetails a)

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)

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

toConstr :: HsPatSynDetails a -> Constr

dataTypeOf :: HsPatSynDetails a -> DataType

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

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

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

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

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

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

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

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

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

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

data RecordPatSynField a

Record Pattern Synonym Field

Constructors

RecordPatSynField

Fields

• recordPatSynSelectorId :: a
• recordPatSynPatVar :: a

Instances

Functor RecordPatSynField

Methods

fmap :: (a -> b) -> RecordPatSynField a -> RecordPatSynField b

(<$) :: a -> RecordPatSynField b -> RecordPatSynField a

Foldable RecordPatSynField

Methods

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

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

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

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

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

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

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

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

toList :: RecordPatSynField a -> [a]

null :: RecordPatSynField a -> Bool

length :: RecordPatSynField a -> Int

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

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

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

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

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

Traversable RecordPatSynField

Methods

traverse :: Applicative f => (a -> f b) -> RecordPatSynField a -> f (RecordPatSynField b)

sequenceA :: Applicative f => RecordPatSynField (f a) -> f (RecordPatSynField a)

mapM :: Monad m => (a -> m b) -> RecordPatSynField a -> m (RecordPatSynField b)

sequence :: Monad m => RecordPatSynField (m a) -> m (RecordPatSynField a)

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)

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

toConstr :: RecordPatSynField a -> Constr

dataTypeOf :: RecordPatSynField a -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable a => Outputable (RecordPatSynField a)

Methods

ppr :: RecordPatSynField a -> SDoc

pprPrec :: Rational -> RecordPatSynField a -> SDoc

data HsPatSynDir id

Haskell Pattern Synonym Direction

Constructors

Unidirectional

ImplicitBidirectional

ExplicitBidirectional (MatchGroup id (LHsExpr id))

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)

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

toConstr :: HsPatSynDir id -> Constr

dataTypeOf :: HsPatSynDir id -> DataType

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

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

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

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

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

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

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

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

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

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