GHC.Hs.Expr

Abstract Haskell syntax for expressions.

Documentation

module Language.Haskell.Syntax.Expr

data HsUntypedSpliceResult thing

Constructors

HsUntypedSpliceTop

Fields

• utsplice_result_finalizers :: ThModFinalizers

  TH finalizers produced by the splice.

• utsplice_result :: thing

  The result of splicing; See Note [Lifecycle of a splice]

HsUntypedSpliceNested SplicePointName

Instances

Data a => Data (HsUntypedSpliceResult a)

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsUntypedSpliceResult a -> c (HsUntypedSpliceResult a)

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

toConstr :: HsUntypedSpliceResult a -> Constr

dataTypeOf :: HsUntypedSpliceResult a -> DataType

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

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

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

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

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

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

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

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

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

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

data PendingTcSplice

Pending Type-checker Splice

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc)

Instances

Data PendingTcSplice

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PendingTcSplice -> c PendingTcSplice

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

toConstr :: PendingTcSplice -> Constr

dataTypeOf :: PendingTcSplice -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable PendingTcSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingTcSplice -> SDoc

data PendingRnSplice

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

Instances

Data PendingRnSplice

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PendingRnSplice -> c PendingRnSplice

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

toConstr :: PendingRnSplice -> Constr

dataTypeOf :: PendingRnSplice -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable PendingRnSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingRnSplice -> SDoc

type SplicePointName = Name

data SyntaxExprTc

An expression with wrappers, used for rebindable syntax

This should desugar to

syn_res_wrap $ syn_expr (syn_arg_wraps[0] arg0)
                        (syn_arg_wraps[1] arg1) ...

where the actual arguments come from elsewhere in the AST.

Constructors

SyntaxExprTc

Fields

• syn_expr :: HsExpr GhcTc
• syn_arg_wraps :: [HsWrapper]
• syn_res_wrap :: HsWrapper

NoSyntaxExprTc

Instances

Data SyntaxExprTc

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SyntaxExprTc -> c SyntaxExprTc

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

toConstr :: SyntaxExprTc -> Constr

dataTypeOf :: SyntaxExprTc -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable SyntaxExprTc

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExprTc -> SDoc

newtype ThModFinalizers

Finalizers produced by a splice with addModFinalizer

See Note [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice. For how this is used.

Constructors

ThModFinalizers [ForeignRef (Q ())]

Instances

Data ThModFinalizers

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ThModFinalizers -> c ThModFinalizers

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

toConstr :: ThModFinalizers -> Constr

dataTypeOf :: ThModFinalizers -> DataType

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

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

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

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

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

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

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

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

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

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

type PostTcExpr = HsExpr GhcTc

Post-Type checking Expression

PostTcExpr is an evidence expression attached to the syntax tree by the type checker (c.f. postTcType).

type PostTcTable = [(Name, PostTcExpr)]

Post-Type checking Table

We use a PostTcTable where there are a bunch of pieces of evidence, more than is convenient to keep individually.

type family SyntaxExprGhc (p :: Pass) = (r :: Type) | r -> p where ...

Equations

SyntaxExprGhc 'Parsed = NoExtField

SyntaxExprGhc 'Renamed = SyntaxExprRn

SyntaxExprGhc 'Typechecked = SyntaxExprTc

data SyntaxExprRn

The function to use in rebindable syntax. See Note [NoSyntaxExpr].

Constructors

SyntaxExprRn (HsExpr GhcRn)

NoSyntaxExprRn

Instances

Data SyntaxExprRn

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SyntaxExprRn -> c SyntaxExprRn

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

toConstr :: SyntaxExprRn -> Constr

dataTypeOf :: SyntaxExprRn -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable SyntaxExprRn

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExprRn -> SDoc

data HsWrap hs_syn

HsWrap appears only in typechecker output

Constructors

HsWrap HsWrapper (hs_syn GhcTc)

Instances

(Data (hs_syn GhcTc), Typeable hs_syn) => Data (HsWrap hs_syn)

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWrap hs_syn -> c (HsWrap hs_syn)

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

toConstr :: HsWrap hs_syn -> Constr

dataTypeOf :: HsWrap hs_syn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWrap hs_syn))

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

gmapT :: (forall b. Data b => b -> b) -> HsWrap hs_syn -> HsWrap hs_syn

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

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

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

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

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

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

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

data HsBracketTc

Constructors

HsBracketTc

Fields

• hsb_quote :: HsQuote GhcRn
• hsb_ty :: Type
• hsb_wrap :: Maybe QuoteWrapper
• hsb_splices :: [PendingTcSplice]

Instances

Data HsBracketTc

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBracketTc -> c HsBracketTc

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

toConstr :: HsBracketTc -> Constr

dataTypeOf :: HsBracketTc -> DataType

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

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

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

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

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

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

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

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

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

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

data EpAnnHsCase

Constructors

EpAnnHsCase

Fields

• hsCaseAnnCase :: EpaLocation
• hsCaseAnnOf :: EpaLocation
• hsCaseAnnsRest :: [AddEpAnn]

Instances

Data EpAnnHsCase

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpAnnHsCase -> c EpAnnHsCase

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

toConstr :: EpAnnHsCase -> Constr

dataTypeOf :: EpAnnHsCase -> DataType

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

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

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

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

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

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

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

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

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

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

NoAnn EpAnnHsCase

Defined in GHC.Hs.Expr

Methods

noAnn :: EpAnnHsCase

data EpAnnUnboundVar

Constructors

EpAnnUnboundVar

Fields

• hsUnboundBackquotes :: (EpaLocation, EpaLocation)
• hsUnboundHole :: EpaLocation

Instances

Data EpAnnUnboundVar

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpAnnUnboundVar -> c EpAnnUnboundVar

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

toConstr :: EpAnnUnboundVar -> Constr

dataTypeOf :: EpAnnUnboundVar -> DataType

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

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

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

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

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

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

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

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

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

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

data AnnExplicitSum

Constructors

AnnExplicitSum

Fields

• aesOpen :: EpaLocation
• aesBarsBefore :: [EpaLocation]
• aesBarsAfter :: [EpaLocation]
• aesClose :: EpaLocation

Instances

Data AnnExplicitSum

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnExplicitSum -> c AnnExplicitSum

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

toConstr :: AnnExplicitSum -> Constr

dataTypeOf :: AnnExplicitSum -> DataType

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

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

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

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

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

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

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

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

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

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

NoAnn AnnExplicitSum

Defined in GHC.Hs.Expr

Methods

noAnn :: AnnExplicitSum

type HsMatchContextRn = HsMatchContext (LIdP GhcRn)

data AnnsIf

Constructors

AnnsIf

Fields

• aiIf :: EpaLocation
• aiThen :: EpaLocation
• aiElse :: EpaLocation
• aiThenSemi :: Maybe EpaLocation
• aiElseSemi :: Maybe EpaLocation

Instances

Data AnnsIf

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnsIf -> c AnnsIf

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

toConstr :: AnnsIf -> Constr

dataTypeOf :: AnnsIf -> DataType

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

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

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

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

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

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

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

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

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

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

NoAnn AnnsIf

Defined in GHC.Hs.Expr

Methods

noAnn :: AnnsIf

data family HsRecUpdParent x

Information about the parent of a record update:

• the parent type constructor or pattern synonym,
• the relevant con-likes,
• the field labels.

Instances

Data (HsRecUpdParent GhcPs)

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRecUpdParent GhcPs -> c (HsRecUpdParent GhcPs)

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

toConstr :: HsRecUpdParent GhcPs -> Constr

dataTypeOf :: HsRecUpdParent GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecUpdParent GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> HsRecUpdParent GhcPs -> HsRecUpdParent GhcPs

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

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

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

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

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

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

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

Data (HsRecUpdParent GhcRn)

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRecUpdParent GhcRn -> c (HsRecUpdParent GhcRn)

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

toConstr :: HsRecUpdParent GhcRn -> Constr

dataTypeOf :: HsRecUpdParent GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecUpdParent GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> HsRecUpdParent GhcRn -> HsRecUpdParent GhcRn

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

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

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

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

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

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

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

Data (HsRecUpdParent GhcTc)

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRecUpdParent GhcTc -> c (HsRecUpdParent GhcTc)

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

toConstr :: HsRecUpdParent GhcTc -> Constr

dataTypeOf :: HsRecUpdParent GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecUpdParent GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> HsRecUpdParent GhcTc -> HsRecUpdParent GhcTc

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

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

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

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

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

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

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

data HsRecUpdParent GhcPs

Defined in GHC.Hs.Expr

data HsRecUpdParent GhcPs

data HsRecUpdParent GhcRn

Defined in GHC.Hs.Expr

data HsRecUpdParent GhcRn = RnRecUpdParent {

• rnRecUpdLabels :: NonEmpty FieldGlobalRdrElt
• rnRecUpdCons :: UniqSet ConLikeName

}

data HsRecUpdParent GhcTc

Defined in GHC.Hs.Expr

data HsRecUpdParent GhcTc = TcRecUpdParent {

• tcRecUpdParent :: RecSelParent
• tcRecUpdLabels :: NonEmpty FieldGlobalRdrElt
• tcRecUpdCons :: UniqSet ConLike

}

data AnnProjection

Constructors

AnnProjection

Fields

• apOpen :: EpaLocation

  '('

• apClose :: EpaLocation

  ')'

Instances

Data AnnProjection

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProjection -> c AnnProjection

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

toConstr :: AnnProjection -> Constr

dataTypeOf :: AnnProjection -> DataType

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

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

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

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

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

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

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

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

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

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

NoAnn AnnProjection

Defined in GHC.Hs.Expr

Methods

noAnn :: AnnProjection

data AnnFieldLabel

Constructors

AnnFieldLabel

Fields

• afDot :: Maybe EpaLocation

Instances

Data AnnFieldLabel

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnFieldLabel -> c AnnFieldLabel

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

toConstr :: AnnFieldLabel -> Constr

dataTypeOf :: AnnFieldLabel -> DataType

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

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

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

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

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

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

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

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

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

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

NoAnn AnnFieldLabel

Defined in GHC.Hs.Expr

Methods

noAnn :: AnnFieldLabel

data XXExprGhcRn

Constructors

ExpandedThingRn

Fields

• xrn_orig :: HsThingRn
• xrn_expanded :: HsExpr GhcRn

PopErrCtxt !(LHsExpr GhcRn)

Instances

Data XXExprGhcRn

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> XXExprGhcRn -> c XXExprGhcRn

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

toConstr :: XXExprGhcRn -> Constr

dataTypeOf :: XXExprGhcRn -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable XXExprGhcRn

Defined in GHC.Hs.Expr

Methods

ppr :: XXExprGhcRn -> SDoc

data XXExprGhcTc

Constructors

WrapExpr !(HsWrap HsExpr)

ExpandedThingTc

Fields

• xtc_orig :: HsThingRn
• xtc_expanded :: HsExpr GhcTc

ConLikeTc ConLike [TcTyVar] [Scaled TcType]

HsTick CoreTickish (LHsExpr GhcTc)

HsBinTick Int Int (LHsExpr GhcTc)

Instances

Data XXExprGhcTc

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> XXExprGhcTc -> c XXExprGhcTc

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

toConstr :: XXExprGhcTc -> Constr

dataTypeOf :: XXExprGhcTc -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable XXExprGhcTc

Defined in GHC.Hs.Expr

Methods

ppr :: XXExprGhcTc -> SDoc

data HsThingRn

The different source constructs that we use to instantiate the "original" field in an `XXExprGhcRn original expansion`

Constructors

OrigExpr (HsExpr GhcRn)

OrigStmt (ExprLStmt GhcRn)

OrigPat (LPat GhcRn)

Instances

Data HsThingRn

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsThingRn -> c HsThingRn

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

toConstr :: HsThingRn -> Constr

dataTypeOf :: HsThingRn -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable HsThingRn

Defined in GHC.Hs.Expr

Methods

ppr :: HsThingRn -> SDoc

type CmdSyntaxTable p = [(Name, HsExpr p)]

Command Syntax Table (for Arrow syntax)

data CmdTopTc

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc)

Instances

Data CmdTopTc

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CmdTopTc -> c CmdTopTc

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

toConstr :: CmdTopTc -> Constr

dataTypeOf :: CmdTopTc -> DataType

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

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

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

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

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

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

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

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

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

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

data MatchGroupTc

Constructors

MatchGroupTc

Fields

• mg_arg_tys :: [Scaled Type]
• mg_res_ty :: Type
• mg_origin :: Origin

Instances

Data MatchGroupTc

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroupTc -> c MatchGroupTc

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

toConstr :: MatchGroupTc -> Constr

dataTypeOf :: MatchGroupTc -> DataType

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

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

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

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

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

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

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

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

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

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

data GrhsAnn

Constructors

GrhsAnn

Fields

• ga_vbar :: Maybe EpaLocation
• ga_sep :: AddEpAnn

  Match separator location

Instances

Data GrhsAnn

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GrhsAnn -> c GrhsAnn

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

toConstr :: GrhsAnn -> Constr

dataTypeOf :: GrhsAnn -> DataType

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

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

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

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

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

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

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

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

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

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

NoAnn GrhsAnn

Defined in GHC.Hs.Expr

Methods

noAnn :: GrhsAnn

Outputable GrhsAnn

Defined in GHC.Hs.Expr

Methods

ppr :: GrhsAnn -> SDoc

data RecStmtTc

Constructors

RecStmtTc

Fields

• recS_bind_ty :: Type
• recS_later_rets :: [PostTcExpr]
• recS_rec_rets :: [PostTcExpr]
• recS_ret_ty :: Type

Instances

Data RecStmtTc

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RecStmtTc -> c RecStmtTc

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

toConstr :: RecStmtTc -> Constr

dataTypeOf :: RecStmtTc -> DataType

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

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

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

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

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

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

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

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

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

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

data XBindStmtRn

Constructors

XBindStmtRn

Fields

• xbsrn_bindOp :: SyntaxExpr GhcRn
• xbsrn_failOp :: FailOperator GhcRn

Instances

Data XBindStmtRn

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> XBindStmtRn -> c XBindStmtRn

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

toConstr :: XBindStmtRn -> Constr

dataTypeOf :: XBindStmtRn -> DataType

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

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

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

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

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

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

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

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

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

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

data XBindStmtTc

Constructors

XBindStmtTc

Fields

• xbstc_bindOp :: SyntaxExpr GhcTc
• xbstc_boundResultType :: Type
• xbstc_boundResultMult :: Mult
• xbstc_failOp :: FailOperator GhcTc

Instances

Data XBindStmtTc

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> XBindStmtTc -> c XBindStmtTc

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

toConstr :: XBindStmtTc -> Constr

dataTypeOf :: XBindStmtTc -> DataType

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

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

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

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

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

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

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

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

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

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

data DelayedSplice

Constructors

DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTc)

Instances

Data DelayedSplice

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DelayedSplice -> c DelayedSplice

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

toConstr :: DelayedSplice -> Constr

dataTypeOf :: DelayedSplice -> DataType

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

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

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

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

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

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

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

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

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

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

data UntypedSpliceFlavour

Constructors

UntypedExpSplice

UntypedPatSplice

UntypedTypeSplice

UntypedDeclSplice

Instances

Data UntypedSpliceFlavour

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UntypedSpliceFlavour -> c UntypedSpliceFlavour

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

toConstr :: UntypedSpliceFlavour -> Constr

dataTypeOf :: UntypedSpliceFlavour -> DataType

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

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

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

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

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

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

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

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

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

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

type HsMatchContextPs = HsMatchContext (LIdP GhcPs)

type HsStmtContextRn = HsStmtContext (LIdP GhcRn)

pprParendExpr :: OutputableBndrId p => PprPrec -> HsExpr (GhcPass p) -> SDoc

pprExpr :: OutputableBndrId p => HsExpr (GhcPass p) -> SDoc

pprFunBind :: OutputableBndrId idR => MatchGroup (GhcPass idR) (LHsExpr (GhcPass idR)) -> SDoc

pprPatBind :: forall bndr p. (OutputableBndrId bndr, OutputableBndrId p) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc

pprUntypedSplice :: forall p. OutputableBndrId p => Bool -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc

pprLExpr :: OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc

prependQualified :: Maybe ModuleName -> SDoc -> SDoc

lamCaseKeyword :: HsLamVariant -> SDoc

pp_rhs :: Outputable body => HsMatchContext fn -> body -> SDoc

pprTypedSplice :: OutputableBndrId p => Maybe SplicePointName -> LHsExpr (GhcPass p) -> SDoc

ppr_expr :: forall p. OutputableBndrId p => HsExpr (GhcPass p) -> SDoc

pprArg :: forall idL. OutputableBndrId idL => ApplicativeArg (GhcPass idL) -> SDoc

noExpr :: HsExpr (GhcPass p)

This is used for rebindable-syntax pieces that are too polymorphic for tcSyntaxOp (trS_fmap and the mzip in ParStmt)

noSyntaxExpr :: forall p. IsPass p => SyntaxExpr (GhcPass p)

mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn

Make a 'SyntaxExpr GhcRn' from an expression Used only in getMonadFailOp. See Note [Monad fail : Rebindable syntax, overloaded strings] in GHC.Rename.Expr

mkRnSyntaxExpr :: Name -> SyntaxExprRn

Make a SyntaxExpr from a Name (the "rn" is because this is used in the renamer).

tupArgPresent :: HsTupArg (GhcPass p) -> Bool

tupArgPresent_maybe :: HsTupArg (GhcPass p) -> Maybe (LHsExpr (GhcPass p))

tupArgsPresent_maybe :: [HsTupArg (GhcPass p)] -> Maybe [LHsExpr (GhcPass p)]

isHsThingRnExpr :: HsThingRn -> Bool

isHsThingRnStmt :: HsThingRn -> Bool

isHsThingRnPat :: HsThingRn -> Bool

mkPopErrCtxtExpr :: LHsExpr GhcRn -> HsExpr GhcRn

Wrap a located expression with a PopErrCtxt

mkPopErrCtxtExprAt :: SrcSpanAnnA -> LHsExpr GhcRn -> LHsExpr GhcRn

Wrap a located expression with a PopSrcExpr with an appropriate location

mkExpandedExpr

Arguments

:: HsExpr GhcRn

source expression

-> HsExpr GhcRn

expanded expression

-> HsExpr GhcRn

suitably wrapped XXExprGhcRn

Build an expression using the extension constructor XExpr, and the two components of the expansion: original expression and expanded expressions.

mkExpandedStmt

Arguments

:: ExprLStmt GhcRn

source statement

-> HsExpr GhcRn

expanded expression

-> HsExpr GhcRn

suitably wrapped XXExprGhcRn

Build an expression using the extension constructor XExpr, and the two components of the expansion: original do stmt and expanded expression

mkExpandedPatRn

Arguments

:: LPat GhcRn

source pattern

-> HsExpr GhcRn

expanded expression

-> HsExpr GhcRn

suitably wrapped XXExprGhcRn

mkExpandedStmtAt

Arguments

:: SrcSpanAnnA

Location for the expansion expression

-> ExprLStmt GhcRn

source statement

-> HsExpr GhcRn

expanded expression

-> LHsExpr GhcRn

suitably wrapped located XXExprGhcRn

Build an expression using the extension constructor XExpr, and the two components of the expansion: original do stmt and expanded expression an associate with a provided location

mkExpandedStmtPopAt

Arguments

:: SrcSpanAnnA

Location for the expansion statement

-> ExprLStmt GhcRn

source statement

-> HsExpr GhcRn

expanded expression

-> LHsExpr GhcRn

suitably wrapped XXExprGhcRn

Wrap the expanded version of the expression with a pop.

mkExpandedExprTc

Arguments

:: HsExpr GhcRn

source expression

-> HsExpr GhcTc

expanded typechecked expression

-> HsExpr GhcTc

suitably wrapped XXExprGhcRn

Build a XXExprGhcRn out of an extension constructor, and the two components of the expansion: original and expanded typechecked expressions.

mkExpandedStmtTc

Arguments

:: ExprLStmt GhcRn

source do statement

-> HsExpr GhcTc

expanded typechecked expression

-> HsExpr GhcTc

suitably wrapped XXExprGhcRn

Build a XXExprGhcRn out of an extension constructor. The two components of the expansion are: original statement and expanded typechecked expression.

isAtomicHsExpr :: forall p. IsPass p => HsExpr (GhcPass p) -> Bool

isQuietHsExpr :: HsExpr id -> Bool

pprBinds :: (OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc

ppr_lexpr :: OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc

ppr_apps :: OutputableBndrId p => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))] -> SDoc

ppr_infix_expr :: forall p. OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc

pprDebugParendExpr :: OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc

pprMatches :: (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc

pprDo :: (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => HsDoFlavour -> [LStmt (GhcPass p) body] -> SDoc

thTyBrackets :: SDoc -> SDoc

ppr_with_pending_tc_splices :: SDoc -> [PendingTcSplice] -> SDoc

ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc

ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc

ppr_infix_hs_expansion :: HsThingRn -> Maybe SDoc

pprParendLExpr :: OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc

hsExprNeedsParens :: forall p. IsPass p => PprPrec -> HsExpr (GhcPass p) -> Bool

hsExprNeedsParens p e returns True if the expression e needs parentheses under precedence p.

gHsPar :: forall p. IsPass p => LHsExpr (GhcPass p) -> HsExpr (GhcPass p)

Parenthesize an expression without token information

parenthesizeHsExpr :: IsPass p => PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)

parenthesizeHsExpr p e checks if hsExprNeedsParens p e is true, and if so, surrounds e with an HsPar. Otherwise, it simply returns e.

stripParensLHsExpr :: LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)

stripParensHsExpr :: HsExpr (GhcPass p) -> HsExpr (GhcPass p)

pprCmd :: OutputableBndrId p => HsCmd (GhcPass p) -> SDoc

pprLCmd :: OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc

isQuietHsCmd :: HsCmd id -> Bool

ppr_cmd :: forall p. OutputableBndrId p => HsCmd (GhcPass p) -> SDoc

ppr_lcmd :: OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc

pprArrowExpr :: (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc

pprCmdArg :: OutputableBndrId p => HsCmdTop (GhcPass p) -> SDoc

pprMatch :: (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc

isEmptyMatchGroup :: MatchGroup (GhcPass p) body -> Bool

isSingletonMatchGroup :: [LMatch (GhcPass p) body] -> Bool

Is there only one RHS in this list of matches?

matchGroupArity :: MatchGroup (GhcPass id) body -> Arity

hsLMatchPats :: LMatch (GhcPass id) body -> [LPat (GhcPass id)]

pprGRHSs :: (OutputableBndrId idR, Outputable body) => HsMatchContext fn -> GRHSs (GhcPass idR) body -> SDoc

pprGRHS :: (OutputableBndrId idR, Outputable body) => HsMatchContext fn -> GRHS (GhcPass idR) body -> SDoc

matchSeparator :: HsMatchContext fn -> SDoc

pprStmt :: forall idL idR body. (OutputableBndrId idL, OutputableBndrId idR, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA, Outputable body) => StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc

pprBindStmt :: (Outputable pat, Outputable expr) => pat -> expr -> SDoc

pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> SDoc

ppr_do_stmts :: (OutputableBndrId idL, OutputableBndrId idR, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA, Outputable body) => [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc

pprTransformStmt :: OutputableBndrId p => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc

pprBy :: Outputable body => Maybe body -> SDoc

ppr_module_name_prefix :: Maybe ModuleName -> SDoc

pprComp :: (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc

pprQuals :: (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc

pprPendingSplice :: OutputableBndrId p => SplicePointName -> LHsExpr (GhcPass p) -> SDoc

ppr_splice :: OutputableBndrId p => SDoc -> Maybe SplicePointName -> LHsExpr (GhcPass p) -> SDoc

ppr_quasi :: OutputableBndr p => p -> FastString -> SDoc

thBrackets :: SDoc -> SDoc -> SDoc

pp_dotdot :: SDoc

pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc

pprHsArrType :: HsArrAppType -> SDoc

pprStmtContext :: Outputable fn => HsStmtContext fn -> SDoc

matchContextErrString :: Outputable fn => HsMatchContext fn -> SDoc

matchArrowContextErrString :: HsArrowMatchContext -> SDoc

matchDoContextErrString :: HsDoFlavour -> SDoc

pprMatchInCtxt :: (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc

pprMatchContext :: Outputable fn => HsMatchContext fn -> SDoc

pprStmtInCtxt :: (OutputableBndrId idL, OutputableBndrId idR, Outputable fn, Outputable body, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA) => HsStmtContext fn -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc

pprAStmtContext :: Outputable fn => HsStmtContext fn -> SDoc

pprMatchContextNoun :: Outputable fn => HsMatchContext fn -> SDoc

pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc

pprMatchContextNouns :: Outputable fn => HsMatchContext fn -> SDoc

pprArrowMatchContextNouns :: HsArrowMatchContext -> SDoc

pprAHsDoFlavour :: HsDoFlavour -> SDoc

pprHsDoFlavour :: HsDoFlavour -> SDoc

pprStmtCat :: Stmt (GhcPass p) body -> SDoc

pprFieldLabelStrings :: forall p. (UnXRec p, Outputable (XRec p FieldLabelString)) => FieldLabelStrings p -> SDoc

pprPrefixFastString :: FastString -> SDoc

Orphan instances

Outputable HsArrowMatchContext

Methods

ppr :: HsArrowMatchContext -> SDoc

Outputable HsLamVariant

Methods

ppr :: HsLamVariant -> SDoc

OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL))

Methods

ppr :: ApplicativeArg (GhcPass idL) -> SDoc

OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p))

Methods

ppr :: ArithSeqInfo (GhcPass p) -> SDoc

UnXRec p => Outputable (DotFieldOcc p)

Methods

ppr :: DotFieldOcc p -> SDoc

(UnXRec p, Outputable (XRec p FieldLabelString)) => Outputable (FieldLabelStrings p)

Methods

ppr :: FieldLabelStrings p -> SDoc

OutputableBndrId p => Outputable (HsCmd (GhcPass p))

Methods

ppr :: HsCmd (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsCmdTop (GhcPass p))

Methods

ppr :: HsCmdTop (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsExpr (GhcPass p))

Methods

ppr :: HsExpr (GhcPass p) -> SDoc

Outputable fn => Outputable (HsMatchContext fn)

Methods

ppr :: HsMatchContext fn -> SDoc

Outputable (HsPragE (GhcPass p))

Methods

ppr :: HsPragE (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsQuote (GhcPass p))

Methods

ppr :: HsQuote (GhcPass p) -> SDoc

Outputable fn => Outputable (HsStmtContext fn)

Methods

ppr :: HsStmtContext fn -> SDoc

(UnXRec p, Outputable (XRec p FieldLabelString)) => OutputableBndr (Located (FieldLabelStrings p))

Methods

pprBndr :: BindingSite -> Located (FieldLabelStrings p) -> SDoc

pprPrefixOcc :: Located (FieldLabelStrings p) -> SDoc

pprInfixOcc :: Located (FieldLabelStrings p) -> SDoc

bndrIsJoin_maybe :: Located (FieldLabelStrings p) -> JoinPointHood

(UnXRec p, Outputable (XRec p FieldLabelString)) => OutputableBndr (FieldLabelStrings p)

Methods

pprBndr :: BindingSite -> FieldLabelStrings p -> SDoc

pprPrefixOcc :: FieldLabelStrings p -> SDoc

pprInfixOcc :: FieldLabelStrings p -> SDoc

bndrIsJoin_maybe :: FieldLabelStrings p -> JoinPointHood

HasAnnotation (Anno a) => WrapXRec (GhcPass p) a

Methods

wrapXRec :: a -> XRec (GhcPass p) a

(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body)

Methods

ppr :: Match (GhcPass pr) body -> SDoc

(Outputable (StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))), Outputable (XXParStmtBlock (GhcPass idL) (GhcPass idR))) => Outputable (ParStmtBlock (GhcPass idL) (GhcPass idR))

Methods

ppr :: ParStmtBlock (GhcPass idL) (GhcPass idR) -> SDoc

(OutputableBndrId pl, OutputableBndrId pr, Anno (StmtLR (GhcPass pl) (GhcPass pr) body) ~ SrcSpanAnnA, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body)

Methods

ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc