BasicTypes

Documentation

type Version = Int

bumpVersion :: Version -> Version

initialVersion :: Version

data LeftOrRight

Constructors

CLeft

CRight

Instances

Eq LeftOrRight

Defined in BasicTypes

Methods

(==) :: LeftOrRight -> LeftOrRight -> Bool

(/=) :: LeftOrRight -> LeftOrRight -> Bool

Data LeftOrRight

Defined in BasicTypes

Methods

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

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

toConstr :: LeftOrRight -> Constr

dataTypeOf :: LeftOrRight -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable LeftOrRight

Defined in BasicTypes

Methods

ppr :: LeftOrRight -> SDoc

pprPrec :: Rational -> LeftOrRight -> SDoc

Binary LeftOrRight

Defined in Binary

Methods

put_ :: BinHandle -> LeftOrRight -> IO ()

put :: BinHandle -> LeftOrRight -> IO (Bin LeftOrRight)

get :: BinHandle -> IO LeftOrRight

pickLR :: LeftOrRight -> (a, a) -> a

type ConTag = Int

Constructor Tag

Type of the tags associated with each constructor possibility or superclass selector

type ConTagZ = Int

A *zero-indexed* constructor tag

fIRST_TAG :: ConTag

Tags are allocated from here for real constructors or for superclass selectors

type Arity = Int

The number of value arguments that can be applied to a value before it does "real work". So: fib 100 has arity 0 x -> fib x has arity 1 See also Note [Definition of arity] in CoreArity

type RepArity = Int

Representation Arity

The number of represented arguments that can be applied to a value before it does "real work". So: fib 100 has representation arity 0 x -> fib x has representation arity 1 () -> fib (x + y) has representation arity 2

type JoinArity = Int

The number of arguments that a join point takes. Unlike the arity of a function, this is a purely syntactic property and is fixed when the join point is created (or converted from a value). Both type and value arguments are counted.

data Alignment

A power-of-two alignment

Instances

Eq Alignment

Defined in BasicTypes

Methods

(==) :: Alignment -> Alignment -> Bool

(/=) :: Alignment -> Alignment -> Bool

Ord Alignment

Defined in BasicTypes

Methods

compare :: Alignment -> Alignment -> Ordering

(<) :: Alignment -> Alignment -> Bool

(<=) :: Alignment -> Alignment -> Bool

(>) :: Alignment -> Alignment -> Bool

(>=) :: Alignment -> Alignment -> Bool

max :: Alignment -> Alignment -> Alignment

min :: Alignment -> Alignment -> Alignment

Outputable Alignment

Defined in BasicTypes

Methods

ppr :: Alignment -> SDoc

pprPrec :: Rational -> Alignment -> SDoc

mkAlignment :: Int -> Alignment

alignmentOf :: Int -> Alignment

alignmentBytes :: Alignment -> Int

data PromotionFlag

Is a TyCon a promoted data constructor or just a normal type constructor?

Constructors

NotPromoted

IsPromoted

Instances

Eq PromotionFlag

Defined in BasicTypes

Methods

(==) :: PromotionFlag -> PromotionFlag -> Bool

(/=) :: PromotionFlag -> PromotionFlag -> Bool

Data PromotionFlag

Defined in BasicTypes

Methods

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

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

toConstr :: PromotionFlag -> Constr

dataTypeOf :: PromotionFlag -> DataType

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

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

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

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

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

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

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

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

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

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

Binary PromotionFlag

Defined in Binary

Methods

put_ :: BinHandle -> PromotionFlag -> IO ()

put :: BinHandle -> PromotionFlag -> IO (Bin PromotionFlag)

get :: BinHandle -> IO PromotionFlag

isPromoted :: PromotionFlag -> Bool

data FunctionOrData

Constructors

IsFunction

IsData

Instances

Eq FunctionOrData

Defined in BasicTypes

Methods

(==) :: FunctionOrData -> FunctionOrData -> Bool

(/=) :: FunctionOrData -> FunctionOrData -> Bool

Data FunctionOrData

Defined in BasicTypes

Methods

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

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

toConstr :: FunctionOrData -> Constr

dataTypeOf :: FunctionOrData -> DataType

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

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

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

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

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

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

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

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

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

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

Ord FunctionOrData

Defined in BasicTypes

Methods

compare :: FunctionOrData -> FunctionOrData -> Ordering

(<) :: FunctionOrData -> FunctionOrData -> Bool

(<=) :: FunctionOrData -> FunctionOrData -> Bool

(>) :: FunctionOrData -> FunctionOrData -> Bool

(>=) :: FunctionOrData -> FunctionOrData -> Bool

max :: FunctionOrData -> FunctionOrData -> FunctionOrData

min :: FunctionOrData -> FunctionOrData -> FunctionOrData

Outputable FunctionOrData

Defined in BasicTypes

Methods

ppr :: FunctionOrData -> SDoc

pprPrec :: Rational -> FunctionOrData -> SDoc

Binary FunctionOrData

Defined in Binary

Methods

put_ :: BinHandle -> FunctionOrData -> IO ()

put :: BinHandle -> FunctionOrData -> IO (Bin FunctionOrData)

get :: BinHandle -> IO FunctionOrData

data WarningTxt

Warning Text

reason/explanation from a WARNING or DEPRECATED pragma

Constructors

WarningTxt (Located SourceText) [Located StringLiteral]

DeprecatedTxt (Located SourceText) [Located StringLiteral]

Instances

Eq WarningTxt

Defined in BasicTypes

Methods

(==) :: WarningTxt -> WarningTxt -> Bool

(/=) :: WarningTxt -> WarningTxt -> Bool

Data WarningTxt

Defined in BasicTypes

Methods

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

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

toConstr :: WarningTxt -> Constr

dataTypeOf :: WarningTxt -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable WarningTxt

Defined in BasicTypes

Methods

ppr :: WarningTxt -> SDoc

pprPrec :: Rational -> WarningTxt -> SDoc

Binary WarningTxt

Defined in Binary

Methods

put_ :: BinHandle -> WarningTxt -> IO ()

put :: BinHandle -> WarningTxt -> IO (Bin WarningTxt)

get :: BinHandle -> IO WarningTxt

pprWarningTxtForMsg :: WarningTxt -> SDoc

data StringLiteral

A String Literal in the source, including its original raw format for use by source to source manipulation tools.

Constructors

StringLiteral

Fields

• sl_st :: SourceText
• sl_fs :: FastString

Instances

Eq StringLiteral

Defined in BasicTypes

Methods

(==) :: StringLiteral -> StringLiteral -> Bool

(/=) :: StringLiteral -> StringLiteral -> Bool

Data StringLiteral

Defined in BasicTypes

Methods

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

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

toConstr :: StringLiteral -> Constr

dataTypeOf :: StringLiteral -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable StringLiteral

Defined in BasicTypes

Methods

ppr :: StringLiteral -> SDoc

pprPrec :: Rational -> StringLiteral -> SDoc

Binary StringLiteral

Defined in Binary

Methods

put_ :: BinHandle -> StringLiteral -> IO ()

put :: BinHandle -> StringLiteral -> IO (Bin StringLiteral)

get :: BinHandle -> IO StringLiteral

data Fixity

Constructors

Fixity SourceText Int FixityDirection

Instances

Eq Fixity

Defined in BasicTypes

Methods

(==) :: Fixity -> Fixity -> Bool

(/=) :: Fixity -> Fixity -> Bool

Data Fixity

Defined in BasicTypes

Methods

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

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

toConstr :: Fixity -> Constr

dataTypeOf :: Fixity -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Fixity

Defined in BasicTypes

Methods

ppr :: Fixity -> SDoc

pprPrec :: Rational -> Fixity -> SDoc

Binary Fixity

Defined in Binary

Methods

put_ :: BinHandle -> Fixity -> IO ()

put :: BinHandle -> Fixity -> IO (Bin Fixity)

get :: BinHandle -> IO Fixity

data FixityDirection

Constructors

InfixL

InfixR

InfixN

Instances

Eq FixityDirection

Defined in BasicTypes

Methods

(==) :: FixityDirection -> FixityDirection -> Bool

(/=) :: FixityDirection -> FixityDirection -> Bool

Data FixityDirection

Defined in BasicTypes

Methods

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

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

toConstr :: FixityDirection -> Constr

dataTypeOf :: FixityDirection -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable FixityDirection

Defined in BasicTypes

Methods

ppr :: FixityDirection -> SDoc

pprPrec :: Rational -> FixityDirection -> SDoc

Binary FixityDirection

Defined in Binary

Methods

put_ :: BinHandle -> FixityDirection -> IO ()

put :: BinHandle -> FixityDirection -> IO (Bin FixityDirection)

get :: BinHandle -> IO FixityDirection

defaultFixity :: Fixity

maxPrecedence :: Int

minPrecedence :: Int

negateFixity :: Fixity

funTyFixity :: Fixity

compareFixity :: Fixity -> Fixity -> (Bool, Bool)

data LexicalFixity

Captures the fixity of declarations as they are parsed. This is not necessarily the same as the fixity declaration, as the normal fixity may be overridden using parens or backticks.

Constructors

Prefix

Infix

Instances

Eq LexicalFixity

Defined in BasicTypes

Methods

(==) :: LexicalFixity -> LexicalFixity -> Bool

(/=) :: LexicalFixity -> LexicalFixity -> Bool

Data LexicalFixity

Defined in BasicTypes

Methods

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

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

toConstr :: LexicalFixity -> Constr

dataTypeOf :: LexicalFixity -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable LexicalFixity

Defined in BasicTypes

Methods

ppr :: LexicalFixity -> SDoc

pprPrec :: Rational -> LexicalFixity -> SDoc

data RecFlag

Recursivity Flag

Constructors

Recursive

NonRecursive

Instances

Eq RecFlag

Defined in BasicTypes

Methods

(==) :: RecFlag -> RecFlag -> Bool

(/=) :: RecFlag -> RecFlag -> Bool

Data RecFlag

Defined in BasicTypes

Methods

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

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

toConstr :: RecFlag -> Constr

dataTypeOf :: RecFlag -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable RecFlag

Defined in BasicTypes

Methods

ppr :: RecFlag -> SDoc

pprPrec :: Rational -> RecFlag -> SDoc

Binary RecFlag

Defined in Binary

Methods

put_ :: BinHandle -> RecFlag -> IO ()

put :: BinHandle -> RecFlag -> IO (Bin RecFlag)

get :: BinHandle -> IO RecFlag

isRec :: RecFlag -> Bool

isNonRec :: RecFlag -> Bool

boolToRecFlag :: Bool -> RecFlag

data Origin

Constructors

FromSource

Generated

Instances

Eq Origin

Defined in BasicTypes

Methods

(==) :: Origin -> Origin -> Bool

(/=) :: Origin -> Origin -> Bool

Data Origin

Defined in BasicTypes

Methods

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

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

toConstr :: Origin -> Constr

dataTypeOf :: Origin -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Origin

Defined in BasicTypes

Methods

ppr :: Origin -> SDoc

pprPrec :: Rational -> Origin -> SDoc

isGenerated :: Origin -> Bool

type RuleName = FastString

pprRuleName :: RuleName -> SDoc

data TopLevelFlag

Constructors

TopLevel

NotTopLevel

Instances

Outputable TopLevelFlag

Defined in BasicTypes

Methods

ppr :: TopLevelFlag -> SDoc

pprPrec :: Rational -> TopLevelFlag -> SDoc

isTopLevel :: TopLevelFlag -> Bool

isNotTopLevel :: TopLevelFlag -> Bool

data OverlapFlag

The semantics allowed for overlapping instances for a particular instance. See Note [Safe Haskell isSafeOverlap] (in hs) for a explanation of the isSafeOverlap field.

• AnnKeywordId : AnnOpen '{-# OVERLAPPABLE' or '{-# OVERLAPPING' or '{-# OVERLAPS' or '{-# INCOHERENT', AnnClose `#-}`,

Constructors

OverlapFlag

Fields

• overlapMode :: OverlapMode
• isSafeOverlap :: Bool

Instances

Eq OverlapFlag

Defined in BasicTypes

Methods

(==) :: OverlapFlag -> OverlapFlag -> Bool

(/=) :: OverlapFlag -> OverlapFlag -> Bool

Data OverlapFlag

Defined in BasicTypes

Methods

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

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

toConstr :: OverlapFlag -> Constr

dataTypeOf :: OverlapFlag -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable OverlapFlag

Defined in BasicTypes

Methods

ppr :: OverlapFlag -> SDoc

pprPrec :: Rational -> OverlapFlag -> SDoc

Binary OverlapFlag

Defined in Binary

Methods

put_ :: BinHandle -> OverlapFlag -> IO ()

put :: BinHandle -> OverlapFlag -> IO (Bin OverlapFlag)

get :: BinHandle -> IO OverlapFlag

data OverlapMode

Constructors

NoOverlap SourceText

This instance must not overlap another NoOverlap instance. However, it may be overlapped by Overlapping instances, and it may overlap Overlappable instances.

Overlappable SourceText

Silently ignore this instance if you find a more specific one that matches the constraint you are trying to resolve

Example: constraint (Foo [Int]) instance Foo [Int] instance {--} Foo [a]

Since the second instance has the Overlappable flag, the first instance will be chosen (otherwise its ambiguous which to choose)

Overlapping SourceText

Silently ignore any more general instances that may be used to solve the constraint.

Example: constraint (Foo [Int]) instance {--} Foo [Int] instance Foo [a]

Since the first instance has the Overlapping flag, the second---more general---instance will be ignored (otherwise it is ambiguous which to choose)

Overlaps SourceText

Equivalent to having both Overlapping and Overlappable flags.

Incoherent SourceText

Behave like Overlappable and Overlapping, and in addition pick an an arbitrary one if there are multiple matching candidates, and don't worry about later instantiation

Example: constraint (Foo [b]) instance {-# INCOHERENT -} Foo [Int] instance Foo [a] Without the Incoherent flag, we'd complain that instantiating b would change which instance was chosen. See also note [Incoherent instances] in InstEnv

Instances

Eq OverlapMode

Defined in BasicTypes

Methods

(==) :: OverlapMode -> OverlapMode -> Bool

(/=) :: OverlapMode -> OverlapMode -> Bool

Data OverlapMode

Defined in BasicTypes

Methods

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

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

toConstr :: OverlapMode -> Constr

dataTypeOf :: OverlapMode -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable OverlapMode

Defined in BasicTypes

Methods

ppr :: OverlapMode -> SDoc

pprPrec :: Rational -> OverlapMode -> SDoc

Binary OverlapMode

Defined in Binary

Methods

put_ :: BinHandle -> OverlapMode -> IO ()

put :: BinHandle -> OverlapMode -> IO (Bin OverlapMode)

get :: BinHandle -> IO OverlapMode

setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag

hasOverlappingFlag :: OverlapMode -> Bool

hasOverlappableFlag :: OverlapMode -> Bool

hasIncoherentFlag :: OverlapMode -> Bool

data Boxity

Constructors

Boxed

Unboxed

Instances

Eq Boxity

Defined in BasicTypes

Methods

(==) :: Boxity -> Boxity -> Bool

(/=) :: Boxity -> Boxity -> Bool

Data Boxity

Defined in BasicTypes

Methods

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

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

toConstr :: Boxity -> Constr

dataTypeOf :: Boxity -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Boxity

Defined in BasicTypes

Methods

ppr :: Boxity -> SDoc

pprPrec :: Rational -> Boxity -> SDoc

isBoxed :: Boxity -> Bool

newtype PprPrec

A general-purpose pretty-printing precedence type.

Constructors

PprPrec Int

Instances

Eq PprPrec

Defined in BasicTypes

Methods

(==) :: PprPrec -> PprPrec -> Bool

(/=) :: PprPrec -> PprPrec -> Bool

Ord PprPrec

Defined in BasicTypes

Methods

compare :: PprPrec -> PprPrec -> Ordering

(<) :: PprPrec -> PprPrec -> Bool

(<=) :: PprPrec -> PprPrec -> Bool

(>) :: PprPrec -> PprPrec -> Bool

(>=) :: PprPrec -> PprPrec -> Bool

max :: PprPrec -> PprPrec -> PprPrec

min :: PprPrec -> PprPrec -> PprPrec

Show PprPrec

Defined in BasicTypes

Methods

showsPrec :: Int -> PprPrec -> ShowS

show :: PprPrec -> String

showList :: [PprPrec] -> ShowS

topPrec :: PprPrec

sigPrec :: PprPrec

opPrec :: PprPrec

funPrec :: PprPrec

appPrec :: PprPrec

maybeParen :: PprPrec -> PprPrec -> SDoc -> SDoc

data TupleSort

Constructors

BoxedTuple

UnboxedTuple

ConstraintTuple

Instances

Eq TupleSort

Defined in BasicTypes

Methods

(==) :: TupleSort -> TupleSort -> Bool

(/=) :: TupleSort -> TupleSort -> Bool

Data TupleSort

Defined in BasicTypes

Methods

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

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

toConstr :: TupleSort -> Constr

dataTypeOf :: TupleSort -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable TupleSort

Defined in BasicTypes

Methods

ppr :: TupleSort -> SDoc

pprPrec :: Rational -> TupleSort -> SDoc

Binary TupleSort

Defined in Binary

Methods

put_ :: BinHandle -> TupleSort -> IO ()

put :: BinHandle -> TupleSort -> IO (Bin TupleSort)

get :: BinHandle -> IO TupleSort

tupleSortBoxity :: TupleSort -> Boxity

boxityTupleSort :: Boxity -> TupleSort

tupleParens :: TupleSort -> SDoc -> SDoc

sumParens :: SDoc -> SDoc

pprAlternative

Arguments

:: (a -> SDoc)

The pretty printing function to use

-> a

The things to be pretty printed

-> ConTag

Alternative (one-based)

-> Arity

Arity

-> SDoc

SDoc where the alternative havs been pretty printed and finally packed into a paragraph.

Pretty print an alternative in an unboxed sum e.g. "| a | |".

The OneShotInfo type

data OneShotInfo

If the Id is a lambda-bound variable then it may have lambda-bound variable info. Sometimes we know whether the lambda binding this variable is a "one-shot" lambda; that is, whether it is applied at most once.

This information may be useful in optimisation, as computations may safely be floated inside such a lambda without risk of duplicating work.

Constructors

NoOneShotInfo

No information

OneShotLam

The lambda is applied at most once.

Instances

Eq OneShotInfo

Defined in BasicTypes

Methods

(==) :: OneShotInfo -> OneShotInfo -> Bool

(/=) :: OneShotInfo -> OneShotInfo -> Bool

Outputable OneShotInfo

Defined in BasicTypes

Methods

ppr :: OneShotInfo -> SDoc

pprPrec :: Rational -> OneShotInfo -> SDoc

noOneShotInfo :: OneShotInfo

It is always safe to assume that an Id has no lambda-bound variable information

hasNoOneShotInfo :: OneShotInfo -> Bool

isOneShotInfo :: OneShotInfo -> Bool

bestOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo

worstOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo

data OccInfo

identifier Occurrence Information

Constructors

ManyOccs

There are many occurrences, or unknown occurrences

Fields

• occ_tail :: !TailCallInfo

IAmDead

Marks unused variables. Sometimes useful for lambda and case-bound variables.

OneOcc

Occurs exactly once (per branch), not inside a rule

Fields

• occ_in_lam :: !InsideLam
• occ_one_br :: !OneBranch
• occ_int_cxt :: !InterestingCxt
• occ_tail :: !TailCallInfo

IAmALoopBreaker

This identifier breaks a loop of mutually recursive functions. The field marks whether it is only a loop breaker due to a reference in a rule

Fields

• occ_rules_only :: !RulesOnly
• occ_tail :: !TailCallInfo

Instances

Eq OccInfo

Defined in BasicTypes

Methods

(==) :: OccInfo -> OccInfo -> Bool

(/=) :: OccInfo -> OccInfo -> Bool

Outputable OccInfo

Defined in BasicTypes

Methods

ppr :: OccInfo -> SDoc

pprPrec :: Rational -> OccInfo -> SDoc

noOccInfo :: OccInfo

seqOccInfo :: OccInfo -> ()

zapFragileOcc :: OccInfo -> OccInfo

isOneOcc :: OccInfo -> Bool

isDeadOcc :: OccInfo -> Bool

isStrongLoopBreaker :: OccInfo -> Bool

isWeakLoopBreaker :: OccInfo -> Bool

isManyOccs :: OccInfo -> Bool

strongLoopBreaker :: OccInfo

weakLoopBreaker :: OccInfo

type InsideLam = Bool

Inside Lambda

insideLam :: InsideLam

notInsideLam :: InsideLam

type OneBranch = Bool

oneBranch :: OneBranch

notOneBranch :: OneBranch

type InterestingCxt = Bool

Interesting Context

data TailCallInfo

Constructors

AlwaysTailCalled JoinArity

NoTailCallInfo

Instances

Eq TailCallInfo

Defined in BasicTypes

Methods

(==) :: TailCallInfo -> TailCallInfo -> Bool

(/=) :: TailCallInfo -> TailCallInfo -> Bool

Outputable TailCallInfo

Defined in BasicTypes

Methods

ppr :: TailCallInfo -> SDoc

pprPrec :: Rational -> TailCallInfo -> SDoc

tailCallInfo :: OccInfo -> TailCallInfo

zapOccTailCallInfo :: OccInfo -> OccInfo

isAlwaysTailCalled :: OccInfo -> Bool

data EP a

Embedding Projection pair

Constructors

EP

Fields

• fromEP :: a
• toEP :: a

data DefMethSpec ty

Default Method Specification

Constructors

VanillaDM

GenericDM ty

Instances

Outputable (DefMethSpec ty)

Defined in BasicTypes

Methods

ppr :: DefMethSpec ty -> SDoc

pprPrec :: Rational -> DefMethSpec ty -> SDoc

Binary (DefMethSpec IfaceType)

Defined in IfaceType

Methods

put_ :: BinHandle -> DefMethSpec IfaceType -> IO ()

put :: BinHandle -> DefMethSpec IfaceType -> IO (Bin (DefMethSpec IfaceType))

get :: BinHandle -> IO (DefMethSpec IfaceType)

data SwapFlag

Constructors

NotSwapped

IsSwapped

Instances

Outputable SwapFlag

Defined in BasicTypes

Methods

ppr :: SwapFlag -> SDoc

pprPrec :: Rational -> SwapFlag -> SDoc

flipSwap :: SwapFlag -> SwapFlag

unSwap :: SwapFlag -> (a -> a -> b) -> a -> a -> b

isSwapped :: SwapFlag -> Bool

data CompilerPhase

Constructors

Phase PhaseNum

InitialPhase

Instances

Outputable CompilerPhase

Defined in BasicTypes

Methods

ppr :: CompilerPhase -> SDoc

pprPrec :: Rational -> CompilerPhase -> SDoc

type PhaseNum = Int

Phase Number

data Activation

Constructors

NeverActive

AlwaysActive

ActiveBefore SourceText PhaseNum

ActiveAfter SourceText PhaseNum

Instances

Eq Activation

Defined in BasicTypes

Methods

(==) :: Activation -> Activation -> Bool

(/=) :: Activation -> Activation -> Bool

Data Activation

Defined in BasicTypes

Methods

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

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

toConstr :: Activation -> Constr

dataTypeOf :: Activation -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Activation

Defined in BasicTypes

Methods

ppr :: Activation -> SDoc

pprPrec :: Rational -> Activation -> SDoc

Binary Activation

Defined in Binary

Methods

put_ :: BinHandle -> Activation -> IO ()

put :: BinHandle -> Activation -> IO (Bin Activation)

get :: BinHandle -> IO Activation

isActive :: CompilerPhase -> Activation -> Bool

isActiveIn :: PhaseNum -> Activation -> Bool

competesWith :: Activation -> Activation -> Bool

isNeverActive :: Activation -> Bool

isAlwaysActive :: Activation -> Bool

isEarlyActive :: Activation -> Bool

activeAfterInitial :: Activation

activeDuringFinal :: Activation

data RuleMatchInfo

Rule Match Information

Constructors

ConLike

FunLike

Instances

Eq RuleMatchInfo

Defined in BasicTypes

Methods

(==) :: RuleMatchInfo -> RuleMatchInfo -> Bool

(/=) :: RuleMatchInfo -> RuleMatchInfo -> Bool

Data RuleMatchInfo

Defined in BasicTypes

Methods

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

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

toConstr :: RuleMatchInfo -> Constr

dataTypeOf :: RuleMatchInfo -> DataType

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

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

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

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

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

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

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

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

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

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

Show RuleMatchInfo

Defined in BasicTypes

Methods

showsPrec :: Int -> RuleMatchInfo -> ShowS

show :: RuleMatchInfo -> String

showList :: [RuleMatchInfo] -> ShowS

Outputable RuleMatchInfo

Defined in BasicTypes

Methods

ppr :: RuleMatchInfo -> SDoc

pprPrec :: Rational -> RuleMatchInfo -> SDoc

Binary RuleMatchInfo

Defined in Binary

Methods

put_ :: BinHandle -> RuleMatchInfo -> IO ()

put :: BinHandle -> RuleMatchInfo -> IO (Bin RuleMatchInfo)

get :: BinHandle -> IO RuleMatchInfo

isConLike :: RuleMatchInfo -> Bool

isFunLike :: RuleMatchInfo -> Bool

data InlineSpec

Inline Specification

Constructors

Inline

Inlinable

NoInline

NoUserInline

Instances

Eq InlineSpec

Defined in BasicTypes

Methods

(==) :: InlineSpec -> InlineSpec -> Bool

(/=) :: InlineSpec -> InlineSpec -> Bool

Data InlineSpec

Defined in BasicTypes

Methods

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

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

toConstr :: InlineSpec -> Constr

dataTypeOf :: InlineSpec -> DataType

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

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

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

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

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

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

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

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

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

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

Show InlineSpec

Defined in BasicTypes

Methods

showsPrec :: Int -> InlineSpec -> ShowS

show :: InlineSpec -> String

showList :: [InlineSpec] -> ShowS

Outputable InlineSpec

Defined in BasicTypes

Methods

ppr :: InlineSpec -> SDoc

pprPrec :: Rational -> InlineSpec -> SDoc

Binary InlineSpec

Defined in Binary

Methods

put_ :: BinHandle -> InlineSpec -> IO ()

put :: BinHandle -> InlineSpec -> IO (Bin InlineSpec)

get :: BinHandle -> IO InlineSpec

noUserInlineSpec :: InlineSpec -> Bool

data InlinePragma

Constructors

InlinePragma

Fields

• inl_src :: SourceText
• inl_inline :: InlineSpec
• inl_sat :: Maybe Arity
• inl_act :: Activation
• inl_rule :: RuleMatchInfo

Instances

Eq InlinePragma

Defined in BasicTypes

Methods

(==) :: InlinePragma -> InlinePragma -> Bool

(/=) :: InlinePragma -> InlinePragma -> Bool

Data InlinePragma

Defined in BasicTypes

Methods

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

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

toConstr :: InlinePragma -> Constr

dataTypeOf :: InlinePragma -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable InlinePragma

Defined in BasicTypes

Methods

ppr :: InlinePragma -> SDoc

pprPrec :: Rational -> InlinePragma -> SDoc

Binary InlinePragma

Defined in Binary

Methods

put_ :: BinHandle -> InlinePragma -> IO ()

put :: BinHandle -> InlinePragma -> IO (Bin InlinePragma)

get :: BinHandle -> IO InlinePragma

defaultInlinePragma :: InlinePragma

alwaysInlinePragma :: InlinePragma

neverInlinePragma :: InlinePragma

dfunInlinePragma :: InlinePragma

isDefaultInlinePragma :: InlinePragma -> Bool

isInlinePragma :: InlinePragma -> Bool

isInlinablePragma :: InlinePragma -> Bool

isAnyInlinePragma :: InlinePragma -> Bool

inlinePragmaSpec :: InlinePragma -> InlineSpec

inlinePragmaSat :: InlinePragma -> Maybe Arity

inlinePragmaActivation :: InlinePragma -> Activation

inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo

setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma

setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma

pprInline :: InlinePragma -> SDoc

pprInlineDebug :: InlinePragma -> SDoc

data SuccessFlag

Constructors

Succeeded

Failed

Instances

Outputable SuccessFlag

Defined in BasicTypes

Methods

ppr :: SuccessFlag -> SDoc

pprPrec :: Rational -> SuccessFlag -> SDoc

succeeded :: SuccessFlag -> Bool

failed :: SuccessFlag -> Bool

successIf :: Bool -> SuccessFlag

data IntegralLit

Integral Literal

Used (instead of Integer) to represent negative zegative zero which is required for NegativeLiterals extension to correctly parse `-0::Double` as negative zero. See also #13211.

Constructors

IL

Fields

• il_text :: SourceText
• il_neg :: Bool
• il_value :: Integer

Instances

Eq IntegralLit

Defined in BasicTypes

Methods

(==) :: IntegralLit -> IntegralLit -> Bool

(/=) :: IntegralLit -> IntegralLit -> Bool

Data IntegralLit

Defined in BasicTypes

Methods

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

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

toConstr :: IntegralLit -> Constr

dataTypeOf :: IntegralLit -> DataType

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

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

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

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

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

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

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

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

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

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

Ord IntegralLit

Defined in BasicTypes

Methods

compare :: IntegralLit -> IntegralLit -> Ordering

(<) :: IntegralLit -> IntegralLit -> Bool

(<=) :: IntegralLit -> IntegralLit -> Bool

(>) :: IntegralLit -> IntegralLit -> Bool

(>=) :: IntegralLit -> IntegralLit -> Bool

max :: IntegralLit -> IntegralLit -> IntegralLit

min :: IntegralLit -> IntegralLit -> IntegralLit

Show IntegralLit

Defined in BasicTypes

Methods

showsPrec :: Int -> IntegralLit -> ShowS

show :: IntegralLit -> String

showList :: [IntegralLit] -> ShowS

Outputable IntegralLit

Defined in BasicTypes

Methods

ppr :: IntegralLit -> SDoc

pprPrec :: Rational -> IntegralLit -> SDoc

data FractionalLit

Fractional Literal

Used (instead of Rational) to represent exactly the floating point literal that we encountered in the user's source program. This allows us to pretty-print exactly what the user wrote, which is important e.g. for floating point numbers that can't represented as Doubles (we used to via Double for pretty-printing). See also #2245.

Constructors

FL

Fields

• fl_text :: SourceText
• fl_neg :: Bool
• fl_value :: Rational

Instances

Eq FractionalLit

Defined in BasicTypes

Methods

(==) :: FractionalLit -> FractionalLit -> Bool

(/=) :: FractionalLit -> FractionalLit -> Bool

Data FractionalLit

Defined in BasicTypes

Methods

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

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

toConstr :: FractionalLit -> Constr

dataTypeOf :: FractionalLit -> DataType

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

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

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

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

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

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

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

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

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

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

Ord FractionalLit

Defined in BasicTypes

Methods

compare :: FractionalLit -> FractionalLit -> Ordering

(<) :: FractionalLit -> FractionalLit -> Bool

(<=) :: FractionalLit -> FractionalLit -> Bool

(>) :: FractionalLit -> FractionalLit -> Bool

(>=) :: FractionalLit -> FractionalLit -> Bool

max :: FractionalLit -> FractionalLit -> FractionalLit

min :: FractionalLit -> FractionalLit -> FractionalLit

Show FractionalLit

Defined in BasicTypes

Methods

showsPrec :: Int -> FractionalLit -> ShowS

show :: FractionalLit -> String

showList :: [FractionalLit] -> ShowS

Outputable FractionalLit

Defined in BasicTypes

Methods

ppr :: FractionalLit -> SDoc

pprPrec :: Rational -> FractionalLit -> SDoc

negateIntegralLit :: IntegralLit -> IntegralLit

negateFractionalLit :: FractionalLit -> FractionalLit

mkIntegralLit :: Integral a => a -> IntegralLit

mkFractionalLit :: Real a => a -> FractionalLit

integralFractionalLit :: Bool -> Integer -> FractionalLit

data SourceText

Constructors

SourceText String

NoSourceText

For when code is generated, e.g. TH, deriving. The pretty printer will then make its own representation of the item.

Instances

Eq SourceText

Defined in BasicTypes

Methods

(==) :: SourceText -> SourceText -> Bool

(/=) :: SourceText -> SourceText -> Bool

Data SourceText

Defined in BasicTypes

Methods

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

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

toConstr :: SourceText -> Constr

dataTypeOf :: SourceText -> DataType

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

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

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

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

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

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

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

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

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

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

Show SourceText

Defined in BasicTypes

Methods

showsPrec :: Int -> SourceText -> ShowS

show :: SourceText -> String

showList :: [SourceText] -> ShowS

Outputable SourceText

Defined in BasicTypes

Methods

ppr :: SourceText -> SDoc

pprPrec :: Rational -> SourceText -> SDoc

Binary SourceText

Defined in Binary

Methods

put_ :: BinHandle -> SourceText -> IO ()

put :: BinHandle -> SourceText -> IO (Bin SourceText)

get :: BinHandle -> IO SourceText

pprWithSourceText :: SourceText -> SDoc -> SDoc

Special combinator for showing string literals.

data IntWithInf

An integer or infinity

Instances

Eq IntWithInf

Defined in BasicTypes

Methods

(==) :: IntWithInf -> IntWithInf -> Bool

(/=) :: IntWithInf -> IntWithInf -> Bool

Num IntWithInf

Defined in BasicTypes

Methods

(+) :: IntWithInf -> IntWithInf -> IntWithInf

(-) :: IntWithInf -> IntWithInf -> IntWithInf

(*) :: IntWithInf -> IntWithInf -> IntWithInf

negate :: IntWithInf -> IntWithInf

abs :: IntWithInf -> IntWithInf

signum :: IntWithInf -> IntWithInf

fromInteger :: Integer -> IntWithInf

Ord IntWithInf

Defined in BasicTypes

Methods

compare :: IntWithInf -> IntWithInf -> Ordering

(<) :: IntWithInf -> IntWithInf -> Bool

(<=) :: IntWithInf -> IntWithInf -> Bool

(>) :: IntWithInf -> IntWithInf -> Bool

(>=) :: IntWithInf -> IntWithInf -> Bool

max :: IntWithInf -> IntWithInf -> IntWithInf

min :: IntWithInf -> IntWithInf -> IntWithInf

Outputable IntWithInf

Defined in BasicTypes

Methods

ppr :: IntWithInf -> SDoc

pprPrec :: Rational -> IntWithInf -> SDoc

infinity :: IntWithInf

A representation of infinity

treatZeroAsInf :: Int -> IntWithInf

Turn a positive number into an IntWithInf, where 0 represents infinity

mkIntWithInf :: Int -> IntWithInf

Inject any integer into an IntWithInf

intGtLimit :: Int -> IntWithInf -> Bool

data SpliceExplicitFlag

Constructors

ExplicitSplice

= $(f x y)

ImplicitSplice

= f x y, i.e. a naked top level expression

Instances

Data SpliceExplicitFlag

Defined in BasicTypes

Methods

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

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

toConstr :: SpliceExplicitFlag -> Constr

dataTypeOf :: SpliceExplicitFlag -> DataType

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

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

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

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

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

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

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

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

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

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

data TypeOrKind

Flag to see whether we're type-checking terms or kind-checking types

Constructors

TypeLevel

KindLevel

Instances

Eq TypeOrKind

Defined in BasicTypes

Methods

(==) :: TypeOrKind -> TypeOrKind -> Bool

(/=) :: TypeOrKind -> TypeOrKind -> Bool

Outputable TypeOrKind

Defined in BasicTypes

Methods

ppr :: TypeOrKind -> SDoc

pprPrec :: Rational -> TypeOrKind -> SDoc

isTypeLevel :: TypeOrKind -> Bool

isKindLevel :: TypeOrKind -> Bool