Debug.Breakpoint.GhcFacade

Documentation

class Monad m => MonadFix (m :: Type -> Type) where

Monads having fixed points with a 'knot-tying' semantics. Instances of MonadFix should satisfy the following laws:

Purity

mfix (return . h) = return (fix h)

Left shrinking (or Tightening)

mfix (\x -> a >>= \y -> f x y) = a >>= \y -> mfix (\x -> f x y)

Sliding

mfix (liftM h . f) = liftM h (mfix (f . h)), for strict h.

Nesting

mfix (\x -> mfix (\y -> f x y)) = mfix (\x -> f x x)

This class is used in the translation of the recursive do notation supported by GHC and Hugs.

Methods

mfix :: (a -> m a) -> m a

The fixed point of a monadic computation. mfix f executes the action f only once, with the eventual output fed back as the input. Hence f should not be strict, for then mfix f would diverge.

Instances

MonadFix First

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> First a) -> First a

MonadFix Last

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Last a) -> Last a

MonadFix Down

Since: base-4.12.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Down a) -> Down a

MonadFix Dual

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Dual a) -> Dual a

MonadFix Product

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Product a) -> Product a

MonadFix Sum

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Sum a) -> Sum a

MonadFix Par1

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Par1 a) -> Par1 a

MonadFix UniqSM

Defined in GHC.Types.Unique.Supply

Methods

mfix :: (a -> UniqSM a) -> UniqSM a

MonadFix IO

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> IO a) -> IO a

MonadFix Q

If the function passed to mfix inspects its argument, the resulting action will throw a FixIOException.

Since: template-haskell-2.17.0.0

Defined in Language.Haskell.TH.Syntax

Methods

mfix :: (a -> Q a) -> Q a

MonadFix NonEmpty

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> NonEmpty a) -> NonEmpty a

MonadFix Maybe

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Maybe a) -> Maybe a

MonadFix Solo

Since: base-4.15

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Solo a) -> Solo a

MonadFix []

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> [a]) -> [a]

MonadFix (Either e)

Since: base-4.3.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Either e a) -> Either e a

MonadFix (ST s)

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> ST s a) -> ST s a

MonadFix (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

mfix :: (a -> IOEnv env a) -> IOEnv env a

MonadFix m => MonadFix (InputT m)

Defined in System.Console.Haskeline.InputT

Methods

mfix :: (a -> InputT m a) -> InputT m a

MonadFix m => MonadFix (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

mfix :: (a -> MaybeT m a) -> MaybeT m a

MonadFix f => MonadFix (Ap f)

Since: base-4.12.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Ap f a) -> Ap f a

MonadFix f => MonadFix (Alt f)

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Alt f a) -> Alt f a

MonadFix f => MonadFix (Rec1 f)

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Rec1 f a) -> Rec1 f a

(MonadFix m, Error e) => MonadFix (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

mfix :: (a -> ErrorT e m a) -> ErrorT e m a

MonadFix m => MonadFix (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mfix :: (a -> ReaderT r m a) -> ReaderT r m a

MonadFix m => MonadFix (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS

Methods

mfix :: (a -> WriterT w m a) -> WriterT w m a

(MonadFix f, MonadFix g) => MonadFix (f :*: g)

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> (f :*: g) a) -> (f :*: g) a

MonadFix ((->) r)

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> r -> a) -> r -> a

MonadFix f => MonadFix (M1 i c f)

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> M1 i c f a) -> M1 i c f a

class Functor f => Applicative (f :: Type -> Type) where

A functor with application, providing operations to

• embed pure expressions (pure), and
• sequence computations and combine their results (<*> and liftA2).

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id

liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

Identity

pure id <*> v = v

Composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

Homomorphism

pure f <*> pure x = pure (f x)

Interchange

u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

• u *> v = (id <$ u) <*> v

• u <* v = liftA2 const u v

As a consequence of these laws, the Functor instance for f will satisfy

• fmap f x = pure f <*> x

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If f is also a Monad, it should satisfy

• pure = return

• m1 <*> m2 = m1 >>= (x1 -> m2 >>= (x2 -> return (x1 x2)))

• (*>) = (>>)

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b infixl 4

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Example

Used in combination with (<$>), (<*>) can be used to build a record.

>>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

>>> produceFoo :: Applicative f => f Foo

>>> produceBar :: Applicative f => f Bar
>>> produceBaz :: Applicative f => f Baz

>>> mkState :: Applicative f => f MyState
>>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

liftA2 :: (a -> b -> c) -> f a -> f b -> f c

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

This became a typeclass method in 4.10.0.0. Prior to that, it was a function defined in terms of <*> and fmap.

Example

>>> liftA2 (,) (Just 3) (Just 5)
Just (3,5)

(*>) :: f a -> f b -> f b infixl 4

Sequence actions, discarding the value of the first argument.

Examples

If used in conjunction with the Applicative instance for Maybe, you can chain Maybe computations, with a possible "early return" in case of Nothing.

>>> Just 2 *> Just 3
Just 3

>>> Nothing *> Just 3
Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

>>> import Data.Char
>>> import Text.ParserCombinators.ReadP
>>> let p = string "my name is " *> munch1 isAlpha <* eof
>>> readP_to_S p "my name is Simon"
[("Simon","")]

(<*) :: f a -> f b -> f a infixl 4

Sequence actions, discarding the value of the second argument.

Instances

Applicative ZipList

f <$> ZipList xs1 <*> ... <*> ZipList xsN
    = ZipList (zipWithN f xs1 ... xsN)

where zipWithN refers to the zipWith function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example:

(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
    = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
    = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> ZipList a

(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b

liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

(*>) :: ZipList a -> ZipList b -> ZipList b

(<*) :: ZipList a -> ZipList b -> ZipList a

Applicative First

Since: base-4.8.0.0

Defined in Data.Monoid

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Since: base-4.8.0.0

Defined in Data.Monoid

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

pure :: a -> Down a

(<*>) :: Down (a -> b) -> Down a -> Down b

liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c

(*>) :: Down a -> Down b -> Down b

(<*) :: Down a -> Down b -> Down a

Applicative Dual

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Dual a

(<*>) :: Dual (a -> b) -> Dual a -> Dual b

liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c

(*>) :: Dual a -> Dual b -> Dual b

(<*) :: Dual a -> Dual b -> Dual a

Applicative Product

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Product a

(<*>) :: Product (a -> b) -> Product a -> Product b

liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c

(*>) :: Product a -> Product b -> Product b

(<*) :: Product a -> Product b -> Product a

Applicative Sum

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Sum a

(<*>) :: Sum (a -> b) -> Sum a -> Sum b

liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c

(*>) :: Sum a -> Sum b -> Sum b

(<*) :: Sum a -> Sum b -> Sum a

Applicative Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Par1 a

(<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b

liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c

(*>) :: Par1 a -> Par1 b -> Par1 b

(<*) :: Par1 a -> Par1 b -> Par1 a

Applicative P

Since: base-4.5.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> P a

(<*>) :: P (a -> b) -> P a -> P b

liftA2 :: (a -> b -> c) -> P a -> P b -> P c

(*>) :: P a -> P b -> P b

(<*) :: P a -> P b -> P a

Applicative ReadP

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> ReadP a

(<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b

liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c

(*>) :: ReadP a -> ReadP b -> ReadP b

(<*) :: ReadP a -> ReadP b -> ReadP a

Applicative NormM

Defined in GHC.Core.FamInstEnv

Methods

pure :: a -> NormM a

(<*>) :: NormM (a -> b) -> NormM a -> NormM b

liftA2 :: (a -> b -> c) -> NormM a -> NormM b -> NormM c

(*>) :: NormM a -> NormM b -> NormM b

(<*) :: NormM a -> NormM b -> NormM a

Applicative UM

Defined in GHC.Core.Unify

Methods

pure :: a -> UM a

(<*>) :: UM (a -> b) -> UM a -> UM b

liftA2 :: (a -> b -> c) -> UM a -> UM b -> UM c

(*>) :: UM a -> UM b -> UM b

(<*) :: UM a -> UM b -> UM a

Applicative UnifyResultM

Defined in GHC.Core.Unify

Methods

pure :: a -> UnifyResultM a

(<*>) :: UnifyResultM (a -> b) -> UnifyResultM a -> UnifyResultM b

liftA2 :: (a -> b -> c) -> UnifyResultM a -> UnifyResultM b -> UnifyResultM c

(*>) :: UnifyResultM a -> UnifyResultM b -> UnifyResultM b

(<*) :: UnifyResultM a -> UnifyResultM b -> UnifyResultM a

Applicative Pair

Defined in GHC.Data.Pair

Methods

pure :: a -> Pair a

(<*>) :: Pair (a -> b) -> Pair a -> Pair b

liftA2 :: (a -> b -> c) -> Pair a -> Pair b -> Pair c

(*>) :: Pair a -> Pair b -> Pair b

(<*) :: Pair a -> Pair b -> Pair a

Applicative Hsc

Defined in GHC.Driver.Env.Types

Methods

pure :: a -> Hsc a

(<*>) :: Hsc (a -> b) -> Hsc a -> Hsc b

liftA2 :: (a -> b -> c) -> Hsc a -> Hsc b -> Hsc c

(*>) :: Hsc a -> Hsc b -> Hsc b

(<*) :: Hsc a -> Hsc b -> Hsc a

Applicative PV

Defined in GHC.Parser.PostProcess

Methods

pure :: a -> PV a

(<*>) :: PV (a -> b) -> PV a -> PV b

liftA2 :: (a -> b -> c) -> PV a -> PV b -> PV c

(*>) :: PV a -> PV b -> PV b

(<*) :: PV a -> PV b -> PV a

Applicative TcPluginM

Defined in GHC.Tc.Types

Methods

pure :: a -> TcPluginM a

(<*>) :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b

liftA2 :: (a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c

(*>) :: TcPluginM a -> TcPluginM b -> TcPluginM b

(<*) :: TcPluginM a -> TcPluginM b -> TcPluginM a

Applicative UniqSM

Defined in GHC.Types.Unique.Supply

Methods

pure :: a -> UniqSM a

(<*>) :: UniqSM (a -> b) -> UniqSM a -> UniqSM b

liftA2 :: (a -> b -> c) -> UniqSM a -> UniqSM b -> UniqSM c

(*>) :: UniqSM a -> UniqSM b -> UniqSM b

(<*) :: UniqSM a -> UniqSM b -> UniqSM a

Applicative IO

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> IO a

(<*>) :: IO (a -> b) -> IO a -> IO b

liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c

(*>) :: IO a -> IO b -> IO b

(<*) :: IO a -> IO b -> IO a

Applicative Q

Defined in Language.Haskell.TH.Syntax

Methods

pure :: a -> Q a

(<*>) :: Q (a -> b) -> Q a -> Q b

liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c

(*>) :: Q a -> Q b -> Q b

(<*) :: Q a -> Q b -> Q a

Applicative NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

pure :: a -> NonEmpty a

(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b

liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a

Applicative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Applicative Solo

Since: base-4.15

Defined in GHC.Base

Methods

pure :: a -> Solo a

(<*>) :: Solo (a -> b) -> Solo a -> Solo b

liftA2 :: (a -> b -> c) -> Solo a -> Solo b -> Solo c

(*>) :: Solo a -> Solo b -> Solo b

(<*) :: Solo a -> Solo b -> Solo a

Applicative []

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> [a]

(<*>) :: [a -> b] -> [a] -> [b]

liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c]

(*>) :: [a] -> [b] -> [b]

(<*) :: [a] -> [b] -> [a]

Monad m => Applicative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> WrappedMonad m a

(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

Arrow a => Applicative (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> ArrowMonad a a0

(<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c

(*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b

(<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0

Applicative (Either e)

Since: base-3.0

Defined in Data.Either

Methods

pure :: a -> Either e a

(<*>) :: Either e (a -> b) -> Either e a -> Either e b

liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c

(*>) :: Either e a -> Either e b -> Either e b

(<*) :: Either e a -> Either e b -> Either e a

Applicative (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

pure :: a -> Proxy a

(<*>) :: Proxy (a -> b) -> Proxy a -> Proxy b

liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

(*>) :: Proxy a -> Proxy b -> Proxy b

(<*) :: Proxy a -> Proxy b -> Proxy a

Applicative (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> U1 a

(<*>) :: U1 (a -> b) -> U1 a -> U1 b

liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c

(*>) :: U1 a -> U1 b -> U1 b

(<*) :: U1 a -> U1 b -> U1 a

Applicative (SetM s)

Defined in Data.Graph

Methods

pure :: a -> SetM s a

(<*>) :: SetM s (a -> b) -> SetM s a -> SetM s b

liftA2 :: (a -> b -> c) -> SetM s a -> SetM s b -> SetM s c

(*>) :: SetM s a -> SetM s b -> SetM s b

(<*) :: SetM s a -> SetM s b -> SetM s a

Applicative (IOEnv m)

Defined in GHC.Data.IOEnv

Methods

pure :: a -> IOEnv m a

(<*>) :: IOEnv m (a -> b) -> IOEnv m a -> IOEnv m b

liftA2 :: (a -> b -> c) -> IOEnv m a -> IOEnv m b -> IOEnv m c

(*>) :: IOEnv m a -> IOEnv m b -> IOEnv m b

(<*) :: IOEnv m a -> IOEnv m b -> IOEnv m a

Applicative (MaybeErr err)

Defined in GHC.Data.Maybe

Methods

pure :: a -> MaybeErr err a

(<*>) :: MaybeErr err (a -> b) -> MaybeErr err a -> MaybeErr err b

liftA2 :: (a -> b -> c) -> MaybeErr err a -> MaybeErr err b -> MaybeErr err c

(*>) :: MaybeErr err a -> MaybeErr err b -> MaybeErr err b

(<*) :: MaybeErr err a -> MaybeErr err b -> MaybeErr err a

Applicative m => Applicative (InputT m)

Defined in System.Console.Haskeline.InputT

Methods

pure :: a -> InputT m a

(<*>) :: InputT m (a -> b) -> InputT m a -> InputT m b

liftA2 :: (a -> b -> c) -> InputT m a -> InputT m b -> InputT m c

(*>) :: InputT m a -> InputT m b -> InputT m b

(<*) :: InputT m a -> InputT m b -> InputT m a

(Functor m, Monad m) => Applicative (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

pure :: a -> MaybeT m a

(<*>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b

liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c

(*>) :: MaybeT m a -> MaybeT m b -> MaybeT m b

(<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a

Monoid a => Applicative ((,) a)

For tuples, the Monoid constraint on a determines how the first values merge. For example, Strings concatenate:

("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a0 -> (a, a0)

(<*>) :: (a, a0 -> b) -> (a, a0) -> (a, b)

liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c)

(*>) :: (a, a0) -> (a, b) -> (a, b)

(<*) :: (a, a0) -> (a, b) -> (a, a0)

Arrow a => Applicative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a0 -> WrappedArrow a b a0

(<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c

(*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0

(<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

Applicative m => Applicative (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> Kleisli m a a0

(<*>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b

liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c

(*>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b

(<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0

Applicative f => Applicative (Ap f)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

pure :: a -> Ap f a

(<*>) :: Ap f (a -> b) -> Ap f a -> Ap f b

liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c

(*>) :: Ap f a -> Ap f b -> Ap f b

(<*) :: Ap f a -> Ap f b -> Ap f a

Applicative f => Applicative (Alt f)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Alt f a

(<*>) :: Alt f (a -> b) -> Alt f a -> Alt f b

liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c

(*>) :: Alt f a -> Alt f b -> Alt f b

(<*) :: Alt f a -> Alt f b -> Alt f a

Applicative f => Applicative (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Rec1 f a

(<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b

liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c

(*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

(<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a

(Functor m, Monad m) => Applicative (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

pure :: a -> ErrorT e m a

(<*>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b

liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c

(*>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b

(<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a

Applicative m => Applicative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

pure :: a -> ReaderT r m a

(<*>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b

liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c

(*>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b

(<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a

(Functor m, Monad m) => Applicative (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS

Methods

pure :: a -> WriterT w m a

(<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

(*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a

(Monoid a, Monoid b) => Applicative ((,,) a b)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

pure :: a0 -> (a, b, a0)

(<*>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0)

liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c)

(*>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0)

(<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0)

(Applicative f, Applicative g) => Applicative (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :*: g) a

(<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b

liftA2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c

(*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

(<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a

Monoid c => Applicative (K1 i c :: Type -> Type)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

pure :: a -> K1 i c a

(<*>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b

liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0

(*>) :: K1 i c a -> K1 i c b -> K1 i c b

(<*) :: K1 i c a -> K1 i c b -> K1 i c a

(Applicative f, Monad f) => Applicative (WhenMissing f k x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)) .

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

pure :: a -> WhenMissing f k x a

(<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b

liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c

(*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b

(<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a

(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

pure :: a0 -> (a, b, c, a0)

(<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0)

liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0)

(*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0)

(<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0)

Applicative ((->) r)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> r -> a

(<*>) :: (r -> (a -> b)) -> (r -> a) -> r -> b

liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c

(*>) :: (r -> a) -> (r -> b) -> r -> b

(<*) :: (r -> a) -> (r -> b) -> r -> a

(Applicative f, Applicative g) => Applicative (f :.: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :.: g) a

(<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b

liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c

(*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b

(<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a

Applicative f => Applicative (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> M1 i c f a

(<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b

liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0

(*>) :: M1 i c f a -> M1 i c f b -> M1 i c f b

(<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a

(Monad f, Applicative f) => Applicative (WhenMatched f k x y)

Equivalent to ReaderT k (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

pure :: a -> WhenMatched f k x y a

(<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c

(*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b

(<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a

data Plugin

Plugin is the compiler plugin data type. Try to avoid constructing one of these directly, and just modify some fields of defaultPlugin instead: this is to try and preserve source-code compatibility when we add fields to this.

Nonetheless, this API is preliminary and highly likely to change in the future.

Constructors

Plugin

Fields

• installCoreToDos :: CorePlugin

  Modify the Core pipeline that will be used for compilation. This is called as the Core pipeline is built for every module being compiled, and plugins get the opportunity to modify the pipeline in a nondeterministic order.

• tcPlugin :: TcPlugin

  An optional typechecker plugin, which may modify the behaviour of the constraint solver.

• holeFitPlugin :: HoleFitPlugin

  An optional plugin to handle hole fits, which may re-order or change the list of valid hole fits and refinement hole fits.

• driverPlugin :: [CommandLineOption] -> HscEnv -> IO HscEnv

  An optional plugin to update HscEnv, right after plugin loading. This can be used to register hooks or tweak any field of DynFlags before doing actual work on a module.

  Since: ghc-8.10.1

• pluginRecompile :: [CommandLineOption] -> IO PluginRecompile

  Specify how the plugin should affect recompilation.

• parsedResultAction :: [CommandLineOption] -> ModSummary -> HsParsedModule -> Hsc HsParsedModule

  Modify the module when it is parsed. This is called by GHC.Driver.Main when the parsing is successful.

• renamedResultAction :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)

  Modify each group after it is renamed. This is called after each HsGroup has been renamed.

• typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv

  Modify the module when it is type checked. This is called at the very end of typechecking.

• spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)

  Modify the TH splice or quasiqoute before it is run.

• interfaceLoadAction :: forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface

  Modify an interface that have been loaded. This is called by GHC.Iface.Load when an interface is successfully loaded. Not applied to the loading of the plugin interface. Tools that rely on information from modules other than the currently compiled one should implement this function.

data FrontendPlugin

Constructors

FrontendPlugin

Fields

• frontend :: FrontendPluginAction

class Monad m => MonadIO (m :: Type -> Type) where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Instances

MonadIO Hsc

Defined in GHC.Driver.Env.Types

Methods

liftIO :: IO a -> Hsc a

MonadIO IO

Since: base-4.9.0.0

Defined in Control.Monad.IO.Class

Methods

liftIO :: IO a -> IO a

MonadIO Q

Defined in Language.Haskell.TH.Syntax

Methods

liftIO :: IO a -> Q a

MonadIO (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

liftIO :: IO a -> IOEnv env a

MonadIO m => MonadIO (InputT m)

Defined in System.Console.Haskeline.InputT

Methods

liftIO :: IO a -> InputT m a

MonadIO m => MonadIO (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

liftIO :: IO a -> MaybeT m a

(Error e, MonadIO m) => MonadIO (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftIO :: IO a -> ErrorT e m a

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

MonadIO m => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS

Methods

liftIO :: IO a -> WriterT w m a

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])

The mapAndUnzipM function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state monad.

data IORef a

A mutable variable in the IO monad

Instances

Eq (IORef a)

Pointer equality.

Since: base-4.0.0.0

Defined in GHC.IORef

Methods

(==) :: IORef a -> IORef a -> Bool

(/=) :: IORef a -> IORef a -> Bool

(MonadIO m, MonadMask m) => CommandMonad (InputCmdT m)

Defined in System.Console.Haskeline.InputT

Methods

runCompletion :: (String, String) -> InputCmdT m (String, [Completion])

foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b

Right-to-left monadic fold over the elements of a structure.

Given a structure t with elements (a, b, c, ..., x, y), the result of a fold with an operator function f is equivalent to:

foldrM f z t = do
    yy <- f y z
    xx <- f x yy
    ...
    bb <- f b cc
    aa <- f a bb
    return aa -- Just @return z@ when the structure is empty

For a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c, their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:

(f1 >=> f2) a = f1 a >>= f2

Another way of thinking about foldrM is that it amounts to an application to z of a Kleisli composition:

foldrM f z t = f y >=> f x >=> ... >=> f b >=> f a $ z

The monadic effects of foldrM are sequenced from right to left, and e.g. folds of infinite lists will diverge.

If at some step the bind operator (>>=) short-circuits (as with, e.g., mzero in a MonadPlus), the evaluated effects will be from a tail of the element sequence. If you want to evaluate the monadic effects in left-to-right order, or perhaps be able to short-circuit after an initial sequence of elements, you'll need to use foldlM instead.

If the monadic effects don't short-circuit, the outermost application of f is to the leftmost element a, so that, ignoring effects, the result looks like a right fold:

a `f` (b `f` (c `f` (... (x `f` (y `f` z))))).

Examples

Basic usage:

>>> let f i acc = do { print i ; return $ i : acc }
>>> foldrM f [] [0..3]
3
2
1
0
[0,1,2,3]

foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b

Left-to-right monadic fold over the elements of a structure.

Given a structure t with elements (a, b, ..., w, x, y), the result of a fold with an operator function f is equivalent to:

foldlM f z t = do
    aa <- f z a
    bb <- f aa b
    ...
    xx <- f ww x
    yy <- f xx y
    return yy -- Just @return z@ when the structure is empty

For a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c, their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:

(f1 >=> f2) a = f1 a >>= f2

Another way of thinking about foldlM is that it amounts to an application to z of a Kleisli composition:

foldlM f z t =
    flip f a >=> flip f b >=> ... >=> flip f x >=> flip f y $ z

The monadic effects of foldlM are sequenced from left to right.

If at some step the bind operator (>>=) short-circuits (as with, e.g., mzero in a MonadPlus), the evaluated effects will be from an initial segment of the element sequence. If you want to evaluate the monadic effects in right-to-left order, or perhaps be able to short-circuit after processing a tail of the sequence of elements, you'll need to use foldrM instead.

If the monadic effects don't short-circuit, the outermost application of f is to the rightmost element y, so that, ignoring effects, the result looks like a left fold:

((((z `f` a) `f` b) ... `f` w) `f` x) `f` y

Examples

Basic usage:

>>> let f a e = do { print e ; return $ e : a }
>>> foldlM f [] [0..3]
0
1
2
3
[3,2,1,0]

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

Double each element of a list:

>>> (*2) <$> [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)
(2,True)

pprTypeForUser :: Type -> SDoc

pprTyThingLoc :: TyThing -> SDoc

Pretty-prints a TyThing with its defining location.

pprTyThingInContextLoc :: TyThing -> SDoc

Like pprTyThingInContext, but adds the defining location.

pprTyThingInContext :: ShowSub -> TyThing -> SDoc

Pretty-prints a TyThing in context: that is, if the entity is a data constructor, record selector, or class method, then the entity's parent declaration is pretty-printed with irrelevant parts omitted.

pprTyThingHdr :: TyThing -> SDoc

Pretty-prints the TyThing header. For functions and data constructors the function is equivalent to pprTyThing but for type constructors and classes it prints only the header part of the declaration.

pprTyThing :: ShowSub -> TyThing -> SDoc

Pretty-prints a TyThing.

pprFamInst :: FamInst -> SDoc

Pretty-prints a FamInst (type/data family instance) with its defining location.

rnValBindsRHS :: HsSigCtxt -> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)

rnTopBindsLHS :: MiniFixityEnv -> HsValBinds GhcPs -> RnM (HsValBindsLR GhcRn GhcPs)

rnTopBindsBoot :: NameSet -> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)

rnSrcFixityDecl :: HsSigCtxt -> FixitySig GhcPs -> RnM (FixitySig GhcRn)

rnMethodBinds :: Bool -> Name -> [Name] -> LHsBinds GhcPs -> [LSig GhcPs] -> RnM (LHsBinds GhcRn, [LSig GhcRn], FreeVars)

rnMatchGroup :: (Outputable (body GhcPs), AnnoBody body) => HsMatchContext GhcRn -> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars)) -> MatchGroup GhcPs (LocatedA (body GhcPs)) -> RnM (MatchGroup GhcRn (LocatedA (body GhcRn)), FreeVars)

rnLocalValBindsRHS :: NameSet -> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)

rnLocalValBindsLHS :: MiniFixityEnv -> HsValBinds GhcPs -> RnM ([Name], HsValBindsLR GhcRn GhcPs)

rnLocalBindsAndThen :: HsLocalBinds GhcPs -> (HsLocalBinds GhcRn -> FreeVars -> RnM (result, FreeVars)) -> RnM (result, FreeVars)

rnGRHSs :: AnnoBody body => HsMatchContext GhcRn -> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars)) -> GRHSs GhcPs (LocatedA (body GhcPs)) -> RnM (GRHSs GhcRn (LocatedA (body GhcRn)), FreeVars)

rnGRHS :: AnnoBody body => HsMatchContext GhcRn -> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars)) -> LGRHS GhcPs (LocatedA (body GhcPs)) -> RnM (LGRHS GhcRn (LocatedA (body GhcRn)), FreeVars)

renameSigs :: HsSigCtxt -> [LSig GhcPs] -> RnM ([LSig GhcRn], FreeVars)

makeMiniFixityEnv :: [LFixitySig GhcPs] -> RnM MiniFixityEnv

data HsSigCtxt

Constructors

TopSigCtxt NameSet

LocalBindCtxt NameSet

ClsDeclCtxt Name

InstDeclCtxt NameSet

HsBootCtxt NameSet

RoleAnnotCtxt NameSet

Instances

Outputable HsSigCtxt

Defined in GHC.Rename.Env

Methods

ppr :: HsSigCtxt -> SDoc

type MiniFixityEnv = FastStringEnv (Located Fixity)

data PluginWithArgs

Constructors

PluginWithArgs

Fields

• paPlugin :: Plugin

  the actual callable plugin

• paArguments :: [CommandLineOption]

  command line arguments for the plugin

data PluginRecompile

Constructors

ForceRecompile

NoForceRecompile

MaybeRecompile Fingerprint

Instances

Monoid PluginRecompile

Defined in GHC.Driver.Plugins

Methods

mempty :: PluginRecompile

mappend :: PluginRecompile -> PluginRecompile -> PluginRecompile

mconcat :: [PluginRecompile] -> PluginRecompile

Semigroup PluginRecompile

Defined in GHC.Driver.Plugins

Methods

(<>) :: PluginRecompile -> PluginRecompile -> PluginRecompile

sconcat :: NonEmpty PluginRecompile -> PluginRecompile

stimes :: Integral b => b -> PluginRecompile -> PluginRecompile

Outputable PluginRecompile

Defined in GHC.Driver.Plugins

Methods

ppr :: PluginRecompile -> SDoc

type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()

type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]

type CommandLineOption = String

Command line options gathered from the -PModule.Name:stuff syntax are given to you as this type

withPlugins_ :: Monad m => HscEnv -> ConstPluginOperation m a -> a -> m ()

Perform a constant operation by using all of the plugins in turn.

withPlugins :: Monad m => HscEnv -> PluginOperation m a -> a -> m a

Perform an operation by using all of the plugins in turn.

purePlugin :: [CommandLineOption] -> IO PluginRecompile

plugins :: HscEnv -> [PluginWithArgs]

pluginRecompile' :: PluginWithArgs -> IO PluginRecompile

mapPlugins :: HscEnv -> (Plugin -> [CommandLineOption] -> a) -> [a]

lpModuleName :: LoadedPlugin -> ModuleName

keepRenamedSource :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)

A renamer plugin which mades the renamed source available in a typechecker plugin.

impurePlugin :: [CommandLineOption] -> IO PluginRecompile

flagRecompile :: [CommandLineOption] -> IO PluginRecompile

defaultPlugin :: Plugin

Default plugin: does nothing at all, except for marking that safe inference has failed unless -fplugin-trustworthy is passed. For compatibility reason you should base all your plugin definitions on this default value.

defaultFrontendPlugin :: FrontendPlugin

data HoleFitPluginR

HoleFitPluginR adds a TcRef to hole fit plugins so that plugins can track internal state. Note the existential quantification, ensuring that the state cannot be modified from outside the plugin.

newtype NameCacheUpdater

A function that atomically updates the name cache given a modifier function. The second result of the modifier function will be the result of the IO action.

Constructors

NCU

Fields

• updateNameCache :: forall c. (NameCache -> (NameCache, c)) -> IO c

updNameCacheTc :: Module -> OccName -> (NameCache -> (NameCache, c)) -> TcRnIf a b c

updNameCache :: IORef NameCache -> (NameCache -> (NameCache, c)) -> IO c

tcIfaceTyVar :: FastString -> IfL TyVar

tcIfaceLclId :: FastString -> IfL Id

setNameModule :: Maybe Module -> Name -> TcRnIf m n Name

Set the Module of a Name.

newInteractiveBinder :: HscEnv -> OccName -> SrcSpan -> IO Name

newIfaceNames :: [OccName] -> IfL [Name]

newIfaceName :: OccName -> IfL Name

newGlobalBinder :: Module -> OccName -> SrcSpan -> TcRnIf a b Name

mkNameCacheUpdater :: TcRnIf a b NameCacheUpdater

lookupOrigIO :: HscEnv -> Module -> OccName -> IO Name

lookupOrig :: Module -> OccName -> TcRnIf a b Name

Look up the Name for a given Module and OccName. Consider alternatively using lookupIfaceTop if you're in the IfL monad and Module is simply that of the ModIface_ you are typechecking.

lookupIfaceVar :: IfaceBndr -> IfL (Maybe TyCoVar)

lookupIfaceTyVar :: IfaceTvBndr -> IfL (Maybe TyVar)

lookupIfaceTop :: OccName -> IfL Name

Look up a top-level name from the current Iface module

ifaceExportNames :: [IfaceExport] -> TcRnIf gbl lcl [AvailInfo]

externaliseName :: Module -> Name -> TcRnIf m n Name

extendIfaceTyVarEnv :: [TyVar] -> IfL a -> IfL a

extendIfaceIdEnv :: [Id] -> IfL a -> IfL a

extendIfaceEnvs :: [TyCoVar] -> IfL a -> IfL a

allocateGlobalBinder :: NameCache -> Module -> OccName -> SrcSpan -> (NameCache, Name)

data IsExtraConstraint

Constructors

YesExtraConstraint

NoExtraConstraint

Instances

Outputable IsExtraConstraint

Defined in GHC.Tc.Utils.Monad

Methods

ppr :: IsExtraConstraint -> SDoc

xoptM :: Extension -> TcRnIf gbl lcl Bool

writeTcRef :: TcRef a -> a -> TcRnIf gbl lcl ()

wrapLocSndMA :: (a -> TcM (b, c)) -> LocatedA a -> TcM (b, LocatedA c)

wrapLocSndM :: (a -> TcM (b, c)) -> Located a -> TcM (b, Located c)

wrapLocM_ :: (a -> TcM ()) -> Located a -> TcM ()

wrapLocMA_ :: (a -> TcM ()) -> LocatedA a -> TcM ()

wrapLocMA :: (a -> TcM b) -> GenLocated (SrcSpanAnn' ann) a -> TcRn (GenLocated (SrcSpanAnn' ann) b)

wrapLocM :: (a -> TcM b) -> Located a -> TcM (Located b)

wrapLocFstMA :: (a -> TcM (b, c)) -> LocatedA a -> TcM (LocatedA b, c)

wrapLocFstM :: (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)

wrapLocAM :: (a -> TcM b) -> LocatedAn an a -> TcM (Located b)

woptM :: WarningFlag -> TcRnIf gbl lcl Bool

withoutDynamicNow :: TcRnIf gbl lcl a -> TcRnIf gbl lcl a

withException :: TcRnIf gbl lcl (MaybeErr SDoc a) -> TcRnIf gbl lcl a

A convenient wrapper for taking a MaybeErr SDoc a and throwing an exception if it is an error.

withDynamicNow :: TcRnIf gbl lcl a -> TcRnIf gbl lcl a

whenXOptM :: Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()

whenWOptM :: WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()

whenNoErrs :: TcM () -> TcM ()

whenGOptM :: GeneralFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()

whenDOptM :: DumpFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()

Do it flag is true

warnTcM :: WarnReason -> Bool -> (TidyEnv, SDoc) -> TcM ()

Display a warning if a condition is met.

warnTc :: WarnReason -> Bool -> SDoc -> TcM ()

Display a warning if a condition is met.

warnIfFlag :: WarningFlag -> Bool -> SDoc -> TcRn ()

Display a warning if a condition is met, and the warning is enabled

warnIf :: Bool -> SDoc -> TcRn ()

Display a warning if a condition is met.

updateEps_ :: (ExternalPackageState -> ExternalPackageState) -> TcRnIf gbl lcl ()

Update the external package state.

This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.

updateEps :: (ExternalPackageState -> (ExternalPackageState, a)) -> TcRnIf gbl lcl a

Update the external package state. Returns the second result of the modifier function.

This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.

updTopEnv :: (HscEnv -> HscEnv) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

updTcRef :: TcRef a -> (a -> a) -> TcRnIf gbl lcl ()

updLclEnv :: (lcl -> lcl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

updGblEnv :: (gbl -> gbl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

unsetXOptM :: Extension -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

unsetWOptM :: WarningFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

unsetGOptM :: GeneralFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

unlessXOptM :: Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()

tryTcDiscardingErrs :: TcM r -> TcM r -> TcM r

tryTc :: TcRn a -> TcRn (Maybe a, Messages DecoratedSDoc)

tryCaptureConstraints :: TcM a -> TcM (Maybe a, WantedConstraints)

traceTcConstraints :: String -> TcM ()

traceTc :: String -> SDoc -> TcRn ()

traceRn :: String -> SDoc -> TcRn ()

traceOptTcRn :: DumpFlag -> SDoc -> TcRn ()

traceOptIf :: DumpFlag -> SDoc -> TcRnIf m n ()

traceIf :: SDoc -> TcRnIf m n ()

traceHiDiffs :: SDoc -> TcRnIf m n ()

tcSelfBootInfo :: TcRn SelfBootInfo

tcScalingUsage :: Mult -> TcM a -> TcM a

tcScalingUsage mult thing_inside runs thing_inside and scales all the usage information by mult.

tcIsHsig :: TcRn Bool

tcIsHsBootOrSig :: TcRn Bool

tcEmitBindingUsage :: UsageEnv -> TcM ()

tcCollectingUsage :: TcM a -> TcM (UsageEnv, a)

tcCollectingUsage thing_inside runs thing_inside and returns the usage information which was collected as part of the execution of thing_inside. Careful: tcCollectingUsage thing_inside itself does not report any usage information, it's up to the caller to incorporate the returned usage information into the larger context appropriately.

setXOptM :: Extension -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

setTcLevel :: TcLevel -> TcM a -> TcM a

setTcEvBindsMap :: EvBindsVar -> EvBindMap -> TcM ()

setStage :: ThStage -> TcM a -> TcRn a

setSrcSpanA :: SrcSpanAnn' ann -> TcRn a -> TcRn a

setSrcSpan :: SrcSpan -> TcRn a -> TcRn a

setLocalRdrEnv :: LocalRdrEnv -> RnM a -> RnM a

setLclTypeEnv :: TcLclEnv -> TcM a -> TcM a

setLclEnv :: lcl' -> TcRnIf gbl lcl' a -> TcRnIf gbl lcl a

setImplicitEnvM :: TypeEnv -> IfL a -> IfL a

setGblEnv :: gbl -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

setErrsVar :: TcRef (Messages DecoratedSDoc) -> TcRn a -> TcRn a

setErrCtxt :: [ErrCtxt] -> TcM a -> TcM a

setEnvs :: (gbl', lcl') -> TcRnIf gbl' lcl' a -> TcRnIf gbl lcl a

setCtLocM :: CtLoc -> TcM a -> TcM a

setConstraintVar :: TcRef WantedConstraints -> TcM a -> TcM a

reportWarning :: WarnReason -> MsgEnvelope DecoratedSDoc -> TcRn ()

reportErrors :: [MsgEnvelope DecoratedSDoc] -> TcM ()

reportError :: MsgEnvelope DecoratedSDoc -> TcRn ()

recoverM :: TcRn r -> TcRn r -> TcRn r

recordUnsafeInfer :: WarningMessages -> TcM ()

Mark that safe inference has failed See Note [Safe Haskell Overlapping Instances Implementation] although this is used for more than just that failure case.

recordThUse :: TcM ()

recordThSpliceUse :: TcM ()

readTcRef :: TcRef a -> TcRnIf gbl lcl a

pushTcLevelsM :: Int -> TcM a -> TcM (a, TcLevel)

pushTcLevelM_ :: TcM a -> TcM a

pushTcLevelM :: TcM a -> TcM (TcLevel, a)

pushLevelAndCaptureConstraints :: TcM a -> TcM (TcLevel, WantedConstraints, a)

The name says it all. The returned TcLevel is the *inner* TcLevel.

printForUserTcRn :: SDoc -> TcRn ()

Like logInfoTcRn, but for user consumption

popErrCtxt :: TcM a -> TcM a

newUniqueSupply :: TcRnIf gbl lcl UniqSupply

newUnique :: TcRnIf gbl lcl Unique

newTcRef :: a -> TcRnIf gbl lcl (TcRef a)

newTcEvBinds :: TcM EvBindsVar

newSysName :: OccName -> TcRnIf gbl lcl Name

newSysLocalIds :: FastString -> [Scaled TcType] -> TcRnIf gbl lcl [TcId]

newSysLocalId :: FastString -> Mult -> TcType -> TcRnIf gbl lcl TcId

newNoTcEvBinds :: TcM EvBindsVar

Creates an EvBindsVar incapable of holding any bindings. It still tracks covar usages (see comments on ebv_tcvs in GHC.Tc.Types.Evidence), thus must be made monadically

newNameAt :: OccName -> SrcSpan -> TcM Name

newName :: OccName -> TcM Name

newArrowScope :: TcM a -> TcM a

mkLongErrAt :: SrcSpan -> SDoc -> SDoc -> TcRn (MsgEnvelope DecoratedSDoc)

mkIfLclEnv :: Module -> SDoc -> IsBootInterface -> IfLclEnv

mkErrInfo :: TidyEnv -> [ErrCtxt] -> TcM SDoc

mkDecoratedSDocAt

Arguments

:: SrcSpan

-> SDoc

The important part of the message

-> SDoc

The context of the message

-> SDoc

Any supplementary information.

-> TcRn (MsgEnvelope DecoratedSDoc)

mapAndReportM :: (a -> TcRn b) -> [a] -> TcRn [b]

Apply the function to all elements on the input list If all succeed, return the list of results Otherwise fail, propagating all errors

mapAndRecoverM :: (a -> TcRn b) -> [a] -> TcRn [b]

Drop elements of the input that fail, so the result list can be shorter than the argument list

keepAlive :: Name -> TcRn ()

isTouchableTcM :: TcTyVar -> TcM Bool

initTcWithGbl :: HscEnv -> TcGblEnv -> RealSrcSpan -> TcM r -> IO (Messages DecoratedSDoc, Maybe r)

Run a TcM action in the context of an existing GblEnv.

initTcRnIf

Arguments

:: Char

Mask for unique supply

-> HscEnv

-> gbl

-> lcl

-> TcRnIf gbl lcl a

-> IO a

initTcInteractive :: HscEnv -> TcM a -> IO (Messages DecoratedSDoc, Maybe a)

initTc :: HscEnv -> HscSource -> Bool -> Module -> RealSrcSpan -> TcM r -> IO (Messages DecoratedSDoc, Maybe r)

Setup the initial typechecking environment

initIfaceTcRn :: IfG a -> TcRn a

Run an IfG (top-level interface monad) computation inside an existing TcRn (typecheck-renaming monad) computation by initializing an IfGblEnv based on TcGblEnv.

initIfaceLoad :: HscEnv -> IfG a -> IO a

initIfaceLclWithSubst :: Module -> SDoc -> IsBootInterface -> NameShape -> IfL a -> IfM lcl a

Initialize interface typechecking, but with a NameShape to apply when typechecking top-level OccNames (see lookupIfaceTop)

initIfaceLcl :: Module -> SDoc -> IsBootInterface -> IfL a -> IfM lcl a

initIfaceCheck :: SDoc -> HscEnv -> IfG a -> IO a

inGeneratedCode :: TcRn Bool

ifErrsM :: TcRn r -> TcRn r -> TcRn r

goptM :: GeneralFlag -> TcRnIf gbl lcl Bool

getTopEnv :: TcRnIf gbl lcl HscEnv

getTcLevel :: TcM TcLevel

getTcEvTyCoVars :: EvBindsVar -> TcM TyCoVarSet

getTcEvBindsMap :: EvBindsVar -> TcM EvBindMap

getStageAndBindLevel :: Name -> TcRn (Maybe (TopLevelFlag, ThLevel, ThStage))

getStage :: TcM ThStage

getSrcSpanM :: TcRn SrcSpan

getRecFieldEnv :: TcRn RecFieldEnv

getRdrEnvs :: TcRn (GlobalRdrEnv, LocalRdrEnv)

getPrintUnqualified :: TcRn PrintUnqualified

getLocalRdrEnv :: RnM LocalRdrEnv

getLclTypeEnv :: TcM TcTypeEnv

getLclEnv :: TcRnIf gbl lcl lcl

getIsGHCi :: TcRn Bool

getInteractivePrintName :: TcRn Name

getImports :: TcRn ImportAvails

getIfModule :: IfL Module

getHpt :: TcRnIf gbl lcl HomePackageTable

getGlobalRdrEnv :: TcRn GlobalRdrEnv

getGhcMode :: TcRnIf gbl lcl GhcMode

getGblEnv :: TcRnIf gbl lcl gbl

getGHCiMonad :: TcRn Name

getFixityEnv :: TcRn FixityEnv

getErrsVar :: TcRn (TcRef (Messages DecoratedSDoc))

getErrCtxt :: TcM [ErrCtxt]

getEpsVar :: TcRnIf gbl lcl (TcRef ExternalPackageState)

getEpsAndHpt :: TcRnIf gbl lcl (ExternalPackageState, HomePackageTable)

getEps :: TcRnIf gbl lcl ExternalPackageState

getEnvs :: TcRnIf gbl lcl (gbl, lcl)

getDeclaredDefaultTys :: TcRn (Maybe [Type])

getCtLocM :: CtOrigin -> Maybe TypeOrKind -> TcM CtLoc

getConstraintVar :: TcM (TcRef WantedConstraints)

getCCIndexTcM :: FastString -> TcM CostCentreIndex

See getCCIndexM.

getCCIndexM :: (gbl -> TcRef CostCentreState) -> FastString -> TcRnIf gbl lcl CostCentreIndex

Get the next cost centre index associated with a given name.

forkM_maybe :: SDoc -> IfL a -> IfL (Maybe a)

Run thing_inside in an interleaved thread. It shares everything with the parent thread, so this is DANGEROUS.

It returns Nothing if the computation fails

It's used for lazily type-checking interface signatures, which is pretty benign.

See Note [Masking exceptions in forkM_maybe]

forkM :: SDoc -> IfL a -> IfL a

foldAndRecoverM :: (b -> a -> TcRn b) -> b -> [a] -> TcRn b

The accumulator is not updated if the action fails

fixSafeInstances :: SafeHaskellMode -> [ClsInst] -> [ClsInst]

Switch instances to safe instances if we're in Safe mode.

finalSafeMode :: DynFlags -> TcGblEnv -> IO SafeHaskellMode

Figure out the final correct safe haskell mode

failWithTcM :: (TidyEnv, SDoc) -> TcM a

failWithTc :: SDoc -> TcM a

failWith :: SDoc -> TcRn a

failIfTcM :: Bool -> (TidyEnv, SDoc) -> TcM ()

failIfTc :: Bool -> SDoc -> TcM ()

failIfM :: SDoc -> IfL a

failIfErrsM :: TcRn ()

failAt :: SrcSpan -> SDoc -> TcRn a

extendFixityEnv :: [(Name, FixItem)] -> RnM a -> RnM a

escapeArrowScope :: TcM a -> TcM a

emitStaticConstraints :: WantedConstraints -> TcM ()

emitSimples :: Cts -> TcM ()

emitSimple :: Ct -> TcM ()

emitNamedTypeHole :: (Name, TcTyVar) -> TcM ()

emitInsoluble :: Ct -> TcM ()

emitImplications :: Bag Implication -> TcM ()

emitImplication :: Implication -> TcM ()

emitHoles :: Bag Hole -> TcM ()

emitHole :: Hole -> TcM ()

emitConstraints :: WantedConstraints -> TcM ()

emitAnonTypeHole :: IsExtraConstraint -> TcTyVar -> TcM ()

dumpTcRn :: Bool -> DumpFlag -> String -> DumpFormat -> SDoc -> TcRn ()

Unconditionally dump some trace output

Certain tests (T3017, Roles3, T12763 etc.) expect part of the output generated by `-ddump-types` to be in PprUser style. However, generally we want all other debugging output to use PprDump style. We PprUser style if useUserStyle is True.

dumpOptTcRn :: DumpFlag -> String -> DumpFormat -> SDoc -> TcRn ()

Dump if the given DumpFlag is set.

doptM :: DumpFlag -> TcRnIf gbl lcl Bool

discardWarnings :: TcRn a -> TcRn a

discardResult :: TcM a -> TcM ()

discardErrs :: TcRn a -> TcRn a

discardConstraints :: TcM a -> TcM a

Throw out any constraints emitted by the thing_inside

debugTc :: TcM () -> TcM ()

cloneLocalName :: Name -> TcM Name

cloneEvBindsVar :: EvBindsVar -> TcM EvBindsVar

chooseUniqueOccTc :: (OccSet -> OccName) -> TcM OccName

checkTcM :: Bool -> (TidyEnv, SDoc) -> TcM ()

checkTc :: Bool -> SDoc -> TcM ()

checkNoErrs :: TcM r -> TcM r

checkErr :: Bool -> SDoc -> TcRn ()

captureConstraints :: TcM a -> TcM (a, WantedConstraints)

attemptM :: TcRn r -> TcRn (Maybe r)

askNoErrs :: TcRn a -> TcRn (a, Bool)

add_warn :: WarnReason -> SDoc -> SDoc -> TcRn ()

Display a warning, with an optional flag, for the current source location.

addWarnTcM :: WarnReason -> (TidyEnv, SDoc) -> TcM ()

Display a warning in a given context.

addWarnTc :: WarnReason -> SDoc -> TcM ()

Display a warning in the current context.

addWarnAt :: WarnReason -> SrcSpan -> SDoc -> TcRn ()

Display a warning for a given source location.

addWarn :: WarnReason -> SDoc -> TcRn ()

Display a warning for the current source location.

addTopEvBinds :: Bag EvBind -> TcM a -> TcM a

addTcEvBind :: EvBindsVar -> EvBind -> TcM ()

addModFinalizersWithLclEnv :: ThModFinalizers -> TcM ()

Adds the given modFinalizers to the global environment and set them to use the current local environment.

addMessages :: Messages DecoratedSDoc -> TcRn ()

addLongErrAt :: SrcSpan -> SDoc -> SDoc -> TcRn ()

addLocMA :: (a -> TcM b) -> GenLocated (SrcSpanAnn' ann) a -> TcM b

addLocM :: (a -> TcM b) -> Located a -> TcM b

addLandmarkErrCtxtM :: (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcM a -> TcM a

Variant of addLandmarkErrCtxt that allows for monadic operations and tidying.

addLandmarkErrCtxt :: SDoc -> TcM a -> TcM a

Add a fixed landmark message to the error context. A landmark message is always sure to be reported, even if there is a lot of context. It also doesn't count toward the maximum number of contexts reported.

addErrs :: [(SrcSpan, SDoc)] -> TcRn ()

addErrTcM :: (TidyEnv, SDoc) -> TcM ()

addErrTc :: SDoc -> TcM ()

addErrCtxtM :: (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcM a -> TcM a

Add a message to the error context. This message may do tidying.

addErrCtxt :: SDoc -> TcM a -> TcM a

Add a fixed message to the error context. This message should not do any tidying.

addErrAt :: SrcSpan -> SDoc -> TcRn ()

addErr :: SDoc -> TcRn ()

addDependentFiles :: [FilePath] -> TcRn ()

data WhereFrom

Constructors

ImportByUser IsBootInterface

ImportBySystem

ImportByPlugin

Instances

Outputable WhereFrom

Defined in GHC.Tc.Types

Methods

ppr :: WhereFrom -> SDoc

data ThStage

Constructors

Splice SpliceType

RunSplice (TcRef [ForeignRef (Q ())])

Comp

Brack ThStage PendingStuff

Instances

Outputable ThStage

Defined in GHC.Tc.Types

Methods

ppr :: ThStage -> SDoc

type ThLevel = Int

type TcTypeEnv = NameEnv TcTyThing

data TcTyThing

A typecheckable thing available in a local context. Could be AGlobal TyThing, but also lexically scoped variables, etc. See GHC.Tc.Utils.Env for how to retrieve a TyThing given a Name.

Constructors

AGlobal TyThing

ATcId

Fields

• tct_id :: TcId
• tct_info :: IdBindingInfo

ATyVar Name TcTyVar

ATcTyCon TyCon

APromotionErr PromotionErr

Instances

Outputable TcTyThing

Defined in GHC.Tc.Types

Methods

ppr :: TcTyThing -> SDoc

data TcSigInfo

Constructors

TcIdSig TcIdSigInfo

TcPatSynSig TcPatSynInfo

Instances

Outputable TcSigInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcSigInfo -> SDoc

type TcSigFun = Name -> Maybe TcSigInfo

type TcRnIf a b = IOEnv (Env a b)

type TcRn = TcRnIf TcGblEnv TcLclEnv

type TcRef a = IORef a

Type alias for IORef; the convention is we'll use this for mutable bits of data in TcGblEnv which are updated during typechecking and returned at the end.

type TcPluginSolver = [Ct] -> [Ct] -> [Ct] -> TcPluginM TcPluginResult

data TcPluginResult

Constructors

TcPluginContradiction [Ct]

The plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble.

TcPluginOk [(EvTerm, Ct)] [Ct]

The first field is for constraints that were solved. These are removed from the inert set, and the evidence for them is recorded. The second field contains new work, that should be processed by the constraint solver.

data TcPluginM a

Instances

MonadFail TcPluginM

Defined in GHC.Tc.Types

Methods

fail :: String -> TcPluginM a

Applicative TcPluginM

Defined in GHC.Tc.Types

Methods

pure :: a -> TcPluginM a

(<*>) :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b

liftA2 :: (a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c

(*>) :: TcPluginM a -> TcPluginM b -> TcPluginM b

(<*) :: TcPluginM a -> TcPluginM b -> TcPluginM a

Functor TcPluginM

Defined in GHC.Tc.Types

Methods

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

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

Monad TcPluginM

Defined in GHC.Tc.Types

Methods

(>>=) :: TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b

(>>) :: TcPluginM a -> TcPluginM b -> TcPluginM b

return :: a -> TcPluginM a

data TcPlugin

Constructors

TcPlugin

Fields

• tcPluginInit :: TcPluginM s

  Initialize plugin, when entering type-checker.

• tcPluginSolve :: s -> TcPluginSolver

  Solve some constraints. TODO: WRITE MORE DETAILS ON HOW THIS WORKS.

• tcPluginStop :: s -> TcPluginM ()

  Clean up after the plugin, when exiting the type-checker.

data TcPatSynInfo

Constructors

TPSI

Fields

• patsig_name :: Name
• patsig_implicit_bndrs :: [InvisTVBinder]
• patsig_univ_bndrs :: [InvisTVBinder]
• patsig_req :: TcThetaType
• patsig_ex_bndrs :: [InvisTVBinder]
• patsig_prov :: TcThetaType
• patsig_body_ty :: TcSigmaType

Instances

Outputable TcPatSynInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcPatSynInfo -> SDoc

type TcM = TcRn

Historical "type-checking monad" (now it's just TcRn).

data TcIdSigInst

Constructors

TISI

Fields

• sig_inst_sig :: TcIdSigInfo
• sig_inst_skols :: [(Name, InvisTVBinder)]
• sig_inst_theta :: TcThetaType
• sig_inst_tau :: TcSigmaType
• sig_inst_wcs :: [(Name, TcTyVar)]
• sig_inst_wcx :: Maybe TcType

Instances

Outputable TcIdSigInst

Defined in GHC.Tc.Types

Methods

ppr :: TcIdSigInst -> SDoc

data TcIdSigInfo

Constructors

CompleteSig

Fields

• sig_bndr :: TcId
• sig_ctxt :: UserTypeCtxt
• sig_loc :: SrcSpan

PartialSig

Fields

• psig_name :: Name
• psig_hs_ty :: LHsSigWcType GhcRn
• sig_ctxt :: UserTypeCtxt
• sig_loc :: SrcSpan

Instances

Outputable TcIdSigInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcIdSigInfo -> SDoc

type TcIdSet = IdSet

type TcId = Id

data TcGblEnv

TcGblEnv describes the top-level of the module at the point at which the typechecker is finished work. It is this structure that is handed on to the desugarer For state that needs to be updated during the typechecking phase and returned at end, use a TcRef (= IORef).

Constructors

TcGblEnv

Fields

• tcg_mod :: Module

  Module being compiled

• tcg_semantic_mod :: Module

  If a signature, the backing module See also Note [Identity versus semantic module]

• tcg_src :: HscSource

  What kind of module (regular Haskell, hs-boot, hsig)

• tcg_rdr_env :: GlobalRdrEnv

  Top level envt; used during renaming

• tcg_default :: Maybe [Type]

  Types used for defaulting. Nothing => no default decl

• tcg_fix_env :: FixityEnv

  Just for things in this module

• tcg_field_env :: RecFieldEnv

  Just for things in this module See Note [The interactive package] in GHC.Runtime.Context

• tcg_type_env :: TypeEnv

  Global type env for the module we are compiling now. All TyCons and Classes (for this module) end up in here right away, along with their derived constructors, selectors.

  (Ids defined in this module start in the local envt, though they move to the global envt during zonking)

  NB: for what "things in this module" means, see Note [The interactive package] in GHC.Runtime.Context

• tcg_type_env_var :: TcRef TypeEnv
• tcg_inst_env :: !InstEnv

  Instance envt for all home-package modules; Includes the dfuns in tcg_insts NB. BangPattern is to fix a leak, see #15111

• tcg_fam_inst_env :: !FamInstEnv

  Ditto for family instances NB. BangPattern is to fix a leak, see #15111

• tcg_ann_env :: AnnEnv

  And for annotations

• tcg_exports :: [AvailInfo]

  What is exported

• tcg_imports :: ImportAvails

  Information about what was imported from where, including things bound in this module. Also store Safe Haskell info here about transitive trusted package requirements.

  There are not many uses of this field, so you can grep for all them.

  The ImportAvails records information about the following things:

  1. All of the modules you directly imported (tcRnImports)
  2. The orphans (only!) of all imported modules in a GHCi session (runTcInteractive)
  3. The module that instantiated a signature
  4. Each of the signatures that merged in

  It is used in the following ways: - imp_orphs is used to determine what orphan modules should be visible in the context (tcVisibleOrphanMods) - imp_finsts is used to determine what family instances should be visible (tcExtendLocalFamInstEnv) - To resolve the meaning of the export list of a module (tcRnExports) - imp_mods is used to compute usage info (mkIfaceTc, deSugar) - imp_trust_own_pkg is used for Safe Haskell in interfaces (mkIfaceTc, as well as in GHC.Driver.Main) - To create the Dependencies field in interface (mkDependencies)

• tcg_dus :: DefUses
• tcg_used_gres :: TcRef [GlobalRdrElt]
• tcg_keep :: TcRef NameSet
• tcg_th_used :: TcRef Bool

  True <=> Template Haskell syntax used.

  We need this so that we can generate a dependency on the Template Haskell package, because the desugarer is going to emit loads of references to TH symbols. The reference is implicit rather than explicit, so we have to zap a mutable variable.

• tcg_th_splice_used :: TcRef Bool

  True <=> A Template Haskell splice was used.

  Splices disable recompilation avoidance (see #481)

• tcg_dfun_n :: TcRef OccSet

  Allows us to choose unique DFun names.

• tcg_merged :: [(Module, Fingerprint)]

  The requirements we merged with; we always have to recompile if any of these changed.

• tcg_rn_exports :: Maybe [(LIE GhcRn, Avails)]
• tcg_rn_imports :: [LImportDecl GhcRn]
• tcg_rn_decls :: Maybe (HsGroup GhcRn)

  Renamed decls, maybe. Nothing <=> Don't retain renamed decls.

• tcg_dependent_files :: TcRef [FilePath]

  dependencies from addDependentFile

• tcg_th_topdecls :: TcRef [LHsDecl GhcPs]

  Top-level declarations from addTopDecls

• tcg_th_foreign_files :: TcRef [(ForeignSrcLang, FilePath)]

  Foreign files emitted from TH.

• tcg_th_topnames :: TcRef NameSet

  Exact names bound in top-level declarations in tcg_th_topdecls

• tcg_th_modfinalizers :: TcRef [(TcLclEnv, ThModFinalizers)]

  Template Haskell module finalizers.

  They can use particular local environments.

• tcg_th_coreplugins :: TcRef [String]

  Core plugins added by Template Haskell code.

• tcg_th_state :: TcRef (Map TypeRep Dynamic)
• tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState)))

  Template Haskell state

• tcg_th_docs :: TcRef THDocs

  Docs added in Template Haskell via putDoc.

• tcg_ev_binds :: Bag EvBind
• tcg_tr_module :: Maybe Id
• tcg_binds :: LHsBinds GhcTc
• tcg_sigs :: NameSet
• tcg_imp_specs :: [LTcSpecPrag]
• tcg_warns :: Warnings
• tcg_anns :: [Annotation]
• tcg_tcs :: [TyCon]
• tcg_ksigs :: NameSet
• tcg_insts :: [ClsInst]
• tcg_fam_insts :: [FamInst]
• tcg_rules :: [LRuleDecl GhcTc]
• tcg_fords :: [LForeignDecl GhcTc]
• tcg_patsyns :: [PatSyn]
• tcg_doc_hdr :: Maybe LHsDocString

  Maybe Haddock header docs

• tcg_hpc :: !AnyHpcUsage

  True if any part of the prog uses hpc instrumentation. NB. BangPattern is to fix a leak, see #15111

• tcg_self_boot :: SelfBootInfo

  Whether this module has a corresponding hi-boot file

• tcg_main :: Maybe Name

  The Name of the main function, if this module is the main module.

• tcg_safeInfer :: TcRef (Bool, WarningMessages)

  Has the typechecker inferred this module as -XSafe (Safe Haskell) See Note [Safe Haskell Overlapping Instances Implementation], although this is used for more than just that failure case.

• tcg_tc_plugins :: [TcPluginSolver]

  A list of user-defined plugins for the constraint solver.

• tcg_hf_plugins :: [HoleFitPlugin]

  A list of user-defined plugins for hole fit suggestions.

• tcg_top_loc :: RealSrcSpan

  The RealSrcSpan this module came from

• tcg_static_wc :: TcRef WantedConstraints

  Wanted constraints of static forms. See Note [Constraints in static forms].

• tcg_complete_matches :: !CompleteMatches

  Tracking indices for cost centre annotations

• tcg_cc_st :: TcRef CostCentreState

Instances

ContainsModule TcGblEnv

Defined in GHC.Tc.Types

Methods

extractModule :: TcGblEnv -> Module

type TcBinderStack = [TcBinder]

data TcBinder

Constructors

TcIdBndr TcId TopLevelFlag

TcIdBndr_ExpType Name ExpType TopLevelFlag

TcTvBndr Name TyVar

Instances

HasOccName TcBinder

Defined in GHC.Tc.Types

Methods

occName :: TcBinder -> OccName

Outputable TcBinder

Defined in GHC.Tc.Types

Methods

ppr :: TcBinder -> SDoc

type THDocs = Map DocLoc String

The current collection of docs that Template Haskell has built up via putDoc.

data SpliceType

Constructors

Typed

Untyped

data SelfBootInfo

Constructors

NoSelfBoot

SelfBoot

Fields

• sb_mds :: ModDetails
• sb_tcs :: NameSet

type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)

type RnM = TcRn

Historical "renaming monad" (now it's just TcRn).

type RhsNames = NameSet

type RecFieldEnv = NameEnv [FieldLabel]

data PromotionErr

Constructors

TyConPE

ClassPE

FamDataConPE

ConstrainedDataConPE PredType

PatSynPE

RecDataConPE

NoDataKindsTC

NoDataKindsDC

Instances

Outputable PromotionErr

Defined in GHC.Tc.Types

Methods

ppr :: PromotionErr -> SDoc

data PendingStuff

Constructors

RnPendingUntyped (TcRef [PendingRnSplice])

RnPendingTyped

TcPending (TcRef [PendingTcSplice]) (TcRef WantedConstraints) QuoteWrapper

data NameShape

A NameShape is a substitution on Names that can be used to refine the identities of a hole while we are renaming interfaces (see GHC.Iface.Rename). Specifically, a NameShape for ns_module_name A, defines a mapping from {A.T} (for some OccName T) to some arbitrary other Name.

The most intruiging thing about a NameShape, however, is how it's constructed. A NameShape is *implied* by the exported AvailInfos of the implementor of an interface: if an implementor of signature <H> exports M.T, you implicitly define a substitution from {H.T} to M.T. So a NameShape is computed from the list of AvailInfos that are exported by the implementation of a module, or successively merged together by the export lists of signatures which are joining together.

It's not the most obvious way to go about doing this, but it does seem to work!

NB: Can't boot this and put it in NameShape because then we start pulling in too many DynFlags things.

Constructors

NameShape

Fields

• ns_mod_name :: ModuleName
• ns_exports :: [AvailInfo]
• ns_map :: OccEnv Name

data IsGroupClosed

IsGroupClosed describes a group of mutually-recursive bindings

Constructors

IsGroupClosed (NameEnv RhsNames) ClosedTypeId

data ImportAvails

ImportAvails summarises what was imported from where, irrespective of whether the imported things are actually used or not. It is used:

• when processing the export list,
• when constructing usage info for the interface file,
• to identify the list of directly imported modules for initialisation purposes and for optimised overlap checking of family instances,
• when figuring out what things are really unused

Constructors

ImportAvails

Fields

• imp_mods :: ImportedMods

  Domain is all directly-imported modules

  See the documentation on ImportedModsVal in GHC.Unit.Module.Imported for the meaning of the fields.

  We need a full ModuleEnv rather than a ModuleNameEnv here, because we might be importing modules of the same name from different packages. (currently not the case, but might be in the future).

• imp_dep_mods :: ModuleNameEnv ModuleNameWithIsBoot

  Home-package modules needed by the module being compiled

  It doesn't matter whether any of these dependencies are actually used when compiling the module; they are listed if they are below it at all. For example, suppose M imports A which imports X. Then compiling M might not need to consult X.hi, but X is still listed in M's dependencies.

• imp_dep_pkgs :: Set UnitId

  Packages needed by the module being compiled, whether directly, or via other modules in this package, or via modules imported from other packages.

• imp_trust_pkgs :: Set UnitId

  This is strictly a subset of imp_dep_pkgs and records the packages the current module needs to trust for Safe Haskell compilation to succeed. A package is required to be trusted if we are dependent on a trustworthy module in that package. While perhaps making imp_dep_pkgs a tuple of (UnitId, Bool) where True for the bool indicates the package is required to be trusted is the more logical design, doing so complicates a lot of code not concerned with Safe Haskell. See Note [Tracking Trust Transitively] in GHC.Rename.Names

• imp_trust_own_pkg :: Bool

  Do we require that our own package is trusted? This is to handle efficiently the case where a Safe module imports a Trustworthy module that resides in the same package as it. See Note [Trust Own Package] in GHC.Rename.Names

• imp_orphs :: [Module]

  Orphan modules below us in the import tree (and maybe including us for imported modules)

• imp_finsts :: [Module]

  Family instance modules below us in the import tree (and maybe including us for imported modules)

type IfM lcl = TcRnIf IfGblEnv lcl

data IfLclEnv

Constructors

IfLclEnv

Fields

• if_mod :: Module
• if_boot :: IsBootInterface
• if_loc :: SDoc
• if_nsubst :: Maybe NameShape
• if_implicits_env :: Maybe TypeEnv
• if_tv_env :: FastStringEnv TyVar
• if_id_env :: FastStringEnv Id

type IfL = IfM IfLclEnv

data IfGblEnv

Constructors

IfGblEnv

Fields

• if_doc :: SDoc
• if_rec_types :: Maybe (Module, IfG TypeEnv)

type IfG = IfM ()

data IdBindingInfo

IdBindingInfo describes how an Id is bound.

It is used for the following purposes: a) for static forms in checkClosedInStaticForm and b) to figure out when a nested binding can be generalised, in decideGeneralisationPlan.

Constructors

NotLetBound

ClosedLet

NonClosedLet RhsNames ClosedTypeId

Instances

Outputable IdBindingInfo

Defined in GHC.Tc.Types

Methods

ppr :: IdBindingInfo -> SDoc

data FrontendResult

FrontendResult describes the result of running the frontend of a Haskell module. Currently one always gets a FrontendTypecheck, since running the frontend involves typechecking a program. hs-sig merges are not handled here.

This data type really should be in GHC.Driver.Env, but it needs to have a TcGblEnv which is only defined here.

Constructors

FrontendTypecheck TcGblEnv

type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, SDoc))

data Env gbl lcl

Constructors

Env

Fields

• env_top :: !HscEnv
• env_um :: !Char
• env_gbl :: gbl
• env_lcl :: lcl

Instances

ContainsHooks (Env gbl lcl)

Defined in GHC.Tc.Types

Methods

extractHooks :: Env gbl lcl -> Hooks

ContainsDynFlags (Env gbl lcl)

Defined in GHC.Tc.Types

Methods

extractDynFlags :: Env gbl lcl -> DynFlags

ContainsModule gbl => ContainsModule (Env gbl lcl)

Defined in GHC.Tc.Types

Methods

extractModule :: Env gbl lcl -> Module

ContainsLogger (Env gbl lcl)

Defined in GHC.Tc.Types

Methods

extractLogger :: Env gbl lcl -> Logger

data DocLoc

This is a mirror of Template Haskell's DocLoc, but the TH names are resolved to GHC names.

Constructors

DeclDoc Name

ArgDoc Name Int

InstDoc Name

ModuleDoc

Instances

Eq DocLoc

Defined in GHC.Tc.Types

Methods

(==) :: DocLoc -> DocLoc -> Bool

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

Ord DocLoc

Defined in GHC.Tc.Types

Methods

compare :: DocLoc -> DocLoc -> Ordering

(<) :: DocLoc -> DocLoc -> Bool

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

(>) :: DocLoc -> DocLoc -> Bool

(>=) :: DocLoc -> DocLoc -> Bool

max :: DocLoc -> DocLoc -> DocLoc

min :: DocLoc -> DocLoc -> DocLoc

type ClosedTypeId = Bool

data ArrowCtxt

Constructors

NoArrowCtxt

ArrowCtxt LocalRdrEnv (TcRef WantedConstraints)

unsafeTcPluginTcM :: TcM a -> TcPluginM a

This function provides an escape for direct access to the TcM monad. It should not be used lightly, and the provided TcPluginM API should be favoured instead.

topStage :: ThStage

topSpliceStage :: ThStage

topAnnStage :: ThStage

thLevel :: ThStage -> ThLevel

tcVisibleOrphanMods :: TcGblEnv -> ModuleSet

tcTyThingCategory :: TcTyThing -> String

runTcPluginM :: TcPluginM a -> EvBindsVar -> TcM a

removeBindingShadowing :: HasOccName a => [a] -> [a]

pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc

pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc

pprTcTyThingCategory :: TcTyThing -> SDoc

pprPECategory :: PromotionErr -> SDoc

plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails

Union two ImportAvails

This function is a key part of Import handling, basically for each import we create a separate ImportAvails structure and then union them all together with this function.

peCategory :: PromotionErr -> String

outerLevel :: ThLevel

modDepsElts :: ModuleNameEnv ModuleNameWithIsBoot -> [ModuleNameWithIsBoot]

mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv

mkModDeps :: [ModuleNameWithIsBoot] -> ModuleNameEnv ModuleNameWithIsBoot

lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)

lintGblEnv :: Logger -> DynFlags -> TcGblEnv -> TcM ()

Check the TcGblEnv for consistency. Currently, only checks axioms, but should check other aspects, too.

isPartialSig :: TcIdSigInst -> Bool

impLevel :: ThLevel

hasCompleteSig :: TcSigFun -> Name -> Bool

No signature or a partial signature

getRoleAnnots :: [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn]

getPlatform :: TcM Platform

Get target platform

getEvBindsTcPluginM :: TcPluginM EvBindsVar

Access the EvBindsVar carried by the TcPluginM during constraint solving. Returns Nothing if invoked during tcPluginInit or tcPluginStop.

emptyRoleAnnotEnv :: RoleAnnotEnv

emptyImportAvails :: ImportAvails

uncacheModule :: HscEnv -> ModuleName -> IO ()

mkStubPaths :: DynFlags -> ModuleName -> ModLocation -> FilePath

mkObjPath :: DynFlags -> FilePath -> String -> FilePath

Constructs the filename of a .o file for a given source file. Does not check whether the .o file exists

mkHomeModLocation2 :: DynFlags -> ModuleName -> FilePath -> String -> IO ModLocation

mkHomeModLocation :: DynFlags -> ModuleName -> FilePath -> IO ModLocation

mkHiPath :: DynFlags -> FilePath -> String -> FilePath

Constructs the filename of a .hi file for a given source file. Does not check whether the .hi file exists

mkHiOnlyModLocation :: DynFlags -> Suffix -> FilePath -> String -> IO ModLocation

flushFinderCaches :: HscEnv -> IO ()

findPluginModule :: HscEnv -> ModuleName -> IO FindResult

Locate a plugin module requested by the user, for a compiler plugin. This consults the same set of exposed packages as findImportedModule, unless -hide-all-plugin-packages or -plugin-package are specified.

findObjectLinkableMaybe :: Module -> ModLocation -> IO (Maybe Linkable)

findObjectLinkable :: Module -> FilePath -> UTCTime -> IO Linkable

findImportedModule :: HscEnv -> ModuleName -> Maybe FastString -> IO FindResult

Locate a module that was imported by the user. We have the module's name, and possibly a package name. Without a package name, this function will use the search path and the known exposed packages to find the module, if a package is specified then only that package is searched for the module.

findHomeModule :: HscEnv -> ModuleName -> IO FindResult

findExposedPackageModule :: HscEnv -> ModuleName -> Maybe FastString -> IO FindResult

findExactModule :: HscEnv -> InstalledModule -> IO InstalledFindResult

Locate a specific Module. The purpose of this function is to create a ModLocation for a given Module, that is to find out where the files associated with this module live. It is used when reading the interface for a module mentioned by another interface, for example (a "system import").

addHomeModuleToFinder :: HscEnv -> ModuleName -> ModLocation -> IO Module

type Xi = TcType

A Xi-type is one that has been fully rewritten with respect to the inert set; that is, it has been rewritten by the algorithm in GHC.Tc.Solver.Rewrite. (Historical note: Xi, for years and years, meant that a type was type-family-free. It does *not* mean this any more.)

data WantedConstraints

Constructors

WC

Fields

• wc_simple :: Cts
• wc_impl :: Bag Implication
• wc_holes :: Bag Hole

Instances

Outputable WantedConstraints

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: WantedConstraints -> SDoc

data TcEvDest

A place for type-checking evidence to go after it is generated. Wanted equalities are always HoleDest; other wanteds are always EvVarDest.

Constructors

EvVarDest EvVar

bind this var to the evidence EvVarDest is always used for non-type-equalities e.g. class constraints

HoleDest CoercionHole

fill in this hole with the evidence HoleDest is always used for type-equalities See Note [Coercion holes] in GHC.Core.TyCo.Rep

Instances

Outputable TcEvDest

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: TcEvDest -> SDoc

data SubGoalDepth

See Note [SubGoalDepth]

Instances

Outputable SubGoalDepth

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: SubGoalDepth -> SDoc

Eq SubGoalDepth

Defined in GHC.Tc.Types.Constraint

Methods

(==) :: SubGoalDepth -> SubGoalDepth -> Bool

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

Ord SubGoalDepth

Defined in GHC.Tc.Types.Constraint

Methods

compare :: SubGoalDepth -> SubGoalDepth -> Ordering

(<) :: SubGoalDepth -> SubGoalDepth -> Bool

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

(>) :: SubGoalDepth -> SubGoalDepth -> Bool

(>=) :: SubGoalDepth -> SubGoalDepth -> Bool

max :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth

min :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth

data ShadowInfo

Constructors

WDeriv

WOnly

Instances

Eq ShadowInfo

Defined in GHC.Tc.Types.Constraint

Methods

(==) :: ShadowInfo -> ShadowInfo -> Bool

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

data QCInst

Constructors

QCI

Fields

• qci_ev :: CtEvidence
• qci_tvs :: [TcTyVar]
• qci_pred :: TcPredType
• qci_pend_sc :: Bool

Instances

Outputable QCInst

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: QCInst -> SDoc

data Implication

Constructors

Implic

Fields

• ic_tclvl :: TcLevel
• ic_skols :: [TcTyVar]
• ic_info :: SkolemInfo
• ic_given :: [EvVar]
• ic_given_eqs :: HasGivenEqs
• ic_warn_inaccessible :: Bool
• ic_env :: TcLclEnv
• ic_wanted :: WantedConstraints
• ic_binds :: EvBindsVar
• ic_need_inner :: VarSet
• ic_need_outer :: VarSet
• ic_status :: ImplicStatus

Instances

Outputable Implication

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Implication -> SDoc

data ImplicStatus

Constructors

IC_Solved

Fields

• ics_dead :: [EvVar]

IC_Insoluble

IC_BadTelescope

IC_Unsolved

Instances

Outputable ImplicStatus

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: ImplicStatus -> SDoc

data HoleSort

Used to indicate which sort of hole we have.

Constructors

ExprHole HoleExprRef

Either an out-of-scope variable or a "true" hole in an expression (TypedHoles). The HoleExprRef says where to write the the erroring expression for -fdefer-type-errors.

TypeHole

A hole in a type (PartialTypeSignatures)

ConstraintHole

A hole in a constraint, like @f :: (_, Eq a) => ... Differentiated from TypeHole because a ConstraintHole is simplified differently. See Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver.

Instances

Outputable HoleSort

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: HoleSort -> SDoc

data Hole

A hole stores the information needed to report diagnostics about holes in terms (unbound identifiers or underscores) or in types (also called wildcards, as used in partial type signatures). See Note [Holes].

Constructors

Hole

Fields

• hole_sort :: HoleSort

  What flavour of hole is this?

• hole_occ :: OccName

  The name of this hole

• hole_ty :: TcType

  Type to be printed to the user For expression holes: type of expr For type holes: the missing type

• hole_loc :: CtLoc

  Where hole was written

Instances

Outputable Hole

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Hole -> SDoc

data HasGivenEqs

Constructors

NoGivenEqs

LocalGivenEqs

MaybeGivenEqs

Instances

Monoid HasGivenEqs

Defined in GHC.Tc.Types.Constraint

Methods

mempty :: HasGivenEqs

mappend :: HasGivenEqs -> HasGivenEqs -> HasGivenEqs

mconcat :: [HasGivenEqs] -> HasGivenEqs

Semigroup HasGivenEqs

Defined in GHC.Tc.Types.Constraint

Methods

(<>) :: HasGivenEqs -> HasGivenEqs -> HasGivenEqs

sconcat :: NonEmpty HasGivenEqs -> HasGivenEqs

stimes :: Integral b => b -> HasGivenEqs -> HasGivenEqs

Outputable HasGivenEqs

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: HasGivenEqs -> SDoc

Eq HasGivenEqs

Defined in GHC.Tc.Types.Constraint

Methods

(==) :: HasGivenEqs -> HasGivenEqs -> Bool

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

type Cts = Bag Ct

data CtLoc

Constructors

CtLoc

Fields

• ctl_origin :: CtOrigin
• ctl_env :: TcLclEnv
• ctl_t_or_k :: Maybe TypeOrKind
• ctl_depth :: !SubGoalDepth

data CtIrredReason

Used to indicate extra information about why a CIrredCan is irreducible

Constructors

IrredShapeReason

this constraint has a non-canonical shape (e.g. c Int, for a variable c)

HoleBlockerReason HoleSet

this constraint is blocked on the coercion hole(s) listed See Note [Equalities with incompatible kinds] in GHC.Tc.Solver.Canonical Wrinkle (4a). Why store the HoleSet? See Wrinkle (2) of that same Note. INVARIANT: A HoleBlockerReason constraint is a homogeneous equality whose left hand side can fit in a CanEqLHS.

NonCanonicalReason CheckTyEqResult

an equality where some invariant other than (TyEq:H) of CEqCan is not satisfied; the CheckTyEqResult states exactly why INVARIANT: the CheckTyEqResult has some bit set other than cteHoleBlocker

ReprEqReason

an equality that cannot be decomposed because it is representational. Example: a b ~R# Int. These might still be solved later. INVARIANT: The constraint is a representational equality constraint

ShapeMismatchReason

a nominal equality that relates two wholly different types, like Int ~# Bool or a b ~# 3. INVARIANT: The constraint is a nominal equality constraint

AbstractTyConReason

an equality like T a b c ~ Q d e where either T or Q is an abstract type constructor. See Note [Skolem abstract data] in GHC.Core.TyCon. INVARIANT: The constraint is an equality constraint between two TyConApps

Instances

Outputable CtIrredReason

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtIrredReason -> SDoc

type CtFlavourRole = (CtFlavour, EqRel)

Whether or not one Ct can rewrite another is determined by its flavour and its equality relation. See also Note [Flavours with roles] in GHC.Tc.Solver.Monad

data CtFlavour

Constructors

Given

Wanted ShadowInfo

Derived

Instances

Outputable CtFlavour

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtFlavour -> SDoc

Eq CtFlavour

Defined in GHC.Tc.Types.Constraint

Methods

(==) :: CtFlavour -> CtFlavour -> Bool

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

data CtEvidence

Constructors

CtGiven

Fields

• ctev_pred :: TcPredType
• ctev_evar :: EvVar
• ctev_loc :: CtLoc

CtWanted

Fields

• ctev_pred :: TcPredType
• ctev_dest :: TcEvDest
• ctev_nosh :: ShadowInfo
• ctev_loc :: CtLoc

CtDerived

Fields

• ctev_pred :: TcPredType
• ctev_loc :: CtLoc

Instances

Outputable CtEvidence

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtEvidence -> SDoc

data Ct

Constructors

CDictCan

Fields

• cc_ev :: CtEvidence
• cc_class :: Class
• cc_tyargs :: [Xi]
• cc_pend_sc :: Bool

CIrredCan

Fields

• cc_ev :: CtEvidence
• cc_reason :: CtIrredReason

CEqCan

Fields

• cc_ev :: CtEvidence
• cc_lhs :: CanEqLHS
• cc_rhs :: Xi
• cc_eq_rel :: EqRel

CNonCanonical

Fields

• cc_ev :: CtEvidence

CQuantCan QCInst

Instances

Outputable Ct

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Ct -> SDoc

data CheckTyEqResult

A set of problems in checking the validity of a type equality. See checkTypeEq.

Instances

Monoid CheckTyEqResult

Defined in GHC.Tc.Types.Constraint

Methods

mempty :: CheckTyEqResult

mappend :: CheckTyEqResult -> CheckTyEqResult -> CheckTyEqResult

mconcat :: [CheckTyEqResult] -> CheckTyEqResult

Semigroup CheckTyEqResult

Defined in GHC.Tc.Types.Constraint

Methods

(<>) :: CheckTyEqResult -> CheckTyEqResult -> CheckTyEqResult

sconcat :: NonEmpty CheckTyEqResult -> CheckTyEqResult

stimes :: Integral b => b -> CheckTyEqResult -> CheckTyEqResult

Outputable CheckTyEqResult

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CheckTyEqResult -> SDoc

data CheckTyEqProblem

An individual problem that might be logged in a CheckTyEqResult

data CanEqLHS

A CanEqLHS is a type that can appear on the left of a canonical equality: a type variable or exactly-saturated type family application.

Constructors

TyVarLHS TcTyVar

TyFamLHS

Fields

• TyCon

  of the family

• [Xi]

  exactly saturating the family

Instances

Outputable CanEqLHS

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CanEqLHS -> SDoc

wrapType :: Type -> [TyVar] -> [PredType] -> Type

updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc

unionsWC :: [WantedConstraints] -> WantedConstraints

tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar]

Returns free variables of WantedConstraints as a deterministically ordered list. See Note [Deterministic FV] in GHC.Utils.FV.

tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet

Returns free variables of WantedConstraints as a non-deterministic set. See Note [Deterministic FV] in GHC.Utils.FV.

tyCoVarsOfCtsList :: Cts -> [TcTyCoVar]

Returns free variables of a bag of constraints as a deterministically ordered list. See Note [Deterministic FV] in GHC.Utils.FV.

tyCoVarsOfCts :: Cts -> TcTyCoVarSet

Returns free variables of a bag of constraints as a non-deterministic set. See Note [Deterministic FV] in GHC.Utils.FV.

tyCoVarsOfCtList :: Ct -> [TcTyCoVar]

Returns free variables of constraints as a deterministically ordered. list. See Note [Deterministic FV] in GHC.Utils.FV.

tyCoVarsOfCt :: Ct -> TcTyCoVarSet

Returns free variables of constraints as a non-deterministic set

toKindLoc :: CtLoc -> CtLoc

Take a CtLoc and moves it to the kind level

superClassesMightHelp :: WantedConstraints -> Bool

True if taking superclasses of givens, or of wanteds (to perhaps expose more equalities or functional dependencies) might help to solve this constraint. See Note [When superclasses help]

subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool

snocCts :: Cts -> Ct -> Cts

singleCt :: Ct -> Cts

setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc

setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc

setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc

setCtLoc :: Ct -> CtLoc -> Ct

pprEvVars :: [EvVar] -> SDoc

pprEvVarWithType :: EvVar -> SDoc

pprEvVarTheta :: [EvVar] -> SDoc

pprCts :: Cts -> SDoc

pprCtLoc :: CtLoc -> SDoc

mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType

Makes a new equality predicate with the same role as the given evidence.

mkSimpleWC :: [CtEvidence] -> WantedConstraints

mkNonCanonicalCt :: Ct -> Ct

mkNonCanonical :: CtEvidence -> Ct

mkKindLoc :: TcType -> TcType -> CtLoc -> CtLoc

mkIrredCt :: CtIrredReason -> CtEvidence -> Ct

mkImplicWC :: Bag Implication -> WantedConstraints

mkGivens :: CtLoc -> [EvId] -> [Ct]

mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc

maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth

listToCts :: [Ct] -> Cts

isWantedCt :: Ct -> Bool

isWanted :: CtEvidence -> Bool

isUserTypeErrorCt :: Ct -> Bool

isSolvedWC :: WantedConstraints -> Bool

Checks whether a the given wanted constraints are solved, i.e. that there are no simple constraints left and all the implications are solved.

isSolvedStatus :: ImplicStatus -> Bool

isPendingScInst :: QCInst -> Maybe QCInst

isPendingScDict :: Ct -> Maybe Ct

isOutOfScopeHole :: Hole -> Bool

Does this hole represent an "out of scope" error? See Note [Insoluble holes]

isInsolubleStatus :: ImplicStatus -> Bool

isInsolubleReason :: CtIrredReason -> Bool

Are we sure that more solving will never solve this constraint?

isGivenLoc :: CtLoc -> Bool

isGivenCt :: Ct -> Bool

isGiven :: CtEvidence -> Bool

isEmptyWC :: WantedConstraints -> Bool

isEmptyCts :: Cts -> Bool

isDroppableCt :: Ct -> Bool

isDerivedCt :: Ct -> Bool

isDerived :: CtEvidence -> Bool

insolubleWC :: WantedConstraints -> Bool

insolubleImplic :: Implication -> Bool

insolubleEqCt :: Ct -> Bool

insolubleCt :: Ct -> Bool

initialSubGoalDepth :: SubGoalDepth

implicationPrototype :: Implication

getUserTypeErrorMsg :: Ct -> Maybe Type

A constraint is considered to be a custom type error, if it contains custom type errors anywhere in it. See Note [Custom type errors in constraints]

getPendingWantedScs :: Cts -> ([Ct], Cts)

extendCtsList :: Cts -> [Ct] -> Cts

eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool

eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool

eqCanRewrite :: EqRel -> EqRel -> Bool

eqCanEqLHS :: CanEqLHS -> CanEqLHS -> Bool

Are two CanEqLHSs equal?

eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool

emptyWC :: WantedConstraints

emptyCts :: Cts

dropMisleading :: WantedConstraints -> WantedConstraints

dropDerivedWC :: WantedConstraints -> WantedConstraints

dropDerivedSimples :: Cts -> Cts

ctsElts :: Cts -> [Ct]

cterSetOccursCheckSoluble :: CheckTyEqResult -> CheckTyEqResult

Mark a CheckTyEqResult as not having an insoluble occurs-check: any occurs check under a type family or in a representation equality is soluble.

cterRemoveProblem :: CheckTyEqResult -> CheckTyEqProblem -> CheckTyEqResult

cterHasProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool

Check whether a CheckTyEqResult has a CheckTyEqProblem

cterHasOnlyProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool

Check whether a CheckTyEqResult has one CheckTyEqProblem and no other

cterHasOccursCheck :: CheckTyEqResult -> Bool

cterHasNoProblem :: CheckTyEqResult -> Bool

Check whether a CheckTyEqResult is marked successful.

cterFromKind :: CheckTyEqResult -> CheckTyEqResult

Retain only information about occurs-check failures, because only that matters after recurring into a kind.

cterClearOccursCheck :: CheckTyEqResult -> CheckTyEqResult

cteTypeFamily :: CheckTyEqProblem

cteSolubleOccurs :: CheckTyEqProblem

cteProblem :: CheckTyEqProblem -> CheckTyEqResult

cteOK :: CheckTyEqResult

No problems in checking the validity of a type equality.

cteInsolubleOccurs :: CheckTyEqProblem

cteImpredicative :: CheckTyEqProblem

cteHoleBlocker :: CheckTyEqProblem

ctPred :: Ct -> PredType

ctOrigin :: Ct -> CtOrigin

ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind

ctLocSpan :: CtLoc -> RealSrcSpan

ctLocOrigin :: CtLoc -> CtOrigin

ctLocLevel :: CtLoc -> TcLevel

ctLocEnv :: CtLoc -> TcLclEnv

ctLocDepth :: CtLoc -> SubGoalDepth

ctLoc :: Ct -> CtLoc

ctFlavourRole :: Ct -> CtFlavourRole

Extract the flavour and role from a Ct

ctFlavourContainsDerived :: CtFlavour -> Bool

Does this CtFlavour subsumed Derived? True of [WD] and [D].

ctFlavour :: Ct -> CtFlavour

Get the flavour of the given Ct

ctEvidence :: Ct -> CtEvidence

ctEvTerm :: CtEvidence -> EvTerm

ctEvRole :: CtEvidence -> Role

Get the role relevant for a CtEvidence

ctEvPred :: CtEvidence -> TcPredType

ctEvOrigin :: CtEvidence -> CtOrigin

ctEvLoc :: CtEvidence -> CtLoc

ctEvId :: Ct -> EvVar

ctEvFlavourRole :: CtEvidence -> CtFlavourRole

Extract the flavour, role, and boxity from a CtEvidence

ctEvFlavour :: CtEvidence -> CtFlavour

ctEvExpr :: CtEvidence -> EvExpr

ctEvEvId :: CtEvidence -> EvVar

ctEvEqRel :: CtEvidence -> EqRel

Get the equality relation relevant for a CtEvidence

ctEvCoercion :: HasDebugCallStack => CtEvidence -> TcCoercion

ctEqRel :: Ct -> EqRel

Get the equality relation for the given Ct

consCts :: Ct -> Cts -> Cts

checkTelescopeSkol :: SkolemInfo -> Bool

canEqLHS_maybe :: Xi -> Maybe CanEqLHS

Is a type a canonical LHS? That is, is it a tyvar or an exactly-saturated type family application? Does not look through type synonyms.

canEqLHSType :: CanEqLHS -> TcType

Convert a CanEqLHS back into a Expr

canEqLHSKind :: CanEqLHS -> TcKind

Retrieve the kind of a CanEqLHS

bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth

bumpCtLocDepth :: CtLoc -> CtLoc

arisesFromGivens :: Ct -> Bool

andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints

andManyCts :: [Cts] -> Cts

andCts :: Cts -> Cts -> Cts

addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints

addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints

addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints

addHoles :: WantedConstraints -> Bag Hole -> WantedConstraints

data FloatBind

Constructors

FloatLet CoreBind

FloatCase CoreExpr Id AltCon [Var]

Instances

Outputable FloatBind

Defined in GHC.Core.Make

Methods

ppr :: FloatBind -> SDoc

wrapFloats :: [FloatBind] -> CoreExpr -> CoreExpr

Applies the floats from right to left. That is wrapFloats [b1, b2, …, bn] u = let b1 in let b2 in … in let bn in u

wrapFloat :: FloatBind -> CoreExpr -> CoreExpr

unitExpr :: CoreExpr

The unit expression

tYPE_ERROR_ID :: Id

sortQuantVars :: [Var] -> [Var]

rUNTIME_ERROR_ID :: Id

rEC_SEL_ERROR_ID :: Id

rEC_CON_ERROR_ID :: Id

pAT_ERROR_ID :: Id

nO_METHOD_BINDING_ERROR_ID :: Id

nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id

mkWordExpr :: Platform -> Integer -> CoreExpr

Create a CoreExpr which will evaluate to the a Word with the given value

mkWildValBinder :: Mult -> Type -> Id

Make a wildcard binder. This is typically used when you need a binder that you expect to use only at a *binding* site. Do not use it at occurrence sites because it has a single, fixed unique, and it's very easy to get into difficulties with shadowing. That's why it is used so little. See Note [WildCard binders] in GHC.Core.Opt.Simplify.Env

mkWildEvBinder :: PredType -> EvVar

mkWildCase :: CoreExpr -> Scaled Type -> Type -> [CoreAlt] -> CoreExpr

mkUncheckedIntExpr :: Integer -> CoreExpr

Create a CoreExpr which will evaluate to the given Int. Don't check that the number is in the range of the target platform Int

mkTupleSelector1

Arguments

:: [Id]

The Ids to pattern match the tuple against

-> Id

The Id to select

-> Id

A variable of the same type as the scrutinee

-> CoreExpr

Scrutinee

-> CoreExpr

Selector expression

Builds a selector which scrutises the given expression and extracts the one name from the list given. If you want the no-shadowing rule to apply, the caller is responsible for making sure that none of these names are in scope.

If there is just one Id in the tuple, then the selector is just the identity.

If necessary, we pattern match on a "big" tuple.

A tuple selector is not linear in its argument. Consequently, the case expression built by mkTupleSelector must consume its scrutinee Many times. And all the argument variables must have multiplicity Many.

mkTupleSelector

Arguments

:: [Id]

The Ids to pattern match the tuple against

-> Id

The Id to select

-> Id

A variable of the same type as the scrutinee

-> CoreExpr

Scrutinee

-> CoreExpr

Selector expression

mkTupleSelector1 is like mkTupleSelector but one-tuples are NOT flattened (see Note [Flattening one-tuples])

Builds a selector which scrutises the given expression and extracts the one name from the list given. If you want the no-shadowing rule to apply, the caller is responsible for making sure that none of these names are in scope.

If there is just one Id in the tuple, then the selector is just the identity.

If necessary, we pattern match on a "big" tuple.

A tuple selector is not linear in its argument. Consequently, the case expression built by mkTupleSelector must consume its scrutinee Many times. And all the argument variables must have multiplicity Many.

mkTupleCase

Arguments

:: UniqSupply

For inventing names of intermediate variables

-> [Id]

The tuple identifiers to pattern match on

-> CoreExpr

Body of the case

-> Id

A variable of the same type as the scrutinee

-> CoreExpr

Scrutinee

-> CoreExpr

A generalization of mkTupleSelector, allowing the body of the case to be an arbitrary expression.

To avoid shadowing, we use uniques to invent new variables.

If necessary we pattern match on a "big" tuple.

mkStringExprFSWith :: Monad m => (Name -> m Id) -> FastString -> m CoreExpr

mkStringExprFS :: MonadThings m => FastString -> m CoreExpr

Create a CoreExpr which will evaluate to a string morally equivalent to the given FastString

mkStringExpr :: MonadThings m => String -> m CoreExpr

Create a CoreExpr which will evaluate to the given String

mkSmallTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

mkSmallTupleSelector1 is like mkSmallTupleSelector but one-tuples are NOT flattened (see Note [Flattening one-tuples])

Like mkTupleSelector but for tuples that are guaranteed never to be "big".

mkSmallTupleSelector [x] x v e = [| e |]
mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]

mkSmallTupleCase

Arguments

:: [Id]

The tuple args

-> CoreExpr

Body of the case

-> Id

A variable of the same type as the scrutinee

-> CoreExpr

Scrutinee

-> CoreExpr

As mkTupleCase, but for a tuple that is small enough to be guaranteed not to need nesting.

mkRuntimeErrorApp :: Id -> Type -> String -> CoreExpr

mkNothingExpr :: Type -> CoreExpr

Makes a Nothing for the specified type

mkNonEmptyListExpr :: Type -> CoreExpr -> [CoreExpr] -> CoreExpr

mkNilExpr :: Type -> CoreExpr

Makes a list [] for lists of the specified type

mkNaturalExpr :: Integer -> CoreExpr

Create a CoreExpr which will evaluate to the given Natural

mkListExpr :: Type -> [CoreExpr] -> CoreExpr

Make a list containing the given expressions, where the list has the given type

mkJustExpr :: Type -> CoreExpr -> CoreExpr

Makes a Just from a value of the specified type

mkIntegerExpr :: Integer -> CoreExpr

Create a CoreExpr which will evaluate to the given Integer

mkIntExprInt :: Platform -> Int -> CoreExpr

Create a CoreExpr which will evaluate to the given Int

mkIntExpr :: Platform -> Integer -> CoreExpr

Create a CoreExpr which will evaluate to the given Int

mkImpossibleExpr :: Type -> CoreExpr

mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr

mkFoldrExpr

Arguments

:: MonadThings m

=> Type

Element type of the list

-> Type

Fold result type

-> CoreExpr

Cons function expression for the fold

-> CoreExpr

Nil expression for the fold

-> CoreExpr

List expression being folded acress

-> m CoreExpr

Make a fully applied foldr expression

mkFloatExpr :: Float -> CoreExpr

Create a CoreExpr which will evaluate to the given Float

mkDoubleExpr :: Double -> CoreExpr

Create a CoreExpr which will evaluate to the given Double

mkCoreVarTupTy :: [Id] -> Type

Build the type of a small tuple that holds the specified variables One-tuples are flattened; see Note [Flattening one-tuples]

mkCoreUbxTup :: [Type] -> [CoreExpr] -> CoreExpr

Build a small unboxed tuple holding the specified expressions, with the given types. The types must be the types of the expressions. Do not include the RuntimeRep specifiers; this function calculates them for you. Does not flatten one-tuples; see Note [Flattening one-tuples]

mkCoreUbxSum :: Int -> Int -> [Type] -> CoreExpr -> CoreExpr

Build an unboxed sum.

Alternative number ("alt") starts from 1.

mkCoreTupBoxity :: Boxity -> [CoreExpr] -> CoreExpr

Make a core tuple of the given boxity; don't flatten 1-tuples

mkCoreTup :: [CoreExpr] -> CoreExpr

Build a small tuple holding the specified expressions One-tuples are flattened; see Note [Flattening one-tuples]

mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr

Bind a list of binding groups over an expression. The leftmost binding group becomes the outermost group in the resulting expression

mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr

Bind a binding group over an expression, using a let or case as appropriate (see GHC.Core)

mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr

Create a lambda where the given expression has a number of variables bound over it. The leftmost binder is that bound by the outermost lambda in the result

mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr

Construct an expression which represents the application of a number of expressions to that of a data constructor expression. The leftmost expression in the list is applied first

mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr infixl 4

Construct an expression which represents the application of a number of expressions to another. The leftmost expression in the list is applied first Respects the let/app invariant by building a case expression where necessary See Note [Core let/app invariant] in GHC.Core

mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr infixl 4

Construct an expression which represents the application of one expression to the other Respects the let/app invariant by building a case expression where necessary See Note [Core let/app invariant] in GHC.Core

mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr

Makes a list (:) for lists of the specified type

mkCharExpr :: Char -> CoreExpr

Create a CoreExpr which will evaluate to the given Char

mkBuildExpr

Arguments

:: (MonadFail m, MonadThings m, MonadUnique m)

=> Type

Type of list elements to be built

-> ((Id, Type) -> (Id, Type) -> m CoreExpr)

Function that, given information about the Ids of the binders for the build worker function, returns the body of that worker

-> m CoreExpr

Make a build expression applied to a locally-bound worker function

mkBigCoreVarTupTy :: [Id] -> Type

Build the type of a big tuple that holds the specified variables One-tuples are flattened; see Note [Flattening one-tuples]

mkBigCoreVarTup1 :: [Id] -> CoreExpr

mkBigCoreVarTup :: [Id] -> CoreExpr

Build a big tuple holding the specified variables One-tuples are flattened; see Note [Flattening one-tuples]

mkBigCoreTupTy :: [Type] -> Type

Build the type of a big tuple that holds the specified type of thing One-tuples are flattened; see Note [Flattening one-tuples]

mkBigCoreTup :: [CoreExpr] -> CoreExpr

Build a big tuple holding the specified expressions One-tuples are flattened; see Note [Flattening one-tuples]

mkAbsentErrorApp :: Type -> String -> CoreExpr

floatBindings :: FloatBind -> [Var]

errorIds :: [Id]

castBottomExpr :: CoreExpr -> Type -> CoreExpr

aBSENT_SUM_FIELD_ERROR_ID :: Id

aBSENT_ERROR_ID :: Id

class UnXRec p => CollectPass p where

This class specifies how to collect variable identifiers from extension patterns in the given pass. Consumers of the GHC API that define their own passes should feel free to implement instances in order to make use of functions which depend on it.

In particular, Haddock already makes use of this, with an instance for its DocNameI pass so that it can reuse the code in GHC for collecting binders.

Methods

collectXXPat :: Proxy p -> CollectFlag p -> XXPat p -> [IdP p] -> [IdP p]

Instances

IsPass p => CollectPass (GhcPass p)

Defined in GHC.Hs.Utils

Methods

collectXXPat :: Proxy (GhcPass p) -> CollectFlag (GhcPass p) -> XXPat (GhcPass p) -> [IdP (GhcPass p)] -> [IdP (GhcPass p)]

data CollectFlag p where

Indicate if evidence binders have to be collected.

This type is used as a boolean (should we collect evidence binders or not?) but also to pass an evidence that the AST has been typechecked when we do want to collect evidence binders, otherwise these binders are not available.

See Note [Dictionary binders in ConPatOut]

Constructors

CollNoDictBinders :: forall p. CollectFlag p

Don't collect evidence binders

CollWithDictBinders :: CollectFlag (GhcPass 'Typechecked)

Collect evidence binders

unitRecStmtTc :: RecStmtTc

unguardedRHS :: forall (p :: Pass) body. Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpan => EpAnn GrhsAnn -> SrcSpan -> LocatedA (body (GhcPass p)) -> [LGRHS (GhcPass p) (LocatedA (body (GhcPass p)))]

unguardedGRHSs :: forall (p :: Pass) body. Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpan => SrcSpan -> LocatedA (body (GhcPass p)) -> EpAnn GrhsAnn -> GRHSs (GhcPass p) (LocatedA (body (GhcPass p)))

spanHsLocaLBinds :: forall (p :: Pass). Data (HsLocalBinds (GhcPass p)) => HsLocalBinds (GhcPass p) -> SrcSpan

Return the SrcSpan encompassing the contents of any enclosed binds

nl_HsVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> HsExpr (GhcPass p)

nlWildPatName :: LPat GhcRn

Wildcard pattern - after renaming

nlWildPat :: LPat GhcPs

Wildcard pattern - after parsing

nlWildConPat :: DataCon -> LPat GhcPs

nlVarPat :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LPat (GhcPass p)

nlTuplePat :: [LPat GhcPs] -> Boxity -> LPat GhcPs

nlParPat :: forall (name :: Pass). LPat (GhcPass name) -> LPat (GhcPass name)

nlNullaryConPat :: RdrName -> LPat GhcPs

nlLitPat :: HsLit GhcPs -> LPat GhcPs

nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs

nlInfixConPat :: RdrName -> LPat GhcPs -> LPat GhcPs -> LPat GhcPs

nlHsVarApps :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> [IdP (GhcPass p)] -> LHsExpr (GhcPass p)

nlHsVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LHsExpr (GhcPass p)

nlHsTyVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LHsType (GhcPass p)

nlHsTyConApp :: forall (p :: Pass) a. IsSrcSpanAnn p a => LexicalFixity -> IdP (GhcPass p) -> [LHsTypeArg (GhcPass p)] -> LHsType (GhcPass p)

nlHsTyApps :: Id -> [Type] -> [LHsExpr GhcTc] -> LHsExpr GhcTc

nlHsTyApp :: Id -> [Type] -> LHsExpr GhcTc

nlHsSyntaxApps :: SyntaxExprTc -> [LHsExpr GhcTc] -> LHsExpr GhcTc

nlHsParTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p)

nlHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

nlHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs

nlHsLit :: forall (p :: Pass). HsLit (GhcPass p) -> LHsExpr (GhcPass p)

nlHsLam :: LMatch GhcPs (LHsExpr GhcPs) -> LHsExpr GhcPs

nlHsIntLit :: forall (p :: Pass). Integer -> LHsExpr (GhcPass p)

nlHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs

nlHsFunTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)

nlHsDo :: HsStmtContext GhcRn -> [LStmt GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs

nlHsDataCon :: DataCon -> LHsExpr GhcTc

NB: Only for LHsExpr Id.

nlHsCase :: LHsExpr GhcPs -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs

nlHsApps :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> [LHsExpr (GhcPass p)] -> LHsExpr (GhcPass p)

nlHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)

nlHsAppKindTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsKind (GhcPass p) -> LHsType (GhcPass p)

nlHsApp :: forall (id :: Pass). IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

nlConVarPatName :: Name -> [Name] -> LPat GhcRn

nlConVarPat :: RdrName -> [RdrName] -> LPat GhcPs

nlConPatName :: Name -> [LPat GhcRn] -> LPat GhcRn

nlConPat :: RdrName -> [LPat GhcPs] -> LPat GhcPs

mkVarBind :: forall (p :: Pass). IdP (GhcPass p) -> LHsExpr (GhcPass p) -> LHsBind (GhcPass p)

mkUntypedSplice :: EpAnn [AddEpAnn] -> SpliceDecoration -> LHsExpr GhcPs -> HsSplice GhcPs

mkTypedSplice :: EpAnn [AddEpAnn] -> SpliceDecoration -> LHsExpr GhcPs -> HsSplice GhcPs

mkTransformStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)

mkTransformByStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)

mkTopFunBind :: Origin -> LocatedN Name -> [LMatch GhcRn (LHsExpr GhcRn)] -> HsBind GhcRn

In Name-land, with empty bind_fvs

mkTcBindStmt :: LPat GhcTc -> LocatedA (bodyR GhcTc) -> StmtLR GhcTc GhcTc (LocatedA (bodyR GhcTc))

mkSimpleMatch :: forall (p :: Pass) body. (Anno (Match (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpanAnnA, Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpan) => HsMatchContext (NoGhcTc (GhcPass p)) -> [LPat (GhcPass p)] -> LocatedA (body (GhcPass p)) -> LMatch (GhcPass p) (LocatedA (body (GhcPass p)))

mkSimpleGeneratedFunBind :: SrcSpan -> RdrName -> [LPat GhcPs] -> LHsExpr GhcPs -> LHsBind GhcPs

Convenience function using mkFunBind. This is for generated bindings only, do not use for user-written code.

mkRnBindStmt :: LPat GhcRn -> LocatedA (bodyR GhcRn) -> StmtLR GhcRn GhcRn (LocatedA (bodyR GhcRn))

mkRecStmt :: forall (idL :: Pass) bodyR. Anno [GenLocated (Anno (StmtLR (GhcPass idL) GhcPs bodyR)) (StmtLR (GhcPass idL) GhcPs bodyR)] ~ SrcSpanAnnL => EpAnn AnnList -> LocatedL [LStmtLR (GhcPass idL) GhcPs bodyR] -> StmtLR (GhcPass idL) GhcPs bodyR

mkPsBindStmt :: EpAnn [AddEpAnn] -> LPat GhcPs -> LocatedA (bodyR GhcPs) -> StmtLR GhcPs GhcPs (LocatedA (bodyR GhcPs))

mkPrefixFunRhs :: LIdP p -> HsMatchContext p

Make a prefix, non-strict function HsMatchContext

mkPatSynBind :: LocatedN RdrName -> HsPatSynDetails GhcPs -> LPat GhcPs -> HsPatSynDir GhcPs -> EpAnn [AddEpAnn] -> HsBind GhcPs

mkParPat :: forall (p :: Pass). IsPass p => LPat (GhcPass p) -> LPat (GhcPass p)

mkNPlusKPat :: LocatedN RdrName -> Located (HsOverLit GhcPs) -> EpAnn EpaLocation -> Pat GhcPs

mkNPat :: Located (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs) -> EpAnn [AddEpAnn] -> Pat GhcPs

mkMatchGroup :: forall (p :: Pass) body. AnnoBody p body => Origin -> LocatedL [LocatedA (Match (GhcPass p) (LocatedA (body (GhcPass p))))] -> MatchGroup (GhcPass p) (LocatedA (body (GhcPass p)))

mkMatch :: forall (p :: Pass). IsPass p => HsMatchContext (NoGhcTc (GhcPass p)) -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> HsLocalBinds (GhcPass p) -> LMatch (GhcPass p) (LHsExpr (GhcPass p))

mkLocatedList :: Semigroup a => [GenLocated (SrcAnn a) e2] -> LocatedAn an [GenLocated (SrcAnn a) e2]

mkLetStmt :: EpAnn [AddEpAnn] -> HsLocalBinds GhcPs -> StmtLR GhcPs GhcPs (LocatedA b)

mkLastStmt :: forall (idR :: Pass) bodyR (idL :: Pass). IsPass idR => LocatedA (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (LocatedA (bodyR (GhcPass idR)))

mkLHsWrapCo :: TcCoercionN -> LHsExpr GhcTc -> LHsExpr GhcTc

mkLHsWrap :: HsWrapper -> LHsExpr GhcTc -> LHsExpr GhcTc

mkLHsVarTuple :: forall (p :: Pass) a. IsSrcSpanAnn p a => [IdP (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p)

mkLHsTupleExpr :: forall (p :: Pass). [LHsExpr (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p)

mkLHsPar :: forall (id :: Pass). IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

Wrap in parens if hsExprNeedsParens appPrec says it needs them So f x becomes (f x), but 3 stays as 3.

mkLHsCmdWrap :: HsWrapper -> LHsCmd GhcTc -> LHsCmd GhcTc

mkHsWrapPatCo :: TcCoercionN -> Pat GhcTc -> Type -> Pat GhcTc

mkHsWrapPat :: HsWrapper -> Pat GhcTc -> Type -> Pat GhcTc

mkHsWrapCoR :: TcCoercionR -> HsExpr GhcTc -> HsExpr GhcTc

mkHsWrapCo :: TcCoercionN -> HsExpr GhcTc -> HsExpr GhcTc

mkHsWrap :: HsWrapper -> HsExpr GhcTc -> HsExpr GhcTc

Avoid HsWrap co1 (HsWrap co2 _) and HsWrap co1 (HsPar _ _) See Note [Detecting forced eta expansion] in GHC.HsToCore.Expr

mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr GhcPs -> LHsBind GhcPs

mkHsStringPrimLit :: forall (p :: Pass). FastString -> HsLit (GhcPass p)

mkHsString :: forall (p :: Pass). String -> HsLit (GhcPass p)

mkHsSigEnv :: (LSig GhcRn -> Maybe ([LocatedN Name], a)) -> [LSig GhcRn] -> NameEnv a

mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsSplice GhcPs

mkHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

e => (e)

mkHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs

A useful function for building OpApps. The operator is always a variable, and we don't know the fixity yet.

mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr GhcTc -> LHsExpr GhcTc

mkHsLam :: forall (p :: Pass). (IsPass p, XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ NoExtField) => [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)

mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs

mkHsIntegral :: IntegralLit -> HsOverLit GhcPs

mkHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> EpAnn AnnsIf -> HsExpr GhcPs

mkHsFractional :: FractionalLit -> HsOverLit GhcPs

mkHsDoAnns :: HsStmtContext GhcRn -> LocatedL [ExprLStmt GhcPs] -> EpAnn AnnList -> HsExpr GhcPs

mkHsDo :: HsStmtContext GhcRn -> LocatedL [ExprLStmt GhcPs] -> HsExpr GhcPs

mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc

mkHsCompAnns :: HsStmtContext GhcRn -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> EpAnn AnnList -> HsExpr GhcPs

mkHsComp :: HsStmtContext GhcRn -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> HsExpr GhcPs

mkHsCmdWrap :: HsWrapper -> HsCmd GhcTc -> HsCmd GhcTc

mkHsCmdIf :: LHsExpr GhcPs -> LHsCmd GhcPs -> LHsCmd GhcPs -> EpAnn AnnsIf -> HsCmd GhcPs

mkHsCharPrimLit :: forall (p :: Pass). Char -> HsLit (GhcPass p)

mkHsCaseAlt :: forall (p :: Pass) body. (Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpan, Anno (Match (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpanAnnA) => LPat (GhcPass p) -> LocatedA (body (GhcPass p)) -> LMatch (GhcPass p) (LocatedA (body (GhcPass p)))

A simple case alternative with a single pattern, no binds, no guards; pre-typechecking

mkHsAppsWith :: forall (id :: Pass). (LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> HsExpr (GhcPass id) -> LHsExpr (GhcPass id)) -> LHsExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)

mkHsApps :: forall (id :: Pass). LHsExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)

mkHsAppWith :: forall (id :: Pass). (LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> HsExpr (GhcPass id) -> LHsExpr (GhcPass id)) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

mkHsAppTypes :: LHsExpr GhcRn -> [LHsWcType GhcRn] -> LHsExpr GhcRn

mkHsAppType :: LHsExpr GhcRn -> LHsWcType GhcRn -> LHsExpr GhcRn

mkHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

mkGroupUsingStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)

mkGroupByUsingStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)

mkFunBind :: Origin -> LocatedN RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> HsBind GhcPs

Not infix, with place holders for coercion and free vars

mkClassOpSigs :: [LSig GhcPs] -> [LSig GhcPs]

Convert TypeSig to ClassOpSig. The former is what is parsed, but the latter is what we need in class/instance declarations

mkChunkified

Arguments

:: ([a] -> a)

"Small" constructor function, of maximum input arity mAX_TUPLE_SIZE

-> [a]

Possible "big" list of things to construct from

-> a

Constructed thing made possible by recursive decomposition

Lifts a "small" constructor into a "big" constructor by recursive decomposition

mkBodyStmt :: forall bodyR (idL :: Pass). LocatedA (bodyR GhcPs) -> StmtLR (GhcPass idL) GhcPs (LocatedA (bodyR GhcPs))

mkBigLHsVarTup :: forall (p :: Pass) a. IsSrcSpanAnn p a => [IdP (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p)

The Big equivalents for the source tuple expressions

mkBigLHsVarPatTup :: [IdP GhcRn] -> LPat GhcRn

The Big equivalents for the source tuple patterns

mkBigLHsTup :: forall (id :: Pass). [LHsExpr (GhcPass id)] -> XExplicitTuple (GhcPass id) -> LHsExpr (GhcPass id)

mkBigLHsPatTup :: [LPat GhcRn] -> LPat GhcRn

missingTupArg :: EpAnn EpaLocation -> HsTupArg GhcPs

lStmtsImplicits :: forall (idR :: Pass) (body :: Type -> Type). [LStmtLR GhcRn (GhcPass idR) (LocatedA (body (GhcPass idR)))] -> [(SrcSpan, [Name])]

lPatImplicits :: LPat GhcRn -> [(SrcSpan, [Name])]

isUnliftedHsBind :: HsBind GhcTc -> Bool

Should we treat this as an unlifted bind? This will be true for any bind that binds an unlifted variable, but we must be careful around AbsBinds. See Note [Unlifted id check in isUnliftedHsBind]. For usage information, see Note [Strict binds checks] is GHC.HsToCore.Binds.

isInfixFunBind :: forall id1 id2. UnXRec id2 => HsBindLR id1 id2 -> Bool

If any of the matches in the FunBind are infix, the FunBind is considered infix.

isBangedHsBind :: HsBind GhcTc -> Bool

Is a binding a strict variable or pattern bind (e.g. !x = ...)?

hsValBindsImplicits :: forall (idR :: Pass). HsValBindsLR GhcRn (GhcPass idR) -> [(SrcSpan, [Name])]

hsTypeToHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs

Convert an LHsType to an LHsSigWcType.

hsTypeToHsSigType :: LHsType GhcPs -> LHsSigType GhcPs

Convert an LHsType to an LHsSigType.

hsTyClForeignBinders :: [TyClGroup GhcRn] -> [LForeignDecl GhcRn] -> [Name]

hsPatSynSelectors :: forall (p :: Pass). IsPass p => HsValBinds (GhcPass p) -> [FieldOcc (GhcPass p)]

Collects record pattern-synonym selectors only; the pattern synonym names are collected by collectHsValBinders.

hsLTyClDeclBinders :: forall (p :: Pass). IsPass p => LocatedA (TyClDecl (GhcPass p)) -> ([LocatedA (IdP (GhcPass p))], [LFieldOcc (GhcPass p)])

Returns all the binding names of the decl. The first one is guaranteed to be the name of the decl. The first component represents all binding names except record fields; the second represents field occurrences. For record fields mentioned in multiple constructors, the SrcLoc will be from the first occurrence.

Each returned (Located name) has a SrcSpan for the whole declaration. See Note [SrcSpan for binders]

hsGroupBinders :: HsGroup GhcRn -> [Name]

hsForeignDeclsBinders :: forall (p :: Pass) a. (UnXRec (GhcPass p), IsSrcSpanAnn p a) => [LForeignDecl (GhcPass p)] -> [LIdP (GhcPass p)]

See Note [SrcSpan for binders]

hsDataFamInstBinders :: forall (p :: Pass). IsPass p => DataFamInstDecl (GhcPass p) -> ([LocatedA (IdP (GhcPass p))], [LFieldOcc (GhcPass p)])

the SrcLoc returned are for the whole declarations, not just the names

getPatSynBinds :: UnXRec id => [(RecFlag, LHsBinds id)] -> [PatSynBind id id]

emptyTransStmt :: EpAnn [AddEpAnn] -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)

emptyRecStmtName :: Anno [GenLocated (Anno (StmtLR GhcRn GhcRn bodyR)) (StmtLR GhcRn GhcRn bodyR)] ~ SrcSpanAnnL => StmtLR GhcRn GhcRn bodyR

emptyRecStmtId :: Stmt GhcTc (LocatedA (HsCmd GhcTc))

emptyRecStmt :: forall (idL :: Pass) bodyR. Anno [GenLocated (Anno (StmtLR (GhcPass idL) GhcPs bodyR)) (StmtLR (GhcPass idL) GhcPs bodyR)] ~ SrcSpanAnnL => StmtLR (GhcPass idL) GhcPs bodyR

collectStmtsBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> [StmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)]

collectStmtBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> StmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)]

collectPatsBinders :: CollectPass p => CollectFlag p -> [LPat p] -> [IdP p]

collectPatBinders :: CollectPass p => CollectFlag p -> LPat p -> [IdP p]

collectMethodBinders :: UnXRec idL => LHsBindsLR idL idR -> [LIdP idL]

Used exclusively for the bindings of an instance decl which are all FunBinds

collectLocalBinders :: forall (idL :: Pass) (idR :: Pass). CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]

collectLStmtsBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> [LStmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)]

collectLStmtBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> LStmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)]

collectHsValBinders :: forall (idL :: Pass) (idR :: Pass). CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]

collectHsIdBinders :: forall (idL :: Pass) (idR :: Pass). CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]

Collect Id binders only, or Ids + pattern synonyms, respectively

collectHsBindsBinders :: CollectPass p => CollectFlag p -> LHsBindsLR p idR -> [IdP p]

collectHsBindListBinders :: CollectPass p => CollectFlag p -> [LHsBindLR p idR] -> [IdP p]

Same as collectHsBindsBinders, but works over a list of bindings

collectHsBindBinders :: CollectPass p => CollectFlag p -> HsBindLR p idR -> [IdP p]

Collect both Ids and pattern-synonym binders

chunkify :: [a] -> [[a]]

Split a list into lists that are small enough to have a corresponding tuple arity. The sub-lists of the result all have length <= mAX_TUPLE_SIZE But there may be more than mAX_TUPLE_SIZE sub-lists

data XXExprGhcTc

Constructors

WrapExpr !(HsWrap HsExpr)

ExpansionExpr !(HsExpansion (HsExpr GhcRn) (HsExpr GhcTc))

data XBindStmtTc

Constructors

XBindStmtTc

Fields

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

data XBindStmtRn

Constructors

XBindStmtRn

Fields

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

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

Outputable SyntaxExprTc

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExprTc -> SDoc

data SyntaxExprRn

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

Constructors

SyntaxExprRn (HsExpr GhcRn)

NoSyntaxExprRn

Instances

Outputable SyntaxExprRn

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExprRn -> SDoc

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

Equations

SyntaxExprGhc 'Parsed = NoExtField

SyntaxExprGhc 'Renamed = SyntaxExprRn

SyntaxExprGhc 'Typechecked = SyntaxExprTc

data RecordUpdTc

Extra data fields for a RecordUpd, added by the type checker

Constructors

RecordUpdTc

Fields

• rupd_cons :: [ConLike]
• rupd_in_tys :: [Type]
• rupd_out_tys :: [Type]
• rupd_wrap :: HsWrapper

data RecStmtTc

Constructors

RecStmtTc

Fields

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

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 PostTcExpr = HsExpr GhcTc

Post-Type checking Expression

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

data PendingTcSplice

Pending Type-checker Splice

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc)

Instances

Outputable PendingTcSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingTcSplice -> SDoc

data PendingRnSplice

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

Instances

Outputable PendingRnSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingRnSplice -> SDoc

data HsWrap (hs_syn :: Type -> Type)

HsWrap appears only in typechecker output Invariant: The contained Expr is *NOT* itself an HsWrap. See Note [Detecting forced eta expansion] in GHC.HsToCore.Expr. This invariant is maintained by mkHsWrap. hs_syn is something like HsExpr or HsCmd

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)

newtype HsSplicedT

Constructors

HsSplicedT DelayedSplice

Instances

Data HsSplicedT

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HsSplicedT -> Constr

dataTypeOf :: HsSplicedT -> DataType

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

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

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

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

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

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

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

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

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

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

data HsExpansion a b

Constructors

HsExpanded a b

Instances

(Data a, Data b) => Data (HsExpansion a b)

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HsExpansion a b -> Constr

dataTypeOf :: HsExpansion a b -> DataType

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

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

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

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

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

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

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

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

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

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

(Outputable a, Outputable b) => Outputable (HsExpansion a b)

Just print the original expression (the a).

Defined in GHC.Hs.Expr

Methods

ppr :: HsExpansion a b -> SDoc

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

Outputable GrhsAnn

Defined in GHC.Hs.Expr

Methods

ppr :: GrhsAnn -> SDoc

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

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 CmdTopTc

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc)

data AnnsLet

Constructors

AnnsLet

Fields

• alLet :: EpaLocation
• alIn :: EpaLocation

Instances

Data AnnsLet

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: AnnsLet -> Constr

dataTypeOf :: AnnsLet -> DataType

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

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

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

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

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

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

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

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

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

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

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

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

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

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

tupArgPresent :: forall (p :: Pass). HsTupArg (GhcPass p) -> Bool

thTyBrackets :: SDoc -> SDoc

thBrackets :: SDoc -> SDoc -> SDoc

stripParensLHsExpr :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)

stripParensHsExpr :: forall (p :: Pass). HsExpr (GhcPass p) -> HsExpr (GhcPass p)

ppr_splice_decl :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SDoc

ppr_splice :: forall (p :: Pass). OutputableBndrId p => SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc

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

ppr_module_name_prefix :: Maybe ModuleName -> SDoc

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pprHsBracket :: forall (p :: Pass). OutputableBndrId p => HsBracket (GhcPass p) -> SDoc

pprGRHSs :: forall (idR :: Pass) body passL. (OutputableBndrId idR, Outputable body) => HsMatchContext passL -> GRHSs (GhcPass idR) body -> SDoc

pprGRHS :: forall (idR :: Pass) body passL. (OutputableBndrId idR, Outputable body) => HsMatchContext passL -> GRHS (GhcPass idR) body -> SDoc

pprDo :: forall (p :: Pass) body any. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => HsStmtContext any -> [LStmt (GhcPass p) body] -> SDoc

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

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

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

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

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

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

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

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

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

pp_dotdot :: SDoc

parenthesizeHsExpr :: forall (p :: Pass). 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.

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

noExpr :: forall (p :: Pass). HsExpr (GhcPass p)

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

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

matchGroupArity :: forall (id :: Pass) body. MatchGroup (GhcPass id) body -> Arity

matchContextErrString :: forall (p :: Pass). OutputableBndrId p => HsMatchContext (GhcPass p) -> SDoc

matchArrowContextErrString :: HsArrowMatchContext -> SDoc

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

Is there only one RHS in this list of matches?

isQuietHsExpr :: HsExpr id -> Bool

isQuietHsCmd :: HsCmd id -> Bool

isEmptyMatchGroup :: forall (p :: Pass) body. MatchGroup (GhcPass p) body -> Bool

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

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

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

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

data NHsValBindsLR idL

Constructors

NValBinds [(RecFlag, LHsBinds idL)] [LSig GhcRn]

data AnnSig

Constructors

AnnSig

Fields

• asDcolon :: AddEpAnn
• asRest :: [AddEpAnn]

Instances

Data AnnSig

Defined in GHC.Hs.Binds

Methods

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

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

toConstr :: AnnSig -> Constr

dataTypeOf :: AnnSig -> DataType

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

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

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

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

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

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

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

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

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

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

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

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

pragBrackets :: SDoc -> SDoc

ppr_sig :: forall (p :: Pass). OutputableBndrId p => Sig (GhcPass p) -> SDoc

ppr_monobind :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsBindLR (GhcPass idL) (GhcPass idR) -> SDoc

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

pprTicks :: SDoc -> SDoc -> SDoc

pprTcSpecPrags :: TcSpecPrags -> SDoc

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

pprMinimalSig :: OutputableBndr name => LBooleanFormula (GenLocated l name) -> SDoc

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

pprLHsBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => LHsBindsLR (GhcPass idL) (GhcPass idR) -> SDoc

pprDeclList :: [SDoc] -> SDoc

plusHsValBinds :: forall (a :: Pass). HsValBinds (GhcPass a) -> HsValBinds (GhcPass a) -> HsValBinds (GhcPass a)

isEmptyValBinds :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b) -> Bool

isEmptyLHsBinds :: forall (idL :: Pass) idR. LHsBindsLR (GhcPass idL) idR -> Bool

isEmptyIPBindsTc :: HsIPBinds GhcTc -> Bool

isEmptyIPBindsPR :: forall (p :: Pass). HsIPBinds (GhcPass p) -> Bool

eqEmptyLocalBinds :: HsLocalBindsLR a b -> Bool

emptyValBindsOut :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b)

emptyValBindsIn :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b)

emptyLocalBinds :: forall (a :: Pass) (b :: Pass). HsLocalBindsLR (GhcPass a) (GhcPass b)

emptyLHsBinds :: forall (idL :: Pass) idR. LHsBindsLR (GhcPass idL) idR

mkHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)

mkHsAppKindTy :: forall (p :: Pass). XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)

pprSpliceDecl :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SpliceExplicitFlag -> SDoc

pprSplice :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SDoc

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

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

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

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

data UntypedSpliceFlavour

Constructors

UntypedExpSplice

UntypedPatSplice

UntypedTypeSplice

UntypedDeclSplice

Instances

Data UntypedSpliceFlavour

Defined in Language.Haskell.Syntax.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

data TransForm

Constructors

ThenForm

GroupForm

Instances

Data TransForm

Defined in Language.Haskell.Syntax.Expr

Methods

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

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

toConstr :: TransForm -> Constr

dataTypeOf :: TransForm -> DataType

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

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

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

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

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

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

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

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

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

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

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 Language.Haskell.Syntax.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

data StmtLR idL idR body

Exact print annotations when in qualifier lists or guards - AnnKeywordId : AnnVbar, AnnComma,AnnThen, AnnBy,AnnBy, AnnGroup,AnnUsing

Constructors

LastStmt (XLastStmt idL idR body) body (Maybe Bool) (SyntaxExpr idR)

BindStmt

Fields

• (XBindStmt idL idR body)

  Post renaming has optional fail and bind / (>>=) operator. Post typechecking, also has multiplicity of the argument and the result type of the function passed to bind; that is, (P, S) in (>>=) :: Q -> (R # P -> S) -> T See Note [The type of bind in Stmts]

• (LPat idL)
• body

ApplicativeStmt (XApplicativeStmt idL idR body) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))

ApplicativeStmt represents an applicative expression built with <$> and <*>. It is generated by the renamer, and is desugared into the appropriate applicative expression by the desugarer, but it is intended to be invisible in error messages.

For full details, see Note [ApplicativeDo] in GHC.Rename.Expr

BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR)

LetStmt (XLetStmt idL idR body) (HsLocalBindsLR idL idR)

• AnnKeywordId : AnnLet AnnOpen '{',AnnClose '}',

ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR)

TransStmt

Fields

• trS_ext :: XTransStmt idL idR body
• trS_form :: TransForm
• trS_stmts :: [ExprLStmt idL]
• trS_bndrs :: [(IdP idR, IdP idR)]
• trS_using :: LHsExpr idR
• trS_by :: Maybe (LHsExpr idR)
• trS_ret :: SyntaxExpr idR
• trS_bind :: SyntaxExpr idR
• trS_fmap :: HsExpr idR

RecStmt

• AnnKeywordId : AnnRec

Fields

• recS_ext :: XRecStmt idL idR body
• recS_stmts :: XRec idR [LStmtLR idL idR body]
• recS_later_ids :: [IdP idR]
• recS_rec_ids :: [IdP idR]
• recS_bind_fn :: SyntaxExpr idR
• recS_ret_fn :: SyntaxExpr idR
• recS_mfix_fn :: SyntaxExpr idR

XStmtLR !(XXStmtLR idL idR body)

Instances

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.Types

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))

Defined in GHC.Hs.Expr

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

type Stmt id body = StmtLR id id body

do block Statement

type SplicePointName = Name

data SpliceDecoration

A splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.

Constructors

DollarSplice

$splice or $$splice

BareSplice

bare splice

Instances

Data SpliceDecoration

Defined in Language.Haskell.Syntax.Expr

Methods

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

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

toConstr :: SpliceDecoration -> Constr

dataTypeOf :: SpliceDecoration -> DataType

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

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

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

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

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

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

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

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

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

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

Show SpliceDecoration

Defined in Language.Haskell.Syntax.Expr

Methods

showsPrec :: Int -> SpliceDecoration -> ShowS

show :: SpliceDecoration -> String

showList :: [SpliceDecoration] -> ShowS

Outputable SpliceDecoration

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: SpliceDecoration -> SDoc

Eq SpliceDecoration

Defined in Language.Haskell.Syntax.Expr

Methods

(==) :: SpliceDecoration -> SpliceDecoration -> Bool

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

type RecUpdProj p = RecProj p (LHsExpr p)

type RecProj p arg = HsRecField' (FieldLabelStrings p) arg

type family PendingTcSplice' p

Instances

type PendingTcSplice' (GhcPass _1)

Defined in GHC.Hs.Expr

type PendingTcSplice' (GhcPass _1) = PendingTcSplice

type family PendingRnSplice' p

Instances

type PendingRnSplice' (GhcPass _1)

Defined in GHC.Hs.Expr

type PendingRnSplice' (GhcPass _1) = PendingRnSplice

data ParStmtBlock idL idR

Parenthesised Statement Block

Constructors

ParStmtBlock (XParStmtBlock idL idR) [ExprLStmt idL] [IdP idR] (SyntaxExpr idR)

XParStmtBlock !(XXParStmtBlock idL idR)

data MatchGroupTc

Constructors

MatchGroupTc

Fields

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

Instances

Data MatchGroupTc

Defined in Language.Haskell.Syntax.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 Match p body

Constructors

Match

Fields

• m_ext :: XCMatch p body
• m_ctxt :: HsMatchContext (NoGhcTc p)
• m_pats :: [LPat p]
• m_grhss :: GRHSs p body

XMatch !(XXMatch p body)

Instances

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.PostProcess

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type LStmtLR idL idR body = XRec idL (StmtLR idL idR body)

Located Statement with separate Left and Right id's

type LStmt id body = XRec id (StmtLR id id body)

Located do block Statement

type LMatch id body = XRec id (Match id body)

Located Match

May have AnnKeywordId : AnnSemi when in a list

type LHsTupArg id = XRec id (HsTupArg id)

Located Haskell Tuple Argument

HsTupArg is used for tuple sections (,a,) is represented by ExplicitTuple [Missing ty1, Present a, Missing ty3] Which in turn stands for (x:ty1 y:ty2. (x,a,y))

type LHsRecUpdProj p = XRec p (RecUpdProj p)

type LHsRecProj p arg = XRec p (RecProj p arg)

type LHsCmdTop p = XRec p (HsCmdTop p)

Top-level command, introducing a new arrow. This may occur inside a proc (where the stack is empty) or as an argument of a command-forming operator.

Located Haskell Top-level Command

type LHsCmd id = XRec id (HsCmd id)

Located Haskell Command (for arrow syntax)

type LGRHS id body = XRec id (GRHS id body)

Located Guarded Right-Hand Side

data HsTupArg id

• AnnKeywordId : AnnComma

Haskell Tuple Argument

Constructors

Present (XPresent id) (LHsExpr id)

The argument

Missing (XMissing id)

The argument is missing, but this is its type

XTupArg !(XXTupArg id)

Note [Trees that Grow] extension point

data HsStmtContext p

Haskell Statement Context.

Constructors

ListComp

MonadComp

DoExpr (Maybe ModuleName)

ModuleName.

do { ... }

MDoExpr (Maybe ModuleName)

ModuleName.

mdo { ... } ie recursive do-expression

ArrowExpr

do-notation in an arrow-command context

GhciStmtCtxt

A command-line Stmt in GHCi pat <- rhs

PatGuard (HsMatchContext p)

Pattern guard for specified thing

ParStmtCtxt (HsStmtContext p)

A branch of a parallel stmt

TransStmtCtxt (HsStmtContext p)

A branch of a transform stmt

data HsSplicedThing id

Haskell Spliced Thing

Values that can result from running a splice.

Constructors

HsSplicedExpr (HsExpr id)

Haskell Spliced Expression

HsSplicedTy (HsType id)

Haskell Spliced Type

HsSplicedPat (Pat id)

Haskell Spliced Pattern

type HsRecordBinds p = HsRecFields p (LHsExpr p)

Haskell Record Bindings

data HsPragE p

A pragma, written as {-# ... #-}, that may appear within an expression.

Constructors

HsPragSCC (XSCC p) SourceText StringLiteral

XHsPragE !(XXPragE p)

• AnnKeywordId : AnnOpen, AnnOpen '{-# GENERATED', AnnVal,AnnVal, AnnColon,AnnVal, AnnMinus, AnnVal,AnnColon, AnnVal, AnnClose '#-}'

data HsMatchContext p

Haskell Match Context

Context of a pattern match. This is more subtle than it would seem. See Note [Varieties of pattern matches].

Constructors

FunRhs

Fields

• mc_fun :: LIdP p

  function binder of f

• mc_fixity :: LexicalFixity

  fixing of f

• mc_strictness :: SrcStrictness

  was f banged? See Note [FunBind vs PatBind]

LambdaExpr

Patterns of a lambda

CaseAlt

Patterns and guards on a case alternative

IfAlt

Guards of a multi-way if alternative

ArrowMatchCtxt HsArrowMatchContext

A pattern match inside arrow notation

PatBindRhs

A pattern binding eg [y] <- e = e

PatBindGuards

Guards of pattern bindings, e.g., (Just b) | Just _ <- x = e | otherwise = e'

RecUpd

Record update [used only in GHC.HsToCore.Expr to tell matchWrapper what sort of runtime error message to generate]

StmtCtxt (HsStmtContext p)

Pattern of a do-stmt, list comprehension, pattern guard, etc

ThPatSplice

A Template Haskell pattern splice

ThPatQuote

A Template Haskell pattern quotation [p| (a,b) |]

PatSyn

A pattern synonym declaration

data HsFieldLabel p

Constructors

HsFieldLabel

Fields

• hflExt :: XCHsFieldLabel p
• hflLabel :: Located FieldLabelString

XHsFieldLabel !(XXHsFieldLabel p)

Instances

Outputable (HsFieldLabel p)

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: HsFieldLabel p -> SDoc

type family HsDoRn p

The AST used to hard-refer to GhcPass, which was a layer violation. For now, we paper it over with this new extension point.

Instances

type HsDoRn (GhcPass _1)

Defined in GHC.Hs.Expr

type HsDoRn (GhcPass _1) = GhcRn

data HsCmdTop p

Haskell Top-level Command

Constructors

HsCmdTop (XCmdTop p) (LHsCmd p)

XCmdTop !(XXCmdTop p)

Instances

type Anno (HsCmdTop (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsCmdTop (GhcPass p)) = SrcSpan

data HsCmd id

Haskell Command (e.g. a "statement" in an Arrow proc block)

Constructors

HsCmdArrApp (XCmdArrApp id) (LHsExpr id) (LHsExpr id) HsArrAppType Bool

• AnnKeywordId : Annlarrowtail, Annrarrowtail,AnnLarrowtail, AnnRarrowtail

HsCmdArrForm (XCmdArrForm id) (LHsExpr id) LexicalFixity (Maybe Fixity) [LHsCmdTop id]

• AnnKeywordId : AnnOpenB '(|', AnnCloseB '|)'

HsCmdApp (XCmdApp id) (LHsCmd id) (LHsExpr id)

HsCmdLam (XCmdLam id) (MatchGroup id (LHsCmd id))

• AnnKeywordId : AnnLam, AnnRarrow,

HsCmdPar (XCmdPar id) (LHsCmd id)

• AnnKeywordId : AnnOpen '(', AnnClose ')'

HsCmdCase (XCmdCase id) (LHsExpr id) (MatchGroup id (LHsCmd id))

• AnnKeywordId : AnnCase, AnnOf,AnnOpen '{', AnnClose '}'

HsCmdLamCase (XCmdLamCase id) (MatchGroup id (LHsCmd id))

• AnnKeywordId : AnnLam, AnnCase,AnnOpen '{', AnnClose '}'

HsCmdIf (XCmdIf id) (SyntaxExpr id) (LHsExpr id) (LHsCmd id) (LHsCmd id)

• AnnKeywordId : AnnIf, AnnSemi, AnnThen,AnnSemi, AnnElse,

HsCmdLet (XCmdLet id) (HsLocalBinds id) (LHsCmd id)

• AnnKeywordId : AnnLet, AnnOpen '{', AnnClose '}',AnnIn

HsCmdDo (XCmdDo id) (XRec id [CmdLStmt id])

• AnnKeywordId : AnnDo, AnnOpen, AnnSemi, AnnVbar, AnnClose

XCmd !(XXCmd id)

Instances

DisambECP (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsCmd GhcPs) :: Type -> Type

type InfixOp (HsCmd GhcPs)

type FunArg (HsCmd GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsCmd GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsCmd GhcPs))

mkHsProjUpdatePV :: SrcSpan -> Located [Located (HsFieldLabel GhcPs)] -> LocatedA (HsCmd GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsCmd GhcPs)))

mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs))

mkHsLetPV :: SrcSpan -> HsLocalBinds GhcPs -> LocatedA (HsCmd GhcPs) -> AnnsLet -> PV (LocatedA (HsCmd GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (HsCmd GhcPs)) => PV (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs))

mkHsOpAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> LocatedN (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsCmd GhcPs))

mkHsLamCasePV :: SrcSpan -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

superFunArg :: (DisambECP (FunArg (HsCmd GhcPs)) => PV (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs))

mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LocatedA (FunArg (HsCmd GhcPs)) -> PV (LocatedA (HsCmd GhcPs))

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (HsCmd GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsCmd GhcPs) -> Bool -> LocatedA (HsCmd GhcPs) -> AnnsIf -> PV (LocatedA (HsCmd GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsCmd GhcPs))] -> AnnList -> PV (LocatedA (HsCmd GhcPs))

mkHsParPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> AnnParen -> PV (LocatedA (HsCmd GhcPs))

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsCmd GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd GhcPs))

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsCmd GhcPs)] -> AnnList -> PV (LocatedA (HsCmd GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsCmd GhcPs) -> ([Fbind (HsCmd GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsNegAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsLazyPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsBangPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

rejectPragmaPV :: LocatedA (HsCmd GhcPs) -> PV ()

type Body (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

type Body (HsCmd GhcPs) = HsCmd

type FunArg (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

type FunArg (HsCmd GhcPs) = HsExpr GhcPs

type InfixOp (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

type InfixOp (HsCmd GhcPs) = HsExpr GhcPs

type Anno (HsCmd (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsCmd (GhcPass p)) = SrcSpanAnnA

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpan

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

type family HsBracketRn p

Instances

type HsBracketRn (GhcPass _1)

Defined in GHC.Hs.Expr

type HsBracketRn (GhcPass _1) = GhcRn

data HsBracket p

Haskell Bracket

Constructors

ExpBr (XExpBr p) (LHsExpr p)

PatBr (XPatBr p) (LPat p)

DecBrL (XDecBrL p) [LHsDecl p]

DecBrG (XDecBrG p) (HsGroup p)

TypBr (XTypBr p) (LHsType p)

VarBr (XVarBr p) Bool (LIdP p)

TExpBr (XTExpBr p) (LHsExpr p)

XBracket !(XXBracket p)

data HsArrowMatchContext

Haskell arrow match context.

Constructors

ProcExpr

A proc expression

ArrowCaseAlt

A case alternative inside arrow notation

KappaExpr

An arrow kappa abstraction

data HsArrAppType

Haskell Array Application Type

Constructors

HsHigherOrderApp

HsFirstOrderApp

Instances

Data HsArrAppType

Defined in Language.Haskell.Syntax.Expr

Methods

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

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

toConstr :: HsArrAppType -> Constr

dataTypeOf :: HsArrAppType -> DataType

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

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

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

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

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

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

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

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

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

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

type GuardStmt id = Stmt id (LHsExpr id)

Guard Statement

type GuardLStmt id = LStmt id (LHsExpr id)

Guard Located Statement

type GhciStmt id = Stmt id (LHsExpr id)

Ghci Statement

type GhciLStmt id = LStmt id (LHsExpr id)

Ghci Located Statement

data GRHS p body

Guarded Right Hand Side.

Constructors

GRHS (XCGRHS p body) [GuardLStmt p] body

XGRHS !(XXGRHS p body)

Instances

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpan

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpan

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpan

newtype FieldLabelStrings p

RecordDotSyntax field updates

Constructors

FieldLabelStrings [Located (HsFieldLabel p)]

Instances

Outputable (FieldLabelStrings p)

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: FieldLabelStrings p -> SDoc

OutputableBndr (FieldLabelStrings p)

Defined in Language.Haskell.Syntax.Expr

Methods

pprBndr :: BindingSite -> FieldLabelStrings p -> SDoc

pprPrefixOcc :: FieldLabelStrings p -> SDoc

pprInfixOcc :: FieldLabelStrings p -> SDoc

bndrIsJoin_maybe :: FieldLabelStrings p -> Maybe Int

type FailOperator id = Maybe (SyntaxExpr id)

The fail operator

This is used for `.. <-` "bind statements" in do notation, including non-monadic "binds" in applicative.

The fail operator is 'Just expr' if it potentially fail monadically. if the pattern match cannot fail, or shouldn't fail monadically (regular incomplete pattern exception), it is Nothing.

See Note [Monad fail : Rebindable syntax, overloaded strings] for the type of expression in the Just case, and why it is so.

See Note [Failing pattern matches in Stmts] for which contexts for 'BindStmt's should use the monadic fail and which shouldn't.

type ExprStmt id = Stmt id (LHsExpr id)

Expression Statement

type ExprLStmt id = LStmt id (LHsExpr id)

Expression Located Statement

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

Command Syntax Table (for Arrow syntax)

type CmdStmt id = Stmt id (LHsCmd id)

Command Statement

type CmdLStmt id = LStmt id (LHsCmd id)

Command Located Statement

data ArithSeqInfo id

Arithmetic Sequence Information

Constructors

From (LHsExpr id)

FromThen (LHsExpr id) (LHsExpr id)

FromTo (LHsExpr id) (LHsExpr id)

FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id)

type family ApplicativeArgStmCtxPass idL

Instances

type ApplicativeArgStmCtxPass _1

Defined in GHC.Hs.Expr

type ApplicativeArgStmCtxPass _1 = GhcRn

data ApplicativeArg idL

Applicative Argument

Constructors

ApplicativeArgOne

Fields

• xarg_app_arg_one :: XApplicativeArgOne idL

  The fail operator, after renaming

  The fail operator is needed if this is a BindStmt where the pattern can fail. E.g.: (Just a) <- stmt The fail operator will be invoked if the pattern match fails. It is also used for guards in MonadComprehensions. The fail operator is Nothing if the pattern match can't fail

• app_arg_pattern :: LPat idL
• arg_expr :: LHsExpr idL
• is_body_stmt :: Bool

  True = was a BodyStmt, False = was a BindStmt. See Note [Applicative BodyStmt]

ApplicativeArgMany

Fields

• xarg_app_arg_many :: XApplicativeArgMany idL
• app_stmts :: [ExprLStmt idL]
• final_expr :: HsExpr idL
• bv_pattern :: LPat idL
• stmt_context :: HsStmtContext (ApplicativeArgStmCtxPass idL)

  context of the do expression, used in pprArg

XApplicativeArg !(XXApplicativeArg idL)

qualifiedDoModuleName_maybe :: HsStmtContext p -> Maybe ModuleName

prependQualified :: Maybe ModuleName -> SDoc -> SDoc

pprStmtContext :: (Outputable (IdP p), UnXRec p) => HsStmtContext p -> SDoc

pprMatchContextNoun :: (Outputable (IdP p), UnXRec p) => HsMatchContext p -> SDoc

pprMatchContext :: (Outputable (IdP p), UnXRec p) => HsMatchContext p -> SDoc

pprFieldLabelStrings :: FieldLabelStrings p -> SDoc

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

pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc

pprAStmtContext :: (Outputable (IdP p), UnXRec p) => HsStmtContext p -> SDoc

matchSeparator :: HsMatchContext p -> SDoc

isTypedSplice :: HsSplice id -> Bool

isTypedBracket :: HsBracket id -> Bool

isPatSynCtxt :: HsMatchContext p -> Bool

isMonadStmtContext :: HsStmtContext id -> Bool

Is this a monadic context?

isMonadCompContext :: HsStmtContext id -> Bool

isInfixMatch :: Match id body -> Bool

isComprehensionContext :: HsStmtContext id -> Bool

data WarnDecls pass

Warning pragma Declarations

Constructors

Warnings

Fields

• wd_ext :: XWarnings pass
• wd_src :: SourceText
• wd_warnings :: [LWarnDecl pass]

XWarnDecls !(XXWarnDecls pass)

Instances

type Anno (WarnDecls (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (WarnDecls (GhcPass p)) = SrcSpanAnnA

data WarnDecl pass

Warning pragma Declaration

Constructors

Warning (XWarning pass) [LIdP pass] WarningTxt

XWarnDecl !(XXWarnDecl pass)

Instances

type Anno (WarnDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (WarnDecl (GhcPass p)) = SrcSpanAnnA

type TyFamInstEqn pass = FamEqn pass (LHsType pass)

Type Family Instance Equation

data TyFamInstDecl pass

Type Family Instance Declaration

Constructors

TyFamInstDecl

• AnnKeywordId : AnnType, AnnInstance,

Fields

• tfid_xtn :: XCTyFamInstDecl pass
• tfid_eqn :: TyFamInstEqn pass

XTyFamInstDecl !(XXTyFamInstDecl pass)

Instances

type Anno (TyFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (TyFamInstDecl (GhcPass p)) = SrcSpanAnnA

type TyFamDefltDecl = TyFamInstDecl

Type family default declarations. A convenient synonym for TyFamInstDecl. See Note [Type family instance declarations in HsSyn].

data TyClGroup pass

Type or Class Group

Constructors

TyClGroup

Fields

• group_ext :: XCTyClGroup pass
• group_tyclds :: [LTyClDecl pass]
• group_roles :: [LRoleAnnotDecl pass]
• group_kisigs :: [LStandaloneKindSig pass]
• group_instds :: [LInstDecl pass]

XTyClGroup !(XXTyClGroup pass)

data TyClDecl pass

A type or class declaration.

Constructors

FamDecl

type/data family T :: *->*

• AnnKeywordId : AnnType, AnnData, AnnFamily,AnnDcolon, AnnWhere,AnnOpenP, AnnDcolon,AnnCloseP, AnnEqual,AnnRarrow, AnnVbar

Fields

• tcdFExt :: XFamDecl pass
• tcdFam :: FamilyDecl pass

SynDecl

type declaration

• AnnKeywordId : AnnType, AnnEqual,

Fields

• tcdSExt :: XSynDecl pass

  Post renameer, FVs

• tcdLName :: LIdP pass

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdRhs :: LHsType pass

  RHS of type declaration

DataDecl

data declaration

• AnnKeywordId : AnnData, AnnFamily, AnnNewType, AnnNewType,AnnDcolon AnnWhere,

Fields

• tcdDExt :: XDataDecl pass

  Post renamer, CUSK flag, FVs

• tcdLName :: LIdP pass

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdDataDefn :: HsDataDefn pass

ClassDecl

Fields

• tcdCExt :: XClassDecl pass

  Post renamer, FVs

• tcdCtxt :: Maybe (LHsContext pass)

  Context...

• tcdLName :: LIdP pass

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdFDs :: [LHsFunDep pass]

  Functional deps

• tcdSigs :: [LSig pass]

  Methods' signatures

• tcdMeths :: LHsBinds pass

  Default methods

• tcdATs :: [LFamilyDecl pass]

  Associated types;

• tcdATDefs :: [LTyFamDefltDecl pass]

  Associated type defaults

• tcdDocs :: [LDocDecl pass]

  Haddock docs

XTyClDecl !(XXTyClDecl pass)

Instances

type Anno (TyClDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA

data StandaloneKindSig pass

Constructors

StandaloneKindSig (XStandaloneKindSig pass) (LIdP pass) (LHsSigType pass)

XStandaloneKindSig !(XXStandaloneKindSig pass)

Instances

type Anno (StandaloneKindSig (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA

data SpliceDecl p

Splice Declaration

Constructors

SpliceDecl (XSpliceDecl p) (XRec p (HsSplice p)) SpliceExplicitFlag

XSpliceDecl !(XXSpliceDecl p)

Instances

type Anno (SpliceDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (SpliceDecl (GhcPass p)) = SrcSpanAnnA

data RuleDecls pass

Rule Declarations

Constructors

HsRules

Fields

• rds_ext :: XCRuleDecls pass
• rds_src :: SourceText
• rds_rules :: [LRuleDecl pass]

XRuleDecls !(XXRuleDecls pass)

Instances

type Anno (RuleDecls (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleDecls (GhcPass p)) = SrcSpanAnnA

data RuleDecl pass

Rule Declaration

Constructors

HsRule

Fields

• rd_ext :: XHsRule pass

  After renamer, free-vars from the LHS and RHS

• rd_name :: XRec pass (SourceText, RuleName)

  Note [Pragma source text] in GHC.Types.Basic

• rd_act :: Activation
• rd_tyvs :: Maybe [LHsTyVarBndr () (NoGhcTc pass)]

  Forall'd type vars

• rd_tmvs :: [LRuleBndr pass]

  Forall'd term vars, before typechecking; after typechecking this includes all forall'd vars

• rd_lhs :: XRec pass (HsExpr pass)
• rd_rhs :: XRec pass (HsExpr pass)
  • AnnKeywordId : AnnOpen,AnnTilde, AnnVal, AnnClose, AnnForall,AnnDot, AnnEqual,

XRuleDecl !(XXRuleDecl pass)

Instances

type Anno (RuleDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleDecl (GhcPass p)) = SrcSpanAnnA

data RuleBndr pass

Rule Binder

Constructors

RuleBndr (XCRuleBndr pass) (LIdP pass)

RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass)

XRuleBndr !(XXRuleBndr pass)

• AnnKeywordId : AnnOpen, AnnDcolon,AnnClose

Instances

type Anno (RuleBndr (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleBndr (GhcPass p)) = SrcSpan

data RoleAnnotDecl pass

Role Annotation Declaration

Constructors

RoleAnnotDecl (XCRoleAnnotDecl pass) (LIdP pass) [XRec pass (Maybe Role)]

• AnnKeywordId : AnnType, AnnRole

XRoleAnnotDecl !(XXRoleAnnotDecl pass)

Instances

type Anno (RoleAnnotDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RoleAnnotDecl (GhcPass p)) = SrcSpanAnnA

data NewOrData

Constructors

NewType

newtype Blah ...

DataType

data Blah ...

Instances

Data NewOrData

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: NewOrData -> Constr

dataTypeOf :: NewOrData -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable NewOrData

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: NewOrData -> SDoc

Eq NewOrData

Defined in Language.Haskell.Syntax.Decls

Methods

(==) :: NewOrData -> NewOrData -> Bool

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

type LWarnDecls pass = XRec pass (WarnDecls pass)

Located Warning Declarations

type LWarnDecl pass = XRec pass (WarnDecl pass)

Located Warning pragma Declaration

type LTyFamInstEqn pass

Arguments

 = XRec pass (TyFamInstEqn pass)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass)

Located Type Family Instance Declaration

type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass)

Located type family default declarations.

type LTyClDecl pass = XRec pass (TyClDecl pass)

Located Declaration of a Type or Class

type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass)

Located Standalone Kind Signature

type LSpliceDecl pass = XRec pass (SpliceDecl pass)

Located Splice Declaration

type LRuleDecls pass = XRec pass (RuleDecls pass)

Located Rule Declarations

type LRuleDecl pass = XRec pass (RuleDecl pass)

Located Rule Declaration

type LRuleBndr pass = XRec pass (RuleBndr pass)

Located Rule Binder

type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass)

Located Role Annotation Declaration

type LInstDecl pass = XRec pass (InstDecl pass)

Located Instance Declaration

type LInjectivityAnn pass = XRec pass (InjectivityAnn pass)

Located Injectivity Annotation

type LHsFunDep pass = XRec pass (FunDep pass)

type LHsDerivingClause pass = XRec pass (HsDerivingClause pass)

type LHsDecl p

Arguments

 = XRec p (HsDecl p)

When in a list this may have

• AnnKeywordId : AnnSemi

type LForeignDecl pass = XRec pass (ForeignDecl pass)

Located Foreign Declaration

type LFamilyResultSig pass = XRec pass (FamilyResultSig pass)

Located type Family Result Signature

type LFamilyDecl pass = XRec pass (FamilyDecl pass)

Located type Family Declaration

type LDocDecl pass = XRec pass DocDecl

Located Documentation comment Declaration

type LDerivStrategy pass = XRec pass (DerivStrategy pass)

A Located DerivStrategy.

type LDerivDecl pass = XRec pass (DerivDecl pass)

Located stand-alone 'deriving instance' declaration

type LDerivClauseTys pass = XRec pass (DerivClauseTys pass)

type LDefaultDecl pass = XRec pass (DefaultDecl pass)

Located Default Declaration

type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass)

Located Data Family Instance Declaration

type LConDecl pass

Arguments

 = XRec pass (ConDecl pass)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

Located data Constructor Declaration

type LClsInstDecl pass = XRec pass (ClsInstDecl pass)

Located Class Instance Declaration

type LAnnDecl pass = XRec pass (AnnDecl pass)

Located Annotation Declaration

data InstDecl pass

Instance Declaration

Constructors

ClsInstD

Fields

• cid_d_ext :: XClsInstD pass
• cid_inst :: ClsInstDecl pass

DataFamInstD

Fields

• dfid_ext :: XDataFamInstD pass
• dfid_inst :: DataFamInstDecl pass

TyFamInstD

Fields

• tfid_ext :: XTyFamInstD pass
• tfid_inst :: TyFamInstDecl pass

XInstDecl !(XXInstDecl pass)

Instances

type Anno (InstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (InstDecl (GhcPass p)) = SrcSpanAnnA

data InjectivityAnn pass

If the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:

type family Foo a b c = r | r -> a c where ...

This will be represented as "InjectivityAnn r [a, c]"

Constructors

InjectivityAnn (XCInjectivityAnn pass) (LIdP pass) [LIdP pass]

• AnnKeywordId : AnnRarrow, AnnVbar

XInjectivityAnn !(XXInjectivityAnn pass)

Instances

type Anno (InjectivityAnn (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (InjectivityAnn (GhcPass p)) = SrcSpan

type HsTyPats pass = [LHsTypeArg pass]

Haskell Type Patterns

data HsRuleRn

Constructors

HsRuleRn NameSet NameSet

Instances

Data HsRuleRn

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: HsRuleRn -> Constr

dataTypeOf :: HsRuleRn -> DataType

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

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

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

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

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

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

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

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

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

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

data HsGroup p

Haskell Group

A HsDecl is categorised into a HsGroup before being fed to the renamer.

Constructors

HsGroup

Fields

• hs_ext :: XCHsGroup p
• hs_valds :: HsValBinds p
• hs_splcds :: [LSpliceDecl p]
• hs_tyclds :: [TyClGroup p]
• hs_derivds :: [LDerivDecl p]
• hs_fixds :: [LFixitySig p]
• hs_defds :: [LDefaultDecl p]
• hs_fords :: [LForeignDecl p]
• hs_warnds :: [LWarnDecls p]
• hs_annds :: [LAnnDecl p]
• hs_ruleds :: [LRuleDecls p]
• hs_docs :: [LDocDecl p]

XHsGroup !(XXHsGroup p)

data HsDerivingClause pass

A single deriving clause of a data declaration.

• AnnKeywordId : AnnDeriving, AnnStock, AnnAnyClass, AnnNewtype, AnnOpen,AnnClose

Constructors

HsDerivingClause

Fields

• deriv_clause_ext :: XCHsDerivingClause pass
• deriv_clause_strategy :: Maybe (LDerivStrategy pass)

  The user-specified strategy (if any) to use when deriving deriv_clause_tys.

• deriv_clause_tys :: LDerivClauseTys pass

  The types to derive.

XHsDerivingClause !(XXHsDerivingClause pass)

Instances

type Anno (HsDerivingClause (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (HsDerivingClause (GhcPass p)) = SrcSpan

type HsDeriving pass

Arguments

 = [LHsDerivingClause pass]

The optional deriving clauses of a data declaration. Clauses is plural because one can specify multiple deriving clauses using the -XDerivingStrategies language extension.

The list of LHsDerivingClauses corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.

Haskell Deriving clause

data HsDecl p

A Haskell Declaration

Constructors

TyClD (XTyClD p) (TyClDecl p)

Type or Class Declaration

InstD (XInstD p) (InstDecl p)

Instance declaration

DerivD (XDerivD p) (DerivDecl p)

Deriving declaration

ValD (XValD p) (HsBind p)

Value declaration

SigD (XSigD p) (Sig p)

Signature declaration

KindSigD (XKindSigD p) (StandaloneKindSig p)

Standalone kind signature

DefD (XDefD p) (DefaultDecl p)

'default' declaration

ForD (XForD p) (ForeignDecl p)

Foreign declaration

WarningD (XWarningD p) (WarnDecls p)

Warning declaration

AnnD (XAnnD p) (AnnDecl p)

Annotation declaration

RuleD (XRuleD p) (RuleDecls p)

Rule declaration

SpliceD (XSpliceD p) (SpliceDecl p)

Splice declaration (Includes quasi-quotes)

DocD (XDocD p) DocDecl

Documentation comment declaration

RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)

Role annotation declaration

XHsDecl !(XXHsDecl p)

Instances

type Anno (HsDecl (GhcPass _1))

Defined in GHC.Hs.Decls

type Anno (HsDecl (GhcPass _1)) = SrcSpanAnnA

data HsDataDefn pass

Haskell Data type Definition

Constructors

HsDataDefn

Declares a data type or newtype, giving its constructors data/newtype T a = constrs data/newtype instance T [a] = constrs

Fields

• dd_ext :: XCHsDataDefn pass
• dd_ND :: NewOrData
• dd_ctxt :: Maybe (LHsContext pass)

  Context

• dd_cType :: Maybe (XRec pass CType)
• dd_kindSig :: Maybe (LHsKind pass)

  Optional kind signature.

  (Just k) for a GADT-style data, or data instance decl, with explicit kind sig

  Always Nothing for H98-syntax decls

• dd_cons :: [LConDecl pass]

  Data constructors

  For data T a = T1 | T2 a the LConDecls all have ConDeclH98. For data T a where { T1 :: T a } the LConDecls all have ConDeclGADT.

• dd_derivs :: HsDeriving pass

  Optional 'deriving' clause

XHsDataDefn !(XXHsDataDefn pass)

type HsConDeclH98Details pass = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass])

The arguments in a Haskell98-style data constructor.

data HsConDeclGADTDetails pass

The arguments in a GADT constructor. Unlike Haskell98-style constructors, GADT constructors cannot be declared with infix syntax. As a result, we do not use HsConDetails here, as InfixCon would be an unrepresentable state. (There is a notion of infix GADT constructors for the purposes of derived Show instances—see Note [Infix GADT constructors] in GHC.Tc.TyCl—but that is an orthogonal concern.)

Constructors

PrefixConGADT [HsScaled pass (LBangType pass)]

RecConGADT (XRec pass [LConDeclField pass])

data FunDep pass

Constructors

FunDep (XCFunDep pass) [LIdP pass] [LIdP pass]

XFunDep !(XXFunDep pass)

Instances

type Anno (FunDep (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FunDep (GhcPass p)) = SrcSpanAnnA

data ForeignImport

Constructors

CImport (Located CCallConv) (Located Safety) (Maybe Header) CImportSpec (Located SourceText)

Instances

Data ForeignImport

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: ForeignImport -> Constr

dataTypeOf :: ForeignImport -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable ForeignImport

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: ForeignImport -> SDoc

data ForeignExport

Constructors

CExport (Located CExportSpec) (Located SourceText)

Instances

Data ForeignExport

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: ForeignExport -> Constr

dataTypeOf :: ForeignExport -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable ForeignExport

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: ForeignExport -> SDoc

data ForeignDecl pass

Foreign Declaration

Constructors

ForeignImport

Fields

• fd_i_ext :: XForeignImport pass
• fd_name :: LIdP pass
• fd_sig_ty :: LHsSigType pass
• fd_fi :: ForeignImport

ForeignExport

• AnnKeywordId : AnnForeign, AnnImport,AnnExport, AnnDcolon

Fields

• fd_e_ext :: XForeignExport pass
• fd_name :: LIdP pass
• fd_sig_ty :: LHsSigType pass
• fd_fe :: ForeignExport

XForeignDecl !(XXForeignDecl pass)

Instances

type Anno (ForeignDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA

data FamilyResultSig pass

type Family Result Signature

Constructors

NoSig (XNoSig pass)

• AnnKeywordId :

KindSig (XCKindSig pass) (LHsKind pass)

• AnnKeywordId : AnnOpenP,AnnDcolon, AnnCloseP

TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass)

• AnnKeywordId : AnnOpenP,AnnDcolon, AnnCloseP, AnnEqual

XFamilyResultSig !(XXFamilyResultSig pass)

Instances

type Anno (FamilyResultSig (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FamilyResultSig (GhcPass p)) = SrcSpan

data FamilyInfo pass

Constructors

DataFamily

OpenTypeFamily

ClosedTypeFamily (Maybe [LTyFamInstEqn pass])

Nothing if we're in an hs-boot file and the user said "type family Foo x where .."

Instances

Outputable (FamilyInfo pass)

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: FamilyInfo pass -> SDoc

data FamilyDecl pass

type Family Declaration

Constructors

FamilyDecl

Fields

• fdExt :: XCFamilyDecl pass
• fdInfo :: FamilyInfo pass
• fdTopLevel :: TopLevelFlag
• fdLName :: LIdP pass
• fdTyVars :: LHsQTyVars pass
• fdFixity :: LexicalFixity
• fdResultSig :: LFamilyResultSig pass
• fdInjectivityAnn :: Maybe (LInjectivityAnn pass)

XFamilyDecl !(XXFamilyDecl pass)

• AnnKeywordId : AnnType, AnnData, AnnFamily, AnnWhere, AnnOpenP, AnnDcolon, AnnCloseP, AnnEqual, AnnRarrow, AnnVbar

Instances

type Anno (FamilyDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA

data FamEqn pass rhs

Family Equation

One equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]

Constructors

FamEqn

Fields

• feqn_ext :: XCFamEqn pass rhs
• feqn_tycon :: LIdP pass
• feqn_bndrs :: HsOuterFamEqnTyVarBndrs pass

  Optional quantified type vars

• feqn_pats :: HsTyPats pass
• feqn_fixity :: LexicalFixity

  Fixity used in the declaration

• feqn_rhs :: rhs
  • AnnKeywordId : AnnEqual

XFamEqn !(XXFamEqn pass rhs)

Instances

type Anno (FamEqn (GhcPass p) _1)

Defined in GHC.Hs.Decls

type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA

type Anno (FamEqn (GhcPass p) _1)

Defined in GHC.Hs.Decls

type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA

type Anno (FamEqn p (LocatedA (HsType p)))

Defined in GHC.Hs.Decls

type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

data DocDecl

Documentation comment Declaration

Constructors

DocCommentNext HsDocString

DocCommentPrev HsDocString

DocCommentNamed String HsDocString

DocGroup Int HsDocString

Instances

Data DocDecl

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: DocDecl -> Constr

dataTypeOf :: DocDecl -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable DocDecl

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: DocDecl -> SDoc

type Anno DocDecl

Defined in GHC.Hs.Decls

type Anno DocDecl = SrcSpanAnnA

data DerivStrategy pass

Which technique the user explicitly requested when deriving an instance.

Constructors

StockStrategy (XStockStrategy pass)

GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., Eq, Show, Functor when -XDeriveFunctor is enabled, etc.)

AnyclassStrategy (XAnyClassStrategy pass)

-XDeriveAnyClass

NewtypeStrategy (XNewtypeStrategy pass)

-XGeneralizedNewtypeDeriving

ViaStrategy (XViaStrategy pass)

-XDerivingVia

Instances

type Anno (DerivStrategy (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DerivStrategy (GhcPass p)) = SrcSpan

data DerivDecl pass

Stand-alone 'deriving instance' declaration

Constructors

DerivDecl

Fields

• deriv_ext :: XCDerivDecl pass
• deriv_type :: LHsSigWcType pass

  The instance type to derive.

  It uses an LHsSigWcType because the context is allowed to be a single wildcard:

  deriving instance _ => Eq (Foo a)

  Which signifies that the context should be inferred.

• deriv_strategy :: Maybe (LDerivStrategy pass)
• deriv_overlap_mode :: Maybe (XRec pass OverlapMode)
  • AnnKeywordId : AnnDeriving, AnnInstance, AnnStock, AnnAnyClass, AnnNewtype, AnnOpen,AnnClose

XDerivDecl !(XXDerivDecl pass)

Instances

type Anno (DerivDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA

data DerivClauseTys pass

The types mentioned in a single deriving clause. This can come in two forms, DctSingle or DctMulti, depending on whether the types are surrounded by enclosing parentheses or not. These parentheses are semantically different than HsParTy. For example, deriving () means "derive zero classes" rather than "derive an instance of the 0-tuple".

DerivClauseTys use LHsSigType because deriving clauses can mention type variables that aren't bound by the datatype, e.g.

data T b = ... deriving (C [a])

should produce a derived instance for C [a] (T b).

Constructors

DctSingle (XDctSingle pass) (LHsSigType pass)

A deriving clause with a single type. Moreover, that type can only be a type constructor without any arguments.

Example: deriving Eq

DctMulti (XDctMulti pass) [LHsSigType pass]

A deriving clause with a comma-separated list of types, surrounded by enclosing parentheses.

Example: deriving (Eq, C a)

XDerivClauseTys !(XXDerivClauseTys pass)

Instances

type Anno (DerivClauseTys (GhcPass _1))

Defined in GHC.Hs.Decls

type Anno (DerivClauseTys (GhcPass _1)) = SrcSpanAnnC

data DefaultDecl pass

Default Declaration

Constructors

DefaultDecl (XCDefaultDecl pass) [LHsType pass]

• AnnKeywordIds : AnnDefault, AnnOpen,AnnClose

XDefaultDecl !(XXDefaultDecl pass)

Instances

type Anno (DefaultDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA

newtype DataFamInstDecl pass

Data Family Instance Declaration

Constructors

DataFamInstDecl

• AnnKeywordId : AnnData, AnnNewType,AnnInstance, AnnDcolon AnnWhere,AnnOpen, AnnClose

Fields

• dfid_eqn :: FamEqn pass (HsDataDefn pass)

Instances

type Anno (DataFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DataFamInstDecl (GhcPass p)) = SrcSpanAnnA

data DataDeclRn

Constructors

DataDeclRn

Fields

• tcdDataCusk :: Bool

  does this have a CUSK? See Note [CUSKs: complete user-supplied kind signatures]

• tcdFVs :: NameSet

Instances

Data DataDeclRn

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: DataDeclRn -> Constr

dataTypeOf :: DataDeclRn -> DataType

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

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

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

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

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

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

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

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

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

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

data ConDecl pass

data T b = forall a. Eq a => MkT a b
  MkT :: forall b a. Eq a => MkT a b

data T b where
     MkT1 :: Int -> T Int

data T = Int MkT Int
       | MkT2

data T a where
     Int MkT Int :: T Int

• AnnKeywordIds : AnnOpen, AnnDotdot,AnnCLose, AnnEqual,AnnVbar, AnnDarrow,AnnDarrow, AnnForall,AnnDot

data Constructor Declaration

Constructors

ConDeclGADT

Fields

• con_g_ext :: XConDeclGADT pass
• con_names :: [LIdP pass]
• con_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass)

  The outermost type variable binders, be they explicit or implicit. The XRec is used to anchor exact print annotations, AnnForall and AnnDot.

• con_mb_cxt :: Maybe (LHsContext pass)

  User-written context (if any)

• con_g_args :: HsConDeclGADTDetails pass

  Arguments; never infix

• con_res_ty :: LHsType pass

  Result type

• con_doc :: Maybe LHsDocString

  A possible Haddock comment.

ConDeclH98

Fields

• con_ext :: XConDeclH98 pass
• con_name :: LIdP pass
• con_forall :: Bool

  True = explicit user-written forall e.g. data T a = forall b. MkT b (b->a) con_ex_tvs = {b} False => con_ex_tvs is empty

• con_ex_tvs :: [LHsTyVarBndr Specificity pass]

  Existentials only

• con_mb_cxt :: Maybe (LHsContext pass)

  User-written context (if any)

• con_args :: HsConDeclH98Details pass

  Arguments; can be infix

• con_doc :: Maybe LHsDocString

  A possible Haddock comment.

XConDecl !(XXConDecl pass)

Instances

type Anno (ConDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ConDecl (GhcPass p)) = SrcSpanAnnA

data ClsInstDecl pass

Class Instance Declaration

Constructors

ClsInstDecl

Fields

• cid_ext :: XCClsInstDecl pass
• cid_poly_ty :: LHsSigType pass
• cid_binds :: LHsBinds pass
• cid_sigs :: [LSig pass]
• cid_tyfam_insts :: [LTyFamInstDecl pass]
• cid_datafam_insts :: [LDataFamInstDecl pass]
• cid_overlap_mode :: Maybe (XRec pass OverlapMode)
  • AnnKeywordId : AnnOpen, AnnClose,

XClsInstDecl !(XXClsInstDecl pass)

Instances

type Anno (ClsInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ClsInstDecl (GhcPass p)) = SrcSpanAnnA

data CImportSpec

Constructors

CLabel CLabelString

CFunction CCallTarget

CWrapper

Instances

Data CImportSpec

Defined in Language.Haskell.Syntax.Decls

Methods

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

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

toConstr :: CImportSpec -> Constr

dataTypeOf :: CImportSpec -> DataType

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

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

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

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

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

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

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

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

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

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

data AnnProvenance pass

Annotation Provenance

Constructors

ValueAnnProvenance (LIdP pass)

TypeAnnProvenance (LIdP pass)

ModuleAnnProvenance

data AnnDecl pass

Annotation Declaration

Constructors

HsAnnotation (XHsAnnotation pass) SourceText (AnnProvenance pass) (XRec pass (HsExpr pass))

• AnnKeywordId : AnnOpen, AnnType AnnModule AnnClose

XAnnDecl !(XXAnnDecl pass)

Instances

type Anno (AnnDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (AnnDecl (GhcPass p)) = SrcSpanAnnA

tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass]

tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]

tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass]

tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass]

tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass

pprFullRuleName :: Located (SourceText, RuleName) -> SDoc

pprFlavour :: FamilyInfo pass -> SDoc

newOrDataToFlavour :: NewOrData -> TyConFlavour

Convert a NewOrData to a TyConFlavour

isTypeFamilyDecl :: TyClDecl pass -> Bool

type family declaration

isSynDecl :: TyClDecl pass -> Bool

type or type instance declaration

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool

open type family info

isFamilyDecl :: TyClDecl pass -> Bool

type/data family declaration

isDataFamilyDecl :: TyClDecl pass -> Bool

data family declaration

isDataDecl :: TyClDecl pass -> Bool

True = argument is a data/newtype declaration.

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool

closed type family info

isClassDecl :: TyClDecl pass -> Bool

type class

hsGroupInstDecls :: HsGroup id -> [LInstDecl id]

docDeclDoc :: DocDecl -> HsDocString

derivStrategyName :: DerivStrategy a -> SDoc

A short description of a DerivStrategy'.

countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int)

collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass]

annProvenanceName_maybe :: UnXRec p => AnnProvenance p -> Maybe (IdP p)

data TcSpecPrags

Type checker Specialisation Pragmas

TcSpecPrags conveys SPECIALISE pragmas from the type checker to the desugarer

Constructors

IsDefaultMethod

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

SpecPrags [LTcSpecPrag]

Instances

Data TcSpecPrags

Defined in Language.Haskell.Syntax.Binds

Methods

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

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

toConstr :: TcSpecPrags -> Constr

dataTypeOf :: TcSpecPrags -> DataType

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

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

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

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

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

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

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

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

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

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

data TcSpecPrag

Type checker Specification Pragma

Constructors

SpecPrag Id HsWrapper InlinePragma

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

Instances

Data TcSpecPrag

Defined in Language.Haskell.Syntax.Binds

Methods

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

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

toConstr :: TcSpecPrag -> Constr

dataTypeOf :: TcSpecPrag -> DataType

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

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

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

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

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

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

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

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

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

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

data Sig pass

Signatures and pragmas

Constructors

TypeSig (XTypeSig pass) [LIdP pass] (LHsSigWcType pass)

An ordinary type signature

f :: Num a => a -> a

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

• AnnKeywordId : AnnDcolon, AnnComma

PatSynSig (XPatSynSig pass) [LIdP pass] (LHsSigType pass)

A pattern synonym type signature

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

• AnnKeywordId : AnnPattern, AnnDcolon,AnnForall AnnDot,AnnDarrow

ClassOpSig (XClassOpSig pass) Bool [LIdP pass] (LHsSigType pass)

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

• AnnKeywordId : AnnDefault, AnnDcolon

IdSig (XIdSig pass) Id

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

FixSig (XFixSig pass) (FixitySig pass)

An ordinary fixity declaration

    infixl 8 ***

• AnnKeywordId : AnnInfix, AnnVal

InlineSig (XInlineSig pass) (LIdP pass) InlinePragma

An inline pragma

{#- INLINE f #-}

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

SpecSig (XSpecSig pass) (LIdP pass) [LHsSigType pass] InlinePragma

A specialisation pragma

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

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

SpecInstSig (XSpecInstSig pass) SourceText (LHsSigType pass)

A specialisation pragma for instance declarations only

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

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

• AnnKeywordId : AnnOpen, AnnInstance,AnnClose

MinimalSig (XMinimalSig pass) SourceText (LBooleanFormula (LIdP pass))

A minimal complete definition pragma

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

• AnnKeywordId : AnnOpen, AnnVbar,AnnComma, AnnClose

SCCFunSig (XSCCFunSig pass) SourceText (LIdP pass) (Maybe (XRec pass StringLiteral))

A "set cost centre" pragma for declarations

{-# SCC funName #-}

or

{-# SCC funName "cost_centre_name" #-}

CompleteMatchSig (XCompleteMatchSig pass) SourceText (XRec pass [LIdP pass]) (Maybe (LIdP pass))

A complete match pragma

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

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

XSig !(XXSig pass)

Instances

type Anno (Sig (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (Sig (GhcPass p)) = SrcSpanAnnA

data RecordPatSynField pass

Record Pattern Synonym Field

Constructors

RecordPatSynField

Fields

• recordPatSynField :: FieldOcc pass

  Field label visible in rest of the file

• recordPatSynPatVar :: LIdP pass

  Filled in by renamer, the name used internally by the pattern

Instances

Outputable (RecordPatSynField a)

Defined in Language.Haskell.Syntax.Binds

Methods

ppr :: RecordPatSynField a -> SDoc

data PatSynBind idL idR

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

Pattern Synonym binding

Constructors

PSB

Fields

• psb_ext :: XPSB idL idR

  Post renaming, FVs. See Note [Bind free vars]

• psb_id :: LIdP idL

  Name of the pattern synonym

• psb_args :: HsPatSynDetails idR

  Formal parameter names

• psb_def :: LPat idR

  Right-hand side

• psb_dir :: HsPatSynDir idR

  Directionality

XPatSynBind !(XXPatSynBind idL idR)

type LTcSpecPrag = Located TcSpecPrag

Located Type checker Specification Pragmas

type LSig pass = XRec pass (Sig pass)

Located Signature

type LIPBind id = XRec id (IPBind id)

Located Implicit Parameter Binding

May have AnnKeywordId : AnnSemi when in a list

type LHsLocalBindsLR idL idR = XRec idL (HsLocalBindsLR idL idR)

type LHsLocalBinds id = XRec id (HsLocalBinds id)

Located Haskell local bindings

type LHsBindsLR idL idR = Bag (LHsBindLR idL idR)

Located Haskell Bindings with separate Left and Right identifier types

type LHsBinds id = LHsBindsLR id id

Located Haskell Bindings

type LHsBindLR idL idR = XRec idL (HsBindLR idL idR)

Located Haskell Binding with separate Left and Right identifier types

type LHsBind id = LHsBindLR id id

Located Haskell Binding

type LFixitySig pass = XRec pass (FixitySig pass)

Located Fixity Signature

data IPBind id

Implicit parameter bindings.

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

• AnnKeywordId : AnnEqual

Constructors

IPBind (XCIPBind id) (Either (XRec id HsIPName) (IdP id)) (LHsExpr id)

XIPBind !(XXIPBind id)

Instances

type Anno (IPBind (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (IPBind (GhcPass p)) = SrcSpanAnnA

data HsValBindsLR idL idR

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

Constructors

ValBinds (XValBinds idL idR) (LHsBindsLR idL idR) [LSig idR]

Value Bindings In

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

XValBindsLR !(XXValBindsLR idL idR)

Value Bindings Out

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

type HsValBinds id = HsValBindsLR id id

Haskell Value Bindings

data HsPatSynDir id

Haskell Pattern Synonym Direction

Constructors

Unidirectional

ImplicitBidirectional

ExplicitBidirectional (MatchGroup id (LHsExpr id))

type HsPatSynDetails pass = HsConDetails Void (LIdP pass) [RecordPatSynField pass]

Haskell Pattern Synonym Details

data HsLocalBindsLR idL idR

Haskell Local Bindings with separate Left and Right identifier types

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

Constructors

HsValBinds (XHsValBinds idL idR) (HsValBindsLR idL idR)

Haskell Value Bindings

HsIPBinds (XHsIPBinds idL idR) (HsIPBinds idR)

Haskell Implicit Parameter Bindings

EmptyLocalBinds (XEmptyLocalBinds idL idR)

Empty Local Bindings

XHsLocalBindsLR !(XXHsLocalBindsLR idL idR)

type HsLocalBinds id = HsLocalBindsLR id id

Haskell Local Bindings

data HsIPBinds id

Haskell Implicit Parameter Bindings

Constructors

IPBinds (XIPBinds id) [LIPBind id]

XHsIPBinds !(XXHsIPBinds id)

data HsBindLR idL idR

Haskell Binding with separate Left and Right id's

Constructors

FunBind

Function-like Binding

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

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

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

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

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

AnnKeywordIds

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

Fields

• fun_ext :: XFunBind idL idR

  After the renamer (but before the type-checker), this contains the locally-bound free variables of this defn. See Note [Bind free vars]

  After the type-checker, this contains a coercion from the type of the MatchGroup to the type of the Id. Example:

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

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

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

  The payload

• fun_tick :: [CoreTickish]

  Ticks to put on the rhs, if any

PatBind

Pattern Binding

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

Fields

• pat_ext :: XPatBind idL idR

  See Note [Bind free vars]

• pat_lhs :: LPat idL
• pat_rhs :: GRHSs idR (LHsExpr idR)
• pat_ticks :: ([CoreTickish], [[CoreTickish]])

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

VarBind

Variable Binding

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

Fields

• var_ext :: XVarBind idL idR
• var_id :: IdP idL
• var_rhs :: LHsExpr idR

  Located only for consistency

AbsBinds

Abstraction Bindings

Fields

• abs_ext :: XAbsBinds idL idR
• abs_tvs :: [TyVar]
• abs_ev_vars :: [EvVar]

  Includes equality constraints

• abs_exports :: [ABExport idL]

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

• abs_ev_binds :: [TcEvBinds]

  Evidence bindings Why a list? See GHC.Tc.TyCl.Instance Note [Typechecking plan for instance declarations]

• abs_binds :: LHsBinds idL

  Typechecked user bindings

• abs_sig :: Bool

PatSynBind

Patterns Synonym Binding

Fields

• (XPatSynBind idL idR)
• (PatSynBind idL idR)
  • AnnKeywordId : AnnPattern, AnnLarrow,AnnEqual, AnnWhere AnnOpen '{',AnnClose '}'

XHsBindsLR !(XXHsBindsLR idL idR)

Instances

type Anno (HsBindLR (GhcPass idL) (GhcPass idR))

Defined in GHC.Hs.Binds

type Anno (HsBindLR (GhcPass idL) (GhcPass idR)) = SrcSpanAnnA

type HsBind id = HsBindLR id id

Haskell Binding

data FixitySig pass

Fixity Signature

Constructors

FixitySig (XFixitySig pass) [LIdP pass] Fixity

XFixitySig !(XXFixitySig pass)

Instances

type Anno (FixitySig (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (FixitySig (GhcPass p)) = SrcSpanAnnA

data ABExport p

Abstraction Bindings Export

Constructors

ABE

Fields

• abe_ext :: XABE p
• abe_poly :: IdP p

  Any INLINE pragma is attached to this Id

• abe_mono :: IdP p
• abe_wrap :: HsWrapper

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

• abe_prags :: TcSpecPrags

  SPECIALISE pragmas

XABExport !(XXABExport p)

noSpecPrags :: TcSpecPrags

isTypeLSig :: UnXRec p => LSig p -> Bool

isSpecLSig :: UnXRec p => LSig p -> Bool

isSpecInstLSig :: UnXRec p => LSig p -> Bool

isSCCFunSig :: UnXRec p => LSig p -> Bool

isPragLSig :: UnXRec p => LSig p -> Bool

isMinimalLSig :: UnXRec p => LSig p -> Bool

isInlineLSig :: UnXRec p => LSig p -> Bool

isFixityLSig :: UnXRec p => LSig p -> Bool

isDefaultMethod :: TcSpecPrags -> Bool

isCompleteMatchSig :: UnXRec p => LSig p -> Bool

hsSigDoc :: Sig name -> SDoc

hasSpecPrags :: TcSpecPrags -> Bool

type LHsRecUpdField p = XRec p (HsRecUpdField p)

Located Haskell Record Update Field

type LHsRecField' p id arg = XRec p (HsRecField' id arg)

Located Haskell Record Field

type LHsRecField p arg = XRec p (HsRecField p arg)

Located Haskell Record Field

type HsRecUpdField p = HsRecField' (AmbiguousFieldOcc p) (LHsExpr p)

Haskell Record Update Field

data HsRecFields p arg

Haskell Record Fields

HsRecFields is used only for patterns and expressions (not data type declarations)

Constructors

HsRecFields

Fields

• rec_flds :: [LHsRecField p arg]
• rec_dotdot :: Maybe (Located Int)

Instances

(Outputable arg, Outputable (XRec p (HsRecField p arg))) => Outputable (HsRecFields p arg)

Defined in Language.Haskell.Syntax.Pat

Methods

ppr :: HsRecFields p arg -> SDoc

data HsRecField' id arg

Haskell Record Field

• AnnKeywordId : AnnEqual,

For details on above see note [exact print annotations] in GHC.Parser.Annotation

Constructors

HsRecField

Fields

• hsRecFieldAnn :: XHsRecField id
• hsRecFieldLbl :: Located id
• hsRecFieldArg :: arg

  Filled in by renamer when punning

• hsRecPun :: Bool

  Note [Punning]

Instances

Foldable (HsRecField' id)

Defined in Language.Haskell.Syntax.Pat

Methods

fold :: Monoid m => HsRecField' id m -> m

foldMap :: Monoid m => (a -> m) -> HsRecField' id a -> m

foldMap' :: Monoid m => (a -> m) -> HsRecField' id a -> m

foldr :: (a -> b -> b) -> b -> HsRecField' id a -> b

foldr' :: (a -> b -> b) -> b -> HsRecField' id a -> b

foldl :: (b -> a -> b) -> b -> HsRecField' id a -> b

foldl' :: (b -> a -> b) -> b -> HsRecField' id a -> b

foldr1 :: (a -> a -> a) -> HsRecField' id a -> a

foldl1 :: (a -> a -> a) -> HsRecField' id a -> a

toList :: HsRecField' id a -> [a]

null :: HsRecField' id a -> Bool

length :: HsRecField' id a -> Int

elem :: Eq a => a -> HsRecField' id a -> Bool

maximum :: Ord a => HsRecField' id a -> a

minimum :: Ord a => HsRecField' id a -> a

sum :: Num a => HsRecField' id a -> a

product :: Num a => HsRecField' id a -> a

Traversable (HsRecField' id)

Defined in Language.Haskell.Syntax.Pat

Methods

traverse :: Applicative f => (a -> f b) -> HsRecField' id a -> f (HsRecField' id b)

sequenceA :: Applicative f => HsRecField' id (f a) -> f (HsRecField' id a)

mapM :: Monad m => (a -> m b) -> HsRecField' id a -> m (HsRecField' id b)

sequence :: Monad m => HsRecField' id (m a) -> m (HsRecField' id a)

Functor (HsRecField' id)

Defined in Language.Haskell.Syntax.Pat

Methods

fmap :: (a -> b) -> HsRecField' id a -> HsRecField' id b

(<$) :: a -> HsRecField' id b -> HsRecField' id a

(Outputable p, OutputableBndr p, Outputable arg) => Outputable (HsRecField' p arg)

Defined in Language.Haskell.Syntax.Pat

Methods

ppr :: HsRecField' p arg -> SDoc

type Anno (HsRecField (GhcPass p) arg)

Defined in GHC.Hs.Pat

type Anno (HsRecField (GhcPass p) arg) = SrcSpanAnnA

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p)))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p))) = SrcSpanAnnA

type Anno (HsRecField' p arg)

Defined in GHC.Hs.Pat

type Anno (HsRecField' p arg) = SrcSpanAnnA

type HsRecField p arg = HsRecField' (FieldOcc p) arg

Haskell Record Field

type HsConPatDetails p = HsConDetails (HsPatSigType (NoGhcTc p)) (LPat p) (HsRecFields p (LPat p))

Haskell Constructor Pattern Details

type family ConLikeP x

Instances

type ConLikeP GhcPs

Defined in GHC.Hs.Pat

type ConLikeP GhcPs = RdrName

type ConLikeP GhcRn

Defined in GHC.Hs.Pat

type ConLikeP GhcRn = Name

type ConLikeP GhcTc

Defined in GHC.Hs.Pat

type ConLikeP GhcTc = ConLike

hsRecFieldsArgs :: UnXRec p => HsRecFields p arg -> [arg]

hsRecFields :: UnXRec p => HsRecFields p arg -> [XCFieldOcc p]

hsRecFieldSel :: HsRecField pass arg -> Located (XCFieldOcc pass)

hsConPatArgs :: UnXRec p => HsConPatDetails p -> [LPat p]

type LHsWcType pass = HsWildCardBndrs pass (LHsType pass)

Located Haskell Wildcard Type

type LHsTypeArg p = HsArg (LHsType p) (LHsKind p)

type LHsType pass

Arguments

 = XRec pass (HsType pass)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Type

type LHsTyVarBndr flag pass = XRec pass (HsTyVarBndr flag pass)

Located Haskell Type Variable Binder

type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass)

Located Haskell Signature Wildcard Type

type LHsSigType pass = XRec pass (HsSigType pass)

Located Haskell Signature Type

data LHsQTyVars pass

Located Haskell Quantified Type Variables

Constructors

HsQTvs

Fields

• hsq_ext :: XHsQTvs pass
• hsq_explicit :: [LHsTyVarBndr () pass]

XLHsQTyVars !(XXLHsQTyVars pass)

type LHsKind pass

Arguments

 = XRec pass (HsKind pass)

AnnKeywordId : AnnDcolon

Located Haskell Kind

type LHsContext pass

Arguments

 = XRec pass (HsContext pass)

AnnKeywordId : AnnUnit For details on above see note [exact print annotations] in GHC.Parser.Annotation

Located Haskell Context

type LFieldOcc pass = XRec pass (FieldOcc pass)

Located Field Occurrence

type LConDeclField pass

Arguments

 = XRec pass (ConDeclField pass)

May have AnnKeywordId : AnnComma when in a list

Located Constructor Declaration Field

type LBangType pass = XRec pass (BangType pass)

Located Bang Type

data HsWildCardBndrs pass thing

Haskell Wildcard Binders

Constructors

HsWC

Fields

• hswc_ext :: XHsWC pass thing
• hswc_body :: thing

XHsWildCardBndrs !(XXHsWildCardBndrs pass thing)

data HsType pass

Haskell Type

Constructors

HsForAllTy

• AnnKeywordId : AnnForall, AnnDot,AnnDarrow For details on above see note [exact print annotations] in GHC.Parser.Annotation

Fields

• hst_xforall :: XForAllTy pass
• hst_tele :: HsForAllTelescope pass
• hst_body :: LHsType pass

HsQualTy

Fields

• hst_xqual :: XQualTy pass
• hst_ctxt :: Maybe (LHsContext pass)
• hst_body :: LHsType pass

HsTyVar (XTyVar pass) PromotionFlag (LIdP pass)

• AnnKeywordId : None

HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)

• AnnKeywordId : None

HsAppKindTy (XAppKindTy pass) (LHsType pass) (LHsKind pass)

HsFunTy (XFunTy pass) (HsArrow pass) (LHsType pass) (LHsType pass)

• AnnKeywordId : AnnRarrow,

HsListTy (XListTy pass) (LHsType pass)

• AnnKeywordId : AnnOpen '[', AnnClose ']'

HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]

• AnnKeywordId : AnnOpen '(' or '(#', AnnClose ')' or '#)'

HsSumTy (XSumTy pass) [LHsType pass]

• AnnKeywordId : AnnOpen '(#', AnnClose '#)'@

HsOpTy (XOpTy pass) (LHsType pass) (LIdP pass) (LHsType pass)

• AnnKeywordId : None

HsParTy (XParTy pass) (LHsType pass)

• AnnKeywordId : AnnOpen '(', AnnClose ')'

HsIParamTy (XIParamTy pass) (XRec pass HsIPName) (LHsType pass)

(?x :: ty)

• AnnKeywordId : AnnDcolon

HsStarTy (XStarTy pass) Bool

• AnnKeywordId : None

HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)

(ty :: kind)

• AnnKeywordId : AnnOpen '(', AnnDcolon,AnnClose ')'

HsSpliceTy (XSpliceTy pass) (HsSplice pass)

• AnnKeywordId : AnnOpen '$(', AnnClose ')'

HsDocTy (XDocTy pass) (LHsType pass) LHsDocString

• AnnKeywordId : None

HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)

• AnnKeywordId : AnnOpen '{-# UNPACK' or '{-# NOUNPACK', AnnClose '#-}' AnnBang '!'

HsRecTy (XRecTy pass) [LConDeclField pass]

• AnnKeywordId : AnnOpen '{', AnnClose '}'

HsExplicitListTy (XExplicitListTy pass) PromotionFlag [LHsType pass]

• AnnKeywordId : AnnOpen "'[", AnnClose ']'

HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]

• AnnKeywordId : AnnOpen "'(", AnnClose ')'

HsTyLit (XTyLit pass) HsTyLit

• AnnKeywordId : None

HsWildCardTy (XWildCardTy pass)

• AnnKeywordId : None

XHsType !(XXType pass)

Instances

DisambTD (HsType GhcPs)

Defined in GHC.Parser.PostProcess

Methods

mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA (HsType GhcPs))

mkHsAppTyPV :: LocatedA (HsType GhcPs) -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs))

mkHsAppKindTyPV :: LocatedA (HsType GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs))

mkHsOpTyPV :: LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs))

mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA (HsType GhcPs) -> PV (LocatedA (HsType GhcPs))

type Anno (BangType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (BangType (GhcPass p)) = SrcSpanAnnA

type Anno (HsKind (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsKind (GhcPass p)) = SrcSpanAnnA

type Anno (HsType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsType (GhcPass p)) = SrcSpanAnnA

type Anno [LocatedA (HsType (GhcPass p))]

Defined in GHC.Hs.Type

type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC

type Anno (FamEqn p (LocatedA (HsType p)))

Defined in GHC.Hs.Decls

type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

data HsTyVarBndr flag pass

Haskell Type Variable Binder The flag annotates the binder. It is Specificity in places where explicit specificity is allowed (e.g. x :: forall {a} b. ...) or () in other places.

Constructors

UserTyVar (XUserTyVar pass) flag (LIdP pass)

KindedTyVar (XKindedTyVar pass) flag (LIdP pass) (LHsKind pass)

• AnnKeywordId : AnnOpen, AnnDcolon, AnnClose

XTyVarBndr !(XXTyVarBndr pass)

Instances

type Anno (HsTyVarBndr _flag (GhcPass _1))

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag (GhcPass _1)) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcPs)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcPs) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcRn)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcRn) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcTc)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcTc) = SrcSpanAnnA

data HsTyLit

Haskell Type Literal

Constructors

HsNumTy SourceText Integer

HsStrTy SourceText FastString

HsCharTy SourceText Char

Instances

Data HsTyLit

Defined in Language.Haskell.Syntax.Type

Methods

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

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

toConstr :: HsTyLit -> Constr

dataTypeOf :: HsTyLit -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable HsTyLit

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsTyLit -> SDoc

data HsTupleSort

Haskell Tuple Sort

Constructors

HsUnboxedTuple

HsBoxedOrConstraintTuple

Instances

Data HsTupleSort

Defined in Language.Haskell.Syntax.Type

Methods

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

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

toConstr :: HsTupleSort -> Constr

dataTypeOf :: HsTupleSort -> DataType

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

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

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

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

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

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

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

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

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

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

data HsSigType pass

A type signature that obeys the forall-or-nothing rule. In other words, an LHsType that uses an HsOuterSigTyVarBndrs to represent its outermost type variable quantification. See Note [Representing type signatures].

Constructors

HsSig

Fields

• sig_ext :: XHsSig pass
• sig_bndrs :: HsOuterSigTyVarBndrs pass
• sig_body :: LHsType pass

XHsSigType !(XXHsSigType pass)

Instances

type Anno (HsSigType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsSigType (GhcPass p)) = SrcSpanAnnA

data HsScaled pass a

This is used in the syntax. In constructor declaration. It must keep the arrow representation.

Constructors

HsScaled (HsArrow pass) a

Instances

Outputable a => Outputable (HsScaled pass a)

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsScaled pass a -> SDoc

data HsPatSigType pass

Types that can appear in pattern signatures, as well as the signatures for term-level binders in RULES. See Note [Pattern signature binders and scoping].

This is very similar to HsSigWcType, but with slightly different semantics: see Note [HsType binders]. See also Note [The wildcard story for types].

Constructors

HsPS

Fields

• hsps_ext :: XHsPS pass

  After renamer: HsPSRn

• hsps_body :: LHsType pass

  Main payload (the type itself)

XHsPatSigType !(XXHsPatSigType pass)

data HsPSRn

The extension field for HsPatSigType, which is only used in the renamer onwards. See Note [Pattern signature binders and scoping].

Constructors

HsPSRn

Fields

• hsps_nwcs :: [Name]

  Wildcard names

• hsps_imp_tvs :: [Name]

  Implicitly bound variable names

Instances

Data HsPSRn

Defined in Language.Haskell.Syntax.Type

Methods

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

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

toConstr :: HsPSRn -> Constr

dataTypeOf :: HsPSRn -> DataType

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

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

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

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

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

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

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

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

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

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

data HsOuterTyVarBndrs flag pass

The outermost type variables in a type that obeys the forall-or-nothing rule. See Note [forall-or-nothing rule].

Constructors

HsOuterImplicit

Implicit forall, e.g., f :: a -> b -> b

Fields

• hso_ximplicit :: XHsOuterImplicit pass

HsOuterExplicit

Explicit forall, e.g., f :: forall a b. a -> b -> b

Fields

• hso_xexplicit :: XHsOuterExplicit pass flag
• hso_bndrs :: [LHsTyVarBndr flag (NoGhcTc pass)]

XHsOuterTyVarBndrs !(XXHsOuterTyVarBndrs pass)

Instances

type Anno (HsOuterTyVarBndrs _1 (GhcPass _2))

Defined in GHC.Hs.Type

type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) = SrcSpanAnnA

type HsOuterSigTyVarBndrs = HsOuterTyVarBndrs Specificity

Used for signatures, e.g.,

f :: forall a {b}. blah

We use Specificity for the HsOuterTyVarBndrs flag to allow distinguishing between specified and inferred type variables.

type HsOuterFamEqnTyVarBndrs = HsOuterTyVarBndrs ()

Used for type-family instance equations, e.g.,

type instance forall a. F [a] = Tree a

The notion of specificity is irrelevant in type family equations, so we use () for the HsOuterTyVarBndrs flag.

type HsKind pass = HsType pass

Haskell Kind

newtype HsIPName

These names are used early on to store the names of implicit parameters. They completely disappear after type-checking.

Constructors

HsIPName FastString

Instances

Data HsIPName

Defined in Language.Haskell.Syntax.Type

Methods

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

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

toConstr :: HsIPName -> Constr

dataTypeOf :: HsIPName -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable HsIPName

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsIPName -> SDoc

OutputableBndr HsIPName

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> HsIPName -> SDoc

pprPrefixOcc :: HsIPName -> SDoc

pprInfixOcc :: HsIPName -> SDoc

bndrIsJoin_maybe :: HsIPName -> Maybe Int

Eq HsIPName

Defined in Language.Haskell.Syntax.Type

Methods

(==) :: HsIPName -> HsIPName -> Bool

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

type Anno HsIPName

Defined in GHC.Hs.Type

type Anno HsIPName = SrcSpan

data HsForAllTelescope pass

The type variable binders in an HsForAllTy. See also Note [Variable Specificity and Forall Visibility] in GHC.Tc.Gen.HsType.

Constructors

HsForAllVis

A visible forall (e.g., forall a -> {...}). These do not have any notion of specificity, so we use () as a placeholder value.

Fields

• hsf_xvis :: XHsForAllVis pass
• hsf_vis_bndrs :: [LHsTyVarBndr () pass]

HsForAllInvis

An invisible forall (e.g., forall a {b} c. {...}), where each binder has a Specificity.

Fields

• hsf_xinvis :: XHsForAllInvis pass
• hsf_invis_bndrs :: [LHsTyVarBndr Specificity pass]

XHsForAllTelescope !(XXHsForAllTelescope pass)

type HsCoreTy = Type

type HsContext pass = [LHsType pass]

Haskell Context

data HsConDetails tyarg arg rec

Describes the arguments to a data constructor. This is a common representation for several constructor-related concepts, including:

• The arguments in a Haskell98-style constructor declaration (see HsConDeclH98Details in GHC.Hs.Decls).
• The arguments in constructor patterns in case/function definitions (see HsConPatDetails in GHC.Hs.Pat).
• The left-hand side arguments in a pattern synonym binding (see HsPatSynDetails in GHC.Hs.Binds).

One notable exception is the arguments in a GADT constructor, which uses a separate data type entirely (see HsConDeclGADTDetails in GHC.Hs.Decls). This is because GADT constructors cannot be declared with infix syntax, unlike the concepts above (#18844).

Constructors

PrefixCon [tyarg] [arg]

RecCon rec

InfixCon arg arg

Instances

(Data tyarg, Data arg, Data rec) => Data (HsConDetails tyarg arg rec)

Defined in Language.Haskell.Syntax.Type

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDetails tyarg arg rec -> c (HsConDetails tyarg arg rec)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails tyarg arg rec)

toConstr :: HsConDetails tyarg arg rec -> Constr

dataTypeOf :: HsConDetails tyarg arg rec -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDetails tyarg arg rec))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDetails tyarg arg rec))

gmapT :: (forall b. Data b => b -> b) -> HsConDetails tyarg arg rec -> HsConDetails tyarg arg rec

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails tyarg arg rec -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails tyarg arg rec -> r

gmapQ :: (forall d. Data d => d -> u) -> HsConDetails tyarg arg rec -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails tyarg arg rec -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails tyarg arg rec -> m (HsConDetails tyarg arg rec)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails tyarg arg rec -> m (HsConDetails tyarg arg rec)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails tyarg arg rec -> m (HsConDetails tyarg arg rec)

(Outputable tyarg, Outputable arg, Outputable rec) => Outputable (HsConDetails tyarg arg rec)

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsConDetails tyarg arg rec -> SDoc

data HsArrow pass

Denotes the type of arrows in the surface language

Constructors

HsUnrestrictedArrow IsUnicodeSyntax

a -> b or a → b

HsLinearArrow IsUnicodeSyntax (Maybe AddEpAnn)

a %1 -> b or a %1 → b, or a ⊸ b

HsExplicitMult IsUnicodeSyntax (Maybe AddEpAnn) (LHsType pass)

a %m -> b or a %m → b (very much including `a %Many -> b`! This is how the programmer wrote it). It is stored as an HsType so as to preserve the syntax as written in the program.

data HsArg tm ty

Constructors

HsValArg tm

HsTypeArg SrcSpan ty

HsArgPar SrcSpan

Instances

(Outputable tm, Outputable ty) => Outputable (HsArg tm ty)

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsArg tm ty -> SDoc

data FieldOcc pass

Field Occurrence

Represents an *occurrence* of an unambiguous field. This may or may not be a binding occurrence (e.g. this type is used in ConDeclField and RecordPatSynField which bind their fields, but also in HsRecField for record construction and patterns, which do not).

We store both the RdrName the user originally wrote, and after the renamer, the selector function.

Constructors

FieldOcc

Fields

• extFieldOcc :: XCFieldOcc pass
• rdrNameFieldOcc :: LocatedN RdrName

  See Note [Located RdrNames] in GHC.Hs.Expr

XFieldOcc !(XXFieldOcc pass)

Instances

Outputable (FieldOcc pass)

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: FieldOcc pass -> SDoc

OutputableBndr (FieldOcc pass)

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> FieldOcc pass -> SDoc

pprPrefixOcc :: FieldOcc pass -> SDoc

pprInfixOcc :: FieldOcc pass -> SDoc

bndrIsJoin_maybe :: FieldOcc pass -> Maybe Int

(Eq (XCFieldOcc pass), Eq (XXFieldOcc pass)) => Eq (FieldOcc pass)

Defined in Language.Haskell.Syntax.Type

Methods

(==) :: FieldOcc pass -> FieldOcc pass -> Bool

(/=) :: FieldOcc pass -> FieldOcc pass -> Bool

OutputableBndr (GenLocated SrcSpan (FieldOcc pass))

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprPrefixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprInfixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

bndrIsJoin_maybe :: GenLocated SrcSpan (FieldOcc pass) -> Maybe Int

type Anno (FieldOcc (GhcPass p))

Defined in GHC.Hs.Type

type Anno (FieldOcc (GhcPass p)) = SrcSpan

type Anno (HsRecField (GhcPass p) arg)

Defined in GHC.Hs.Pat

type Anno (HsRecField (GhcPass p) arg) = SrcSpanAnnA

data ConDeclField pass

Constructor Declaration Field

Constructors

ConDeclField

Fields

• cd_fld_ext :: XConDeclField pass
• cd_fld_names :: [LFieldOcc pass]

  See Note [ConDeclField passs]

• cd_fld_type :: LBangType pass
• cd_fld_doc :: Maybe LHsDocString
  • AnnKeywordId : AnnDcolon

XConDeclField !(XXConDeclField pass)

Instances

type Anno (ConDeclField (GhcPass p))

Defined in GHC.Hs.Type

type Anno (ConDeclField (GhcPass p)) = SrcSpanAnnA

type Anno [LocatedA (ConDeclField (GhcPass _1))]

Defined in GHC.Hs.Decls

type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type BangType pass = HsType pass

Bang Type

In the parser, strictness and packedness annotations bind more tightly than docstrings. This means that when consuming a BangType (and looking for HsBangTy) we must be ready to peer behind a potential layer of HsDocTy. See #15206 for motivation and getBangType for an example.

data AmbiguousFieldOcc pass

Ambiguous Field Occurrence

Represents an *occurrence* of a field that is potentially ambiguous after the renamer, with the ambiguity resolved by the typechecker. We always store the RdrName that the user originally wrote, and store the selector function after the renamer (for unambiguous occurrences) or the typechecker (for ambiguous occurrences).

See Note [HsRecField and HsRecUpdField] in GHC.Hs.Pat and Note [Disambiguating record fields] in GHC.Tc.Gen.Head. See Note [Located RdrNames] in GHC.Hs.Expr

Constructors

Unambiguous (XUnambiguous pass) (LocatedN RdrName)

Ambiguous (XAmbiguous pass) (LocatedN RdrName)

XAmbiguousFieldOcc !(XXAmbiguousFieldOcc pass)

Instances

type Anno (AmbiguousFieldOcc GhcTc)

Defined in GHC.Hs.Pat

type Anno (AmbiguousFieldOcc GhcTc) = SrcSpanAnnA

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p)))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p))) = SrcSpanAnnA

numVisibleArgs :: [HsArg tm ty] -> Arity

noTypeArgs :: [Void]

An empty list that can be used to indicate that there are no type arguments allowed in cases where HsConDetails is applied to Void.

mapHsOuterImplicit :: (XHsOuterImplicit pass -> XHsOuterImplicit pass) -> HsOuterTyVarBndrs flag pass -> HsOuterTyVarBndrs flag pass

isHsKindedTyVar :: HsTyVarBndr flag pass -> Bool

Does this HsTyVarBndr come with an explicit kind annotation?

hsUnrestricted :: a -> HsScaled pass a

When creating syntax we use the shorthands. It's better for printing, also, the shorthands work trivially at each pass.

hsScaledThing :: HsScaled pass a -> a

hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr () pass]

hsPatSigType :: HsPatSigType pass -> LHsType pass

hsMult :: HsScaled pass a -> HsArrow pass

hsLinear :: a -> HsScaled pass a

When creating syntax we use the shorthands. It's better for printing, also, the shorthands work trivially at each pass.

hsIPNameFS :: HsIPName -> FastString

data Pat p

Pattern

• AnnKeywordId : AnnBang

Constructors

WildPat (XWildPat p)

Wildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> Type

VarPat (XVarPat p) (LIdP p)

Variable Pattern

LazyPat (XLazyPat p) (LPat p)

Lazy Pattern ^ - AnnKeywordId : AnnTilde

AsPat (XAsPat p) (LIdP p) (LPat p)

As pattern ^ - AnnKeywordId : AnnAt

ParPat (XParPat p) (LPat p)

Parenthesised pattern See Note [Parens in HsSyn] in GHC.Hs.Expr ^ - AnnKeywordId : AnnOpen '(', AnnClose ')'

BangPat (XBangPat p) (LPat p)

Bang pattern ^ - AnnKeywordId : AnnBang

ListPat (XListPat p) [LPat p]

Syntactic List

• AnnKeywordId : AnnOpen '[', AnnClose ']'

TuplePat (XTuplePat p) [LPat p] Boxity

Tuple sub-patterns

• AnnKeywordId : AnnOpen '(' or '(#', AnnClose ')' or '#)'

SumPat (XSumPat p) (LPat p) ConTag Arity

Anonymous sum pattern

• AnnKeywordId : AnnOpen '(#', AnnClose '#)'

ConPat

Constructor Pattern

Fields

• pat_con_ext :: XConPat p
• pat_con :: XRec p (ConLikeP p)
• pat_args :: HsConPatDetails p

ViewPat

• AnnKeywordId : AnnRarrow

Fields

• (XViewPat p)
• (LHsExpr p)
• (LPat p)

  View Pattern

SplicePat

• AnnKeywordId : AnnOpen '$(' AnnClose ')'

Fields

• (XSplicePat p)
• (HsSplice p)

  Splice Pattern (Includes quasi-quotes)

LitPat (XLitPat p) (HsLit p)

Literal Pattern Used for *non-overloaded* literal patterns: Int#, Char#, Int, Char, String, etc.

NPat (XNPat p) (XRec p (HsOverLit p)) (Maybe (SyntaxExpr p)) (SyntaxExpr p)

Natural Pattern

• AnnKeywordId : AnnVal +

NPlusKPat (XNPlusKPat p) (LIdP p) (XRec p (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p)

n+k pattern

SigPat

• AnnKeywordId : AnnDcolon

Fields

• (XSigPat p)
• (LPat p)
• (HsPatSigType (NoGhcTc p))

  Pattern with a type signature

XPat !(XXPat p)

Trees that Grow extension point for new constructors

Instances

type Anno (Pat (GhcPass p))

Defined in GHC.Hs.Pat

type Anno (Pat (GhcPass p)) = SrcSpanAnnA

type LPat p = XRec p (Pat p)

data OverLitVal

Overloaded Literal Value

Constructors

HsIntegral !IntegralLit

Integer-looking literals;

HsFractional !FractionalLit

Frac-looking literals

HsIsString !SourceText !FastString

String-looking literals

Instances

Data OverLitVal

Defined in Language.Haskell.Syntax.Lit

Methods

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

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

toConstr :: OverLitVal -> Constr

dataTypeOf :: OverLitVal -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable OverLitVal

Defined in Language.Haskell.Syntax.Lit

Methods

ppr :: OverLitVal -> SDoc

Eq OverLitVal

Defined in Language.Haskell.Syntax.Lit

Methods

(==) :: OverLitVal -> OverLitVal -> Bool

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

Ord OverLitVal

Defined in Language.Haskell.Syntax.Lit

Methods

compare :: OverLitVal -> OverLitVal -> Ordering

(<) :: OverLitVal -> OverLitVal -> Bool

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

(>) :: OverLitVal -> OverLitVal -> Bool

(>=) :: OverLitVal -> OverLitVal -> Bool

max :: OverLitVal -> OverLitVal -> OverLitVal

min :: OverLitVal -> OverLitVal -> OverLitVal

data HsOverLit p

Haskell Overloaded Literal

Constructors

OverLit

Fields

• ol_ext :: XOverLit p
• ol_val :: OverLitVal
• ol_witness :: HsExpr p

XOverLit !(XXOverLit p)

Instances

Eq (XXOverLit p) => Eq (HsOverLit p)

Defined in Language.Haskell.Syntax.Lit

Methods

(==) :: HsOverLit p -> HsOverLit p -> Bool

(/=) :: HsOverLit p -> HsOverLit p -> Bool

Ord (XXOverLit p) => Ord (HsOverLit p)

Defined in Language.Haskell.Syntax.Lit

Methods

compare :: HsOverLit p -> HsOverLit p -> Ordering

(<) :: HsOverLit p -> HsOverLit p -> Bool

(<=) :: HsOverLit p -> HsOverLit p -> Bool

(>) :: HsOverLit p -> HsOverLit p -> Bool

(>=) :: HsOverLit p -> HsOverLit p -> Bool

max :: HsOverLit p -> HsOverLit p -> HsOverLit p

min :: HsOverLit p -> HsOverLit p -> HsOverLit p

type Anno (HsOverLit (GhcPass p))

Defined in GHC.Hs.Pat

type Anno (HsOverLit (GhcPass p)) = SrcSpan

data HsLit x

Haskell Literal

Constructors

HsChar (XHsChar x) Char

Character

HsCharPrim (XHsCharPrim x) Char

Unboxed character

HsString (XHsString x) FastString

String

HsStringPrim (XHsStringPrim x) !ByteString

Packed bytes

HsInt (XHsInt x) IntegralLit

Genuinely an Int; arises from GHC.Tc.Deriv.Generate, and from TRANSLATION

HsIntPrim (XHsIntPrim x) Integer

literal Int#

HsWordPrim (XHsWordPrim x) Integer

literal Word#

HsInt64Prim (XHsInt64Prim x) Integer

literal Int64#

HsWord64Prim (XHsWord64Prim x) Integer

literal Word64#

HsInteger (XHsInteger x) Integer Type

Genuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit)

HsRat (XHsRat x) FractionalLit Type

Genuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit)

HsFloatPrim (XHsFloatPrim x) FractionalLit

Unboxed Float

HsDoublePrim (XHsDoublePrim x) FractionalLit

Unboxed Double

XLit !(XXLit x)

Instances

Eq (HsLit x)

Defined in Language.Haskell.Syntax.Lit

Methods

(==) :: HsLit x -> HsLit x -> Bool

(/=) :: HsLit x -> HsLit x -> Bool

negateOverLitVal :: OverLitVal -> OverLitVal

hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool

hsOverLitNeedsParens p ol returns True if an overloaded literal ol needs to be parenthesized under precedence p.

hsLitNeedsParens :: PprPrec -> HsLit x -> Bool

hsLitNeedsParens p l returns True if a literal l needs to be parenthesized under precedence p.

data Pass

Constructors

Parsed

Renamed

Typechecked

Instances

Data Pass

Defined in GHC.Hs.Extension

Methods

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

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

toConstr :: Pass -> Constr

dataTypeOf :: Pass -> DataType

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

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

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

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

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

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

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

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

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

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

type OutputableBndrId (pass :: Pass) = (OutputableBndr (IdGhcP pass), OutputableBndr (IdGhcP (NoGhcTcPass pass)), Outputable (GenLocated (Anno (IdGhcP pass)) (IdGhcP pass)), Outputable (GenLocated (Anno (IdGhcP (NoGhcTcPass pass))) (IdGhcP (NoGhcTcPass pass))), IsPass pass)

Constraint type to bundle up the requirement for OutputableBndr on both the id and the NoGhcTc of it. See Note [NoGhcTc].

type family NoGhcTcPass (p :: Pass) :: Pass where ...

Equations

NoGhcTcPass 'Typechecked = 'Renamed

NoGhcTcPass other = other

type IsSrcSpanAnn (p :: Pass) a = (Anno (IdGhcP p) ~ SrcSpanAnn' (EpAnn a), IsPass p)

class (NoGhcTcPass (NoGhcTcPass p) ~ NoGhcTcPass p, IsPass (NoGhcTcPass p)) => IsPass (p :: Pass) where

Allows us to check what phase we're in at GHC's runtime. For example, this class allows us to write > f :: forall p. IsPass p => HsExpr (GhcPass p) -> blah > f e = case ghcPass @p of > GhcPs -> ... in this RHS we have HsExpr GhcPs... > GhcRn -> ... in this RHS we have HsExpr GhcRn... > GhcTc -> ... in this RHS we have HsExpr GhcTc... which is very useful, for example, when pretty-printing. See Note [IsPass].

Methods

ghcPass :: GhcPass p

Instances

IsPass 'Parsed

Defined in GHC.Hs.Extension

Methods

ghcPass :: GhcPass 'Parsed

IsPass 'Renamed

Defined in GHC.Hs.Extension

Methods

ghcPass :: GhcPass 'Renamed

IsPass 'Typechecked

Defined in GHC.Hs.Extension

Methods

ghcPass :: GhcPass 'Typechecked

type family IdGhcP (pass :: Pass) where ...

Maps the "normal" id type for a given GHC pass

Equations

IdGhcP 'Parsed = RdrName

IdGhcP 'Renamed = Name

IdGhcP 'Typechecked = Id

type GhcTc = GhcPass 'Typechecked

type GhcRn = GhcPass 'Renamed

type GhcPs = GhcPass 'Parsed

data GhcPass (c :: Pass) where

Used as a data type index for the hsSyn AST; also serves as a singleton type for Pass

Constructors

GhcPs :: GhcPass 'Parsed

GhcRn :: GhcPass 'Renamed

GhcTc :: GhcPass 'Typechecked

Instances

Typeable p => Data (GhcPass p)

Defined in GHC.Hs.Extension

Methods

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

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

toConstr :: GhcPass p -> Constr

dataTypeOf :: GhcPass p -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> GhcPass p -> GhcPass p

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

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

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

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

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

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

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

IsPass p => CollectPass (GhcPass p)

Defined in GHC.Hs.Utils

Methods

collectXXPat :: Proxy (GhcPass p) -> CollectFlag (GhcPass p) -> XXPat (GhcPass p) -> [IdP (GhcPass p)] -> [IdP (GhcPass p)]

DisambECP (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (PatBuilder GhcPs) :: Type -> Type

type InfixOp (PatBuilder GhcPs)

type FunArg (PatBuilder GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (PatBuilder GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (PatBuilder GhcPs))

mkHsProjUpdatePV :: SrcSpan -> Located [Located (HsFieldLabel GhcPs)] -> LocatedA (PatBuilder GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (PatBuilder GhcPs)))

mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (PatBuilder GhcPs))) -> PV (LocatedA (PatBuilder GhcPs))

mkHsLetPV :: SrcSpan -> HsLocalBinds GhcPs -> LocatedA (PatBuilder GhcPs) -> AnnsLet -> PV (LocatedA (PatBuilder GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (PatBuilder GhcPs)) => PV (LocatedA (PatBuilder GhcPs))) -> PV (LocatedA (PatBuilder GhcPs))

mkHsOpAppPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> LocatedN (InfixOp (PatBuilder GhcPs)) -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (PatBuilder GhcPs))] -> EpAnnHsCase -> PV (LocatedA (PatBuilder GhcPs))

mkHsLamCasePV :: SrcSpan -> LocatedL [LMatch GhcPs (LocatedA (PatBuilder GhcPs))] -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

superFunArg :: (DisambECP (FunArg (PatBuilder GhcPs)) => PV (LocatedA (PatBuilder GhcPs))) -> PV (LocatedA (PatBuilder GhcPs))

mkHsAppPV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LocatedA (FunArg (PatBuilder GhcPs)) -> PV (LocatedA (PatBuilder GhcPs))

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (PatBuilder GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (PatBuilder GhcPs) -> Bool -> LocatedA (PatBuilder GhcPs) -> AnnsIf -> PV (LocatedA (PatBuilder GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (PatBuilder GhcPs))] -> AnnList -> PV (LocatedA (PatBuilder GhcPs))

mkHsParPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> AnnParen -> PV (LocatedA (PatBuilder GhcPs))

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (PatBuilder GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (PatBuilder GhcPs))

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

mkHsExplicitListPV :: SrcSpan -> [LocatedA (PatBuilder GhcPs)] -> AnnList -> PV (LocatedA (PatBuilder GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (PatBuilder GhcPs) -> ([Fbind (PatBuilder GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

mkHsNegAppPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (PatBuilder GhcPs)) -> LocatedA (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

mkHsLazyPatPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

mkHsBangPatPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs))

rejectPragmaPV :: LocatedA (PatBuilder GhcPs) -> PV ()

DisambECP (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsCmd GhcPs) :: Type -> Type

type InfixOp (HsCmd GhcPs)

type FunArg (HsCmd GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsCmd GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsCmd GhcPs))

mkHsProjUpdatePV :: SrcSpan -> Located [Located (HsFieldLabel GhcPs)] -> LocatedA (HsCmd GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsCmd GhcPs)))

mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs))

mkHsLetPV :: SrcSpan -> HsLocalBinds GhcPs -> LocatedA (HsCmd GhcPs) -> AnnsLet -> PV (LocatedA (HsCmd GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (HsCmd GhcPs)) => PV (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs))

mkHsOpAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> LocatedN (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsCmd GhcPs))

mkHsLamCasePV :: SrcSpan -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

superFunArg :: (DisambECP (FunArg (HsCmd GhcPs)) => PV (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs))

mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LocatedA (FunArg (HsCmd GhcPs)) -> PV (LocatedA (HsCmd GhcPs))

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (HsCmd GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsCmd GhcPs) -> Bool -> LocatedA (HsCmd GhcPs) -> AnnsIf -> PV (LocatedA (HsCmd GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsCmd GhcPs))] -> AnnList -> PV (LocatedA (HsCmd GhcPs))

mkHsParPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> AnnParen -> PV (LocatedA (HsCmd GhcPs))

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsCmd GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd GhcPs))

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsCmd GhcPs)] -> AnnList -> PV (LocatedA (HsCmd GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsCmd GhcPs) -> ([Fbind (HsCmd GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsNegAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsLazyPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkHsBangPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs))

rejectPragmaPV :: LocatedA (HsCmd GhcPs) -> PV ()

DisambECP (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsExpr GhcPs) :: Type -> Type

type InfixOp (HsExpr GhcPs)

type FunArg (HsExpr GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsExpr GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsExpr GhcPs))

mkHsProjUpdatePV :: SrcSpan -> Located [Located (HsFieldLabel GhcPs)] -> LocatedA (HsExpr GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsExpr GhcPs)))

mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs))

mkHsLetPV :: SrcSpan -> HsLocalBinds GhcPs -> LocatedA (HsExpr GhcPs) -> AnnsLet -> PV (LocatedA (HsExpr GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs))

mkHsOpAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> LocatedN (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsExpr GhcPs))

mkHsLamCasePV :: SrcSpan -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

superFunArg :: (DisambECP (FunArg (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs))

mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LocatedA (FunArg (HsExpr GhcPs)) -> PV (LocatedA (HsExpr GhcPs))

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (HsExpr GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsExpr GhcPs) -> Bool -> LocatedA (HsExpr GhcPs) -> AnnsIf -> PV (LocatedA (HsExpr GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsExpr GhcPs))] -> AnnList -> PV (LocatedA (HsExpr GhcPs))

mkHsParPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> AnnParen -> PV (LocatedA (HsExpr GhcPs))

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsExpr GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr GhcPs))

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsExpr GhcPs)] -> AnnList -> PV (LocatedA (HsExpr GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsExpr GhcPs) -> ([Fbind (HsExpr GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsNegAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsLazyPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsBangPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

rejectPragmaPV :: LocatedA (HsExpr GhcPs) -> PV ()

DisambInfixOp (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

Methods

mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs))

mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs))

mkHsInfixHolePV :: SrcSpan -> (EpAnnComments -> EpAnn EpAnnUnboundVar) -> PV (Located (HsExpr GhcPs))

DisambTD (HsType GhcPs)

Defined in GHC.Parser.PostProcess

Methods

mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA (HsType GhcPs))

mkHsAppTyPV :: LocatedA (HsType GhcPs) -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs))

mkHsAppKindTyPV :: LocatedA (HsType GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs))

mkHsOpTyPV :: LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs))

mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA (HsType GhcPs) -> PV (LocatedA (HsType GhcPs))

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

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc

(OutputableBndrId p, Outputable (Anno (IE (GhcPass p)))) => Outputable (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc

Outputable (PatBuilder GhcPs)

Defined in GHC.Parser.Types

Methods

ppr :: PatBuilder GhcPs -> SDoc

OutputableBndrId a => Outputable (InstInfo (GhcPass a))

Defined in GHC.Tc.Utils.Env

Methods

ppr :: InstInfo (GhcPass a) -> SDoc

MapXRec (GhcPass p)

Defined in GHC.Hs.Extension

Methods

mapXRec :: Anno a ~ Anno b => (a -> b) -> XRec (GhcPass p) a -> XRec (GhcPass p) b

UnXRec (GhcPass p)

Defined in GHC.Hs.Extension

Methods

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

type XAmbiguous GhcPs

Defined in GHC.Hs.Type

type XAmbiguous GhcPs = NoExtField

type XAmbiguous GhcRn

Defined in GHC.Hs.Type

type XAmbiguous GhcRn = NoExtField

type XAmbiguous GhcTc

Defined in GHC.Hs.Type

type XAmbiguous GhcTc = Id

type XAnyClassStrategy GhcPs

Defined in GHC.Hs.Decls

type XAnyClassStrategy GhcPs = EpAnn [AddEpAnn]

type XAnyClassStrategy GhcRn

Defined in GHC.Hs.Decls

type XAnyClassStrategy GhcRn = NoExtField

type XAnyClassStrategy GhcTc

Defined in GHC.Hs.Decls

type XAnyClassStrategy GhcTc = NoExtField

type XAppTypeE GhcPs

Defined in GHC.Hs.Expr

type XAppTypeE GhcPs = SrcSpan

type XAppTypeE GhcRn

Defined in GHC.Hs.Expr

type XAppTypeE GhcRn = NoExtField

type XAppTypeE GhcTc

Defined in GHC.Hs.Expr

type XAppTypeE GhcTc = Type

type XApplicativeArgOne GhcPs

Defined in GHC.Hs.Expr

type XApplicativeArgOne GhcPs = NoExtField

type XApplicativeArgOne GhcRn

Defined in GHC.Hs.Expr

type XApplicativeArgOne GhcRn = FailOperator GhcRn

type XApplicativeArgOne GhcTc

Defined in GHC.Hs.Expr

type XApplicativeArgOne GhcTc = FailOperator GhcTc

type XArithSeq GhcPs

Defined in GHC.Hs.Expr

type XArithSeq GhcPs = EpAnn [AddEpAnn]

type XArithSeq GhcRn

Defined in GHC.Hs.Expr

type XArithSeq GhcRn = NoExtField

type XArithSeq GhcTc

Defined in GHC.Hs.Expr

type XArithSeq GhcTc = PostTcExpr

type XAsPat GhcPs

Defined in GHC.Hs.Pat

type XAsPat GhcPs = EpAnn [AddEpAnn]

type XAsPat GhcRn

Defined in GHC.Hs.Pat

type XAsPat GhcRn = NoExtField

type XAsPat GhcTc

Defined in GHC.Hs.Pat

type XAsPat GhcTc = NoExtField

type XBangPat GhcPs

Defined in GHC.Hs.Pat

type XBangPat GhcPs = EpAnn [AddEpAnn]

type XBangPat GhcRn

Defined in GHC.Hs.Pat

type XBangPat GhcRn = NoExtField

type XBangPat GhcTc

Defined in GHC.Hs.Pat

type XBangPat GhcTc = NoExtField

type XCClsInstDecl GhcPs

Defined in GHC.Hs.Decls

type XCClsInstDecl GhcPs = (EpAnn [AddEpAnn], AnnSortKey)

type XCClsInstDecl GhcRn

Defined in GHC.Hs.Decls

type XCClsInstDecl GhcRn = NoExtField

type XCClsInstDecl GhcTc

Defined in GHC.Hs.Decls

type XCClsInstDecl GhcTc = NoExtField

type XCDefaultDecl GhcPs

Defined in GHC.Hs.Decls

type XCDefaultDecl GhcPs = EpAnn [AddEpAnn]

type XCDefaultDecl GhcRn

Defined in GHC.Hs.Decls

type XCDefaultDecl GhcRn = NoExtField

type XCDefaultDecl GhcTc

Defined in GHC.Hs.Decls

type XCDefaultDecl GhcTc = NoExtField

type XCFieldOcc GhcPs

Defined in GHC.Hs.Type

type XCFieldOcc GhcPs = NoExtField

type XCFieldOcc GhcRn

Defined in GHC.Hs.Type

type XCFieldOcc GhcRn = Name

type XCFieldOcc GhcTc

Defined in GHC.Hs.Type

type XCFieldOcc GhcTc = Id

type XCImportDecl GhcPs

Defined in GHC.Hs.ImpExp

type XCImportDecl GhcPs = EpAnn EpAnnImportDecl

type XCImportDecl GhcRn

Defined in GHC.Hs.ImpExp

type XCImportDecl GhcRn = NoExtField

type XCImportDecl GhcTc

Defined in GHC.Hs.ImpExp

type XCImportDecl GhcTc = NoExtField

type XCRoleAnnotDecl GhcPs

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl GhcPs = EpAnn [AddEpAnn]

type XCRoleAnnotDecl GhcRn

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl GhcRn = NoExtField

type XCRoleAnnotDecl GhcTc

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl GhcTc = NoExtField

type XCRuleDecls GhcPs

Defined in GHC.Hs.Decls

type XCRuleDecls GhcPs = EpAnn [AddEpAnn]

type XCRuleDecls GhcRn

Defined in GHC.Hs.Decls

type XCRuleDecls GhcRn = NoExtField

type XCRuleDecls GhcTc

Defined in GHC.Hs.Decls

type XCRuleDecls GhcTc = NoExtField

type XCase GhcPs

Defined in GHC.Hs.Expr

type XCase GhcPs = EpAnn EpAnnHsCase

type XCase GhcRn

Defined in GHC.Hs.Expr

type XCase GhcRn = NoExtField

type XCase GhcTc

Defined in GHC.Hs.Expr

type XCase GhcTc = NoExtField

type XClassDecl GhcPs

Defined in GHC.Hs.Decls

type XClassDecl GhcPs = (EpAnn [AddEpAnn], AnnSortKey, LayoutInfo)

type XClassDecl GhcRn

Defined in GHC.Hs.Decls

type XClassDecl GhcRn = NameSet

type XClassDecl GhcTc

Defined in GHC.Hs.Decls

type XClassDecl GhcTc = NameSet

type XCmdArrApp GhcPs

Defined in GHC.Hs.Expr

type XCmdArrApp GhcPs = EpAnn AddEpAnn

type XCmdArrApp GhcRn

Defined in GHC.Hs.Expr

type XCmdArrApp GhcRn = NoExtField

type XCmdArrApp GhcTc

Defined in GHC.Hs.Expr

type XCmdArrApp GhcTc = Type

type XCmdArrForm GhcPs

Defined in GHC.Hs.Expr

type XCmdArrForm GhcPs = EpAnn AnnList

type XCmdArrForm GhcRn

Defined in GHC.Hs.Expr

type XCmdArrForm GhcRn = NoExtField

type XCmdArrForm GhcTc

Defined in GHC.Hs.Expr

type XCmdArrForm GhcTc = NoExtField

type XCmdCase GhcPs

Defined in GHC.Hs.Expr

type XCmdCase GhcPs = EpAnn EpAnnHsCase

type XCmdCase GhcRn

Defined in GHC.Hs.Expr

type XCmdCase GhcRn = NoExtField

type XCmdCase GhcTc

Defined in GHC.Hs.Expr

type XCmdCase GhcTc = NoExtField

type XCmdDo GhcPs

Defined in GHC.Hs.Expr

type XCmdDo GhcPs = EpAnn AnnList

type XCmdDo GhcRn

Defined in GHC.Hs.Expr

type XCmdDo GhcRn = NoExtField

type XCmdDo GhcTc

Defined in GHC.Hs.Expr

type XCmdDo GhcTc = Type

type XCmdIf GhcPs

Defined in GHC.Hs.Expr

type XCmdIf GhcPs = EpAnn AnnsIf

type XCmdIf GhcRn

Defined in GHC.Hs.Expr

type XCmdIf GhcRn = NoExtField

type XCmdIf GhcTc

Defined in GHC.Hs.Expr

type XCmdIf GhcTc = NoExtField

type XCmdLet GhcPs

Defined in GHC.Hs.Expr

type XCmdLet GhcPs = EpAnn AnnsLet

type XCmdLet GhcRn

Defined in GHC.Hs.Expr

type XCmdLet GhcRn = NoExtField

type XCmdLet GhcTc

Defined in GHC.Hs.Expr

type XCmdLet GhcTc = NoExtField

type XCmdTop GhcPs

Defined in GHC.Hs.Expr

type XCmdTop GhcPs = NoExtField

type XCmdTop GhcRn

Defined in GHC.Hs.Expr

type XCmdTop GhcRn = CmdSyntaxTable GhcRn

type XCmdTop GhcTc

Defined in GHC.Hs.Expr

type XCmdTop GhcTc = CmdTopTc

type XConPat GhcPs

Defined in GHC.Hs.Pat

type XConPat GhcPs = EpAnn [AddEpAnn]

type XConPat GhcRn

Defined in GHC.Hs.Pat

type XConPat GhcRn = NoExtField

type XConPat GhcTc

Defined in GHC.Hs.Pat

type XConPat GhcTc = ConPatTc

type XDataDecl GhcPs

Defined in GHC.Hs.Decls

type XDataDecl GhcPs = EpAnn [AddEpAnn]

type XDataDecl GhcRn

Defined in GHC.Hs.Decls

type XDataDecl GhcRn = DataDeclRn

type XDataDecl GhcTc

Defined in GHC.Hs.Decls

type XDataDecl GhcTc = DataDeclRn

type XDataFamInstD GhcPs

Defined in GHC.Hs.Decls

type XDataFamInstD GhcPs = EpAnn [AddEpAnn]

type XDataFamInstD GhcRn

Defined in GHC.Hs.Decls

type XDataFamInstD GhcRn = NoExtField

type XDataFamInstD GhcTc

Defined in GHC.Hs.Decls

type XDataFamInstD GhcTc = NoExtField

type XDo GhcPs

Defined in GHC.Hs.Expr

type XDo GhcPs = EpAnn AnnList

type XDo GhcRn

Defined in GHC.Hs.Expr

type XDo GhcRn = NoExtField

type XDo GhcTc

Defined in GHC.Hs.Expr

type XDo GhcTc = Type

type XExplicitList GhcPs

Defined in GHC.Hs.Expr

type XExplicitList GhcPs = EpAnn AnnList

type XExplicitList GhcRn

Defined in GHC.Hs.Expr

type XExplicitList GhcRn = NoExtField

type XExplicitList GhcTc

Defined in GHC.Hs.Expr

type XExplicitList GhcTc = Type

type XExplicitListTy GhcPs

Defined in GHC.Hs.Type

type XExplicitListTy GhcPs = EpAnn [AddEpAnn]

type XExplicitListTy GhcRn

Defined in GHC.Hs.Type

type XExplicitListTy GhcRn = NoExtField

type XExplicitListTy GhcTc

Defined in GHC.Hs.Type

type XExplicitListTy GhcTc = Kind

type XExplicitSum GhcPs

Defined in GHC.Hs.Expr

type XExplicitSum GhcPs = EpAnn AnnExplicitSum

type XExplicitSum GhcRn

Defined in GHC.Hs.Expr

type XExplicitSum GhcRn = NoExtField

type XExplicitSum GhcTc

Defined in GHC.Hs.Expr

type XExplicitSum GhcTc = [Type]

type XExplicitTuple GhcPs

Defined in GHC.Hs.Expr

type XExplicitTuple GhcPs = EpAnn [AddEpAnn]

type XExplicitTuple GhcRn

Defined in GHC.Hs.Expr

type XExplicitTuple GhcRn = NoExtField

type XExplicitTuple GhcTc

Defined in GHC.Hs.Expr

type XExplicitTuple GhcTc = NoExtField

type XExplicitTupleTy GhcPs

Defined in GHC.Hs.Type

type XExplicitTupleTy GhcPs = EpAnn [AddEpAnn]

type XExplicitTupleTy GhcRn

Defined in GHC.Hs.Type

type XExplicitTupleTy GhcRn = NoExtField

type XExplicitTupleTy GhcTc

Defined in GHC.Hs.Type

type XExplicitTupleTy GhcTc = [Kind]

type XExprWithTySig GhcPs

Defined in GHC.Hs.Expr

type XExprWithTySig GhcPs = EpAnn [AddEpAnn]

type XExprWithTySig GhcRn

Defined in GHC.Hs.Expr

type XExprWithTySig GhcRn = NoExtField

type XExprWithTySig GhcTc

Defined in GHC.Hs.Expr

type XExprWithTySig GhcTc = NoExtField

type XForeignExport GhcPs

Defined in GHC.Hs.Decls

type XForeignExport GhcPs = EpAnn [AddEpAnn]

type XForeignExport GhcRn

Defined in GHC.Hs.Decls

type XForeignExport GhcRn = NoExtField

type XForeignExport GhcTc

Defined in GHC.Hs.Decls

type XForeignExport GhcTc = Coercion

type XForeignImport GhcPs

Defined in GHC.Hs.Decls

type XForeignImport GhcPs = EpAnn [AddEpAnn]

type XForeignImport GhcRn

Defined in GHC.Hs.Decls

type XForeignImport GhcRn = NoExtField

type XForeignImport GhcTc

Defined in GHC.Hs.Decls

type XForeignImport GhcTc = Coercion

type XGetField GhcPs

Defined in GHC.Hs.Expr

type XGetField GhcPs = EpAnnCO

type XGetField GhcRn

Defined in GHC.Hs.Expr

type XGetField GhcRn = NoExtField

type XGetField GhcTc

Defined in GHC.Hs.Expr

type XGetField GhcTc = Void

type XHsOuterImplicit GhcPs

Defined in GHC.Hs.Type

type XHsOuterImplicit GhcPs = NoExtField

type XHsOuterImplicit GhcRn

Defined in GHC.Hs.Type

type XHsOuterImplicit GhcRn = [Name]

type XHsOuterImplicit GhcTc

Defined in GHC.Hs.Type

type XHsOuterImplicit GhcTc = [TyVar]

type XHsPS GhcPs

Defined in GHC.Hs.Type

type XHsPS GhcPs = EpAnn EpaLocation

type XHsPS GhcRn

Defined in GHC.Hs.Type

type XHsPS GhcRn = HsPSRn

type XHsPS GhcTc

Defined in GHC.Hs.Type

type XHsPS GhcTc = HsPSRn

type XHsQTvs GhcPs

Defined in GHC.Hs.Type

type XHsQTvs GhcPs = NoExtField

type XHsQTvs GhcRn

Defined in GHC.Hs.Type

type XHsQTvs GhcRn = HsQTvsRn

type XHsQTvs GhcTc

Defined in GHC.Hs.Type

type XHsQTvs GhcTc = HsQTvsRn

type XHsRule GhcPs

Defined in GHC.Hs.Decls

type XHsRule GhcPs = EpAnn HsRuleAnn

type XHsRule GhcRn

Defined in GHC.Hs.Decls

type XHsRule GhcRn = HsRuleRn

type XHsRule GhcTc

Defined in GHC.Hs.Decls

type XHsRule GhcTc = HsRuleRn

type XIEModuleContents GhcPs

Defined in GHC.Hs.ImpExp

type XIEModuleContents GhcPs = EpAnn [AddEpAnn]

type XIEModuleContents GhcRn

Defined in GHC.Hs.ImpExp

type XIEModuleContents GhcRn = NoExtField

type XIEModuleContents GhcTc

Defined in GHC.Hs.ImpExp

type XIEModuleContents GhcTc = NoExtField

type XIEVar GhcPs

Defined in GHC.Hs.ImpExp

type XIEVar GhcPs = NoExtField

type XIEVar GhcRn

Defined in GHC.Hs.ImpExp

type XIEVar GhcRn = NoExtField

type XIEVar GhcTc

Defined in GHC.Hs.ImpExp

type XIEVar GhcTc = NoExtField

type XIPBinds GhcPs

Defined in GHC.Hs.Binds

type XIPBinds GhcPs = NoExtField

type XIPBinds GhcRn

Defined in GHC.Hs.Binds

type XIPBinds GhcRn = NoExtField

type XIPBinds GhcTc

Defined in GHC.Hs.Binds

type XIPBinds GhcTc = TcEvBinds

type XIf GhcPs

Defined in GHC.Hs.Expr

type XIf GhcPs = EpAnn AnnsIf

type XIf GhcRn

Defined in GHC.Hs.Expr

type XIf GhcRn = NoExtField

type XIf GhcTc

Defined in GHC.Hs.Expr

type XIf GhcTc = NoExtField

type XLazyPat GhcPs

Defined in GHC.Hs.Pat

type XLazyPat GhcPs = EpAnn [AddEpAnn]

type XLazyPat GhcRn

Defined in GHC.Hs.Pat

type XLazyPat GhcRn = NoExtField

type XLazyPat GhcTc

Defined in GHC.Hs.Pat

type XLazyPat GhcTc = NoExtField

type XLet GhcPs

Defined in GHC.Hs.Expr

type XLet GhcPs = EpAnn AnnsLet

type XLet GhcRn

Defined in GHC.Hs.Expr

type XLet GhcRn = NoExtField

type XLet GhcTc

Defined in GHC.Hs.Expr

type XLet GhcTc = NoExtField

type XListPat GhcPs

Defined in GHC.Hs.Pat

type XListPat GhcPs = EpAnn AnnList

type XListPat GhcRn

Defined in GHC.Hs.Pat

type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)

type XListPat GhcTc

Defined in GHC.Hs.Pat

type XListPat GhcTc = ListPatTc

type XMissing GhcPs

Defined in GHC.Hs.Expr

type XMissing GhcPs = EpAnn EpaLocation

type XMissing GhcRn

Defined in GHC.Hs.Expr

type XMissing GhcRn = NoExtField

type XMissing GhcTc

Defined in GHC.Hs.Expr

type XMissing GhcTc = Scaled Type

type XMultiIf GhcPs

Defined in GHC.Hs.Expr

type XMultiIf GhcPs = EpAnn [AddEpAnn]

type XMultiIf GhcRn

Defined in GHC.Hs.Expr

type XMultiIf GhcRn = NoExtField

type XMultiIf GhcTc

Defined in GHC.Hs.Expr

type XMultiIf GhcTc = Type

type XNPat GhcPs

Defined in GHC.Hs.Pat

type XNPat GhcPs = EpAnn [AddEpAnn]

type XNPat GhcRn

Defined in GHC.Hs.Pat

type XNPat GhcRn = EpAnn [AddEpAnn]

type XNPat GhcTc

Defined in GHC.Hs.Pat

type XNPat GhcTc = Type

type XNPlusKPat GhcPs

Defined in GHC.Hs.Pat

type XNPlusKPat GhcPs = EpAnn EpaLocation

type XNPlusKPat GhcRn

Defined in GHC.Hs.Pat

type XNPlusKPat GhcRn = NoExtField

type XNPlusKPat GhcTc

Defined in GHC.Hs.Pat

type XNPlusKPat GhcTc = Type

type XNegApp GhcPs

Defined in GHC.Hs.Expr

type XNegApp GhcPs = EpAnn [AddEpAnn]

type XNegApp GhcRn

Defined in GHC.Hs.Expr

type XNegApp GhcRn = NoExtField

type XNegApp GhcTc

Defined in GHC.Hs.Expr

type XNegApp GhcTc = NoExtField

type XNewtypeStrategy GhcPs

Defined in GHC.Hs.Decls

type XNewtypeStrategy GhcPs = EpAnn [AddEpAnn]

type XNewtypeStrategy GhcRn

Defined in GHC.Hs.Decls

type XNewtypeStrategy GhcRn = NoExtField

type XNewtypeStrategy GhcTc

Defined in GHC.Hs.Decls

type XNewtypeStrategy GhcTc = NoExtField

type XOpApp GhcPs

Defined in GHC.Hs.Expr

type XOpApp GhcPs = EpAnn [AddEpAnn]

type XOpApp GhcRn

Defined in GHC.Hs.Expr

type XOpApp GhcRn = Fixity

type XOpApp GhcTc

Defined in GHC.Hs.Expr

type XOpApp GhcTc = Void

type XOverLabel GhcPs

Defined in GHC.Hs.Expr

type XOverLabel GhcPs = EpAnnCO

type XOverLabel GhcRn

Defined in GHC.Hs.Expr

type XOverLabel GhcRn = EpAnnCO

type XOverLabel GhcTc

Defined in GHC.Hs.Expr

type XOverLabel GhcTc = Void

type XOverLit GhcPs

Defined in GHC.Hs.Lit

type XOverLit GhcPs = NoExtField

type XOverLit GhcRn

Defined in GHC.Hs.Lit

type XOverLit GhcRn = Bool

type XOverLit GhcTc

Defined in GHC.Hs.Lit

type XOverLit GhcTc = OverLitTc

type XProjection GhcPs

Defined in GHC.Hs.Expr

type XProjection GhcPs = EpAnn AnnProjection

type XProjection GhcRn

Defined in GHC.Hs.Expr

type XProjection GhcRn = NoExtField

type XProjection GhcTc

Defined in GHC.Hs.Expr

type XProjection GhcTc = Void

type XRecTy GhcPs

Defined in GHC.Hs.Type

type XRecTy GhcPs = EpAnn AnnList

type XRecTy GhcRn

Defined in GHC.Hs.Type

type XRecTy GhcRn = NoExtField

type XRecTy GhcTc

Defined in GHC.Hs.Type

type XRecTy GhcTc = NoExtField

type XRecordCon GhcPs

Defined in GHC.Hs.Expr

type XRecordCon GhcPs = EpAnn [AddEpAnn]

type XRecordCon GhcRn

Defined in GHC.Hs.Expr

type XRecordCon GhcRn = NoExtField

type XRecordCon GhcTc

Defined in GHC.Hs.Expr

type XRecordCon GhcTc = PostTcExpr

type XRecordUpd GhcPs

Defined in GHC.Hs.Expr

type XRecordUpd GhcPs = EpAnn [AddEpAnn]

type XRecordUpd GhcRn

Defined in GHC.Hs.Expr

type XRecordUpd GhcRn = NoExtField

type XRecordUpd GhcTc

Defined in GHC.Hs.Expr

type XRecordUpd GhcTc = RecordUpdTc

type XSectionL GhcPs

Defined in GHC.Hs.Expr

type XSectionL GhcPs = EpAnnCO

type XSectionL GhcRn

Defined in GHC.Hs.Expr

type XSectionL GhcRn = EpAnnCO

type XSectionL GhcTc

Defined in GHC.Hs.Expr

type XSectionL GhcTc = Void

type XSectionR GhcPs

Defined in GHC.Hs.Expr

type XSectionR GhcPs = EpAnnCO

type XSectionR GhcRn

Defined in GHC.Hs.Expr

type XSectionR GhcRn = EpAnnCO

type XSectionR GhcTc

Defined in GHC.Hs.Expr

type XSectionR GhcTc = Void

type XSigPat GhcPs

Defined in GHC.Hs.Pat

type XSigPat GhcPs = EpAnn [AddEpAnn]

type XSigPat GhcRn

Defined in GHC.Hs.Pat

type XSigPat GhcRn = NoExtField

type XSigPat GhcTc

Defined in GHC.Hs.Pat

type XSigPat GhcTc = Type

type XSpliceTy GhcPs

Defined in GHC.Hs.Type

type XSpliceTy GhcPs = NoExtField

type XSpliceTy GhcRn

Defined in GHC.Hs.Type

type XSpliceTy GhcRn = NoExtField

type XSpliceTy GhcTc

Defined in GHC.Hs.Type

type XSpliceTy GhcTc = Kind

type XStandaloneKindSig GhcPs

Defined in GHC.Hs.Decls

type XStandaloneKindSig GhcPs = EpAnn [AddEpAnn]

type XStandaloneKindSig GhcRn

Defined in GHC.Hs.Decls

type XStandaloneKindSig GhcRn = NoExtField

type XStandaloneKindSig GhcTc

Defined in GHC.Hs.Decls

type XStandaloneKindSig GhcTc = NoExtField

type XStatic GhcPs

Defined in GHC.Hs.Expr

type XStatic GhcPs = EpAnn [AddEpAnn]

type XStatic GhcRn

Defined in GHC.Hs.Expr

type XStatic GhcRn = NameSet

type XStatic GhcTc

Defined in GHC.Hs.Expr

type XStatic GhcTc = NameSet

type XStockStrategy GhcPs

Defined in GHC.Hs.Decls

type XStockStrategy GhcPs = EpAnn [AddEpAnn]

type XStockStrategy GhcRn

Defined in GHC.Hs.Decls

type XStockStrategy GhcRn = NoExtField

type XStockStrategy GhcTc

Defined in GHC.Hs.Decls

type XStockStrategy GhcTc = NoExtField

type XSumPat GhcPs

Defined in GHC.Hs.Pat

type XSumPat GhcPs = EpAnn EpAnnSumPat

type XSumPat GhcRn

Defined in GHC.Hs.Pat

type XSumPat GhcRn = NoExtField

type XSumPat GhcTc

Defined in GHC.Hs.Pat

type XSumPat GhcTc = [Type]

type XSynDecl GhcPs

Defined in GHC.Hs.Decls

type XSynDecl GhcPs = EpAnn [AddEpAnn]

type XSynDecl GhcRn

Defined in GHC.Hs.Decls

type XSynDecl GhcRn = NameSet

type XSynDecl GhcTc

Defined in GHC.Hs.Decls

type XSynDecl GhcTc = NameSet

type XTuplePat GhcPs

Defined in GHC.Hs.Pat

type XTuplePat GhcPs = EpAnn [AddEpAnn]

type XTuplePat GhcRn

Defined in GHC.Hs.Pat

type XTuplePat GhcRn = NoExtField

type XTuplePat GhcTc

Defined in GHC.Hs.Pat

type XTuplePat GhcTc = [Type]

type XTyFamInstD GhcPs

Defined in GHC.Hs.Decls

type XTyFamInstD GhcPs = NoExtField

type XTyFamInstD GhcRn

Defined in GHC.Hs.Decls

type XTyFamInstD GhcRn = NoExtField

type XTyFamInstD GhcTc

Defined in GHC.Hs.Decls

type XTyFamInstD GhcTc = NoExtField

type XUnambiguous GhcPs

Defined in GHC.Hs.Type

type XUnambiguous GhcPs = NoExtField

type XUnambiguous GhcRn

Defined in GHC.Hs.Type

type XUnambiguous GhcRn = Name

type XUnambiguous GhcTc

Defined in GHC.Hs.Type

type XUnambiguous GhcTc = Id

type XUnboundVar GhcPs

Defined in GHC.Hs.Expr

type XUnboundVar GhcPs = EpAnn EpAnnUnboundVar

type XUnboundVar GhcRn

Defined in GHC.Hs.Expr

type XUnboundVar GhcRn = NoExtField

type XUnboundVar GhcTc

Defined in GHC.Hs.Expr

type XUnboundVar GhcTc = HoleExprRef

type XViaStrategy GhcPs

Defined in GHC.Hs.Decls

type XViaStrategy GhcPs = XViaStrategyPs

type XViaStrategy GhcRn

Defined in GHC.Hs.Decls

type XViaStrategy GhcRn = LHsSigType GhcRn

type XViaStrategy GhcTc

Defined in GHC.Hs.Decls

type XViaStrategy GhcTc = Type

type XViewPat GhcPs

Defined in GHC.Hs.Pat

type XViewPat GhcPs = EpAnn [AddEpAnn]

type XViewPat GhcRn

Defined in GHC.Hs.Pat

type XViewPat GhcRn = NoExtField

type XViewPat GhcTc

Defined in GHC.Hs.Pat

type XViewPat GhcTc = Type

type XWarnings GhcPs

Defined in GHC.Hs.Decls

type XWarnings GhcPs = EpAnn [AddEpAnn]

type XWarnings GhcRn

Defined in GHC.Hs.Decls

type XWarnings GhcRn = NoExtField

type XWarnings GhcTc

Defined in GHC.Hs.Decls

type XWarnings GhcTc = NoExtField

type XWildPat GhcPs

Defined in GHC.Hs.Pat

type XWildPat GhcPs = NoExtField

type XWildPat GhcRn

Defined in GHC.Hs.Pat

type XWildPat GhcRn = NoExtField

type XWildPat GhcTc

Defined in GHC.Hs.Pat

type XWildPat GhcTc = Type

type XXCmd GhcPs

Defined in GHC.Hs.Expr

type XXCmd GhcPs = NoExtCon

type XXCmd GhcRn

Defined in GHC.Hs.Expr

type XXCmd GhcRn = NoExtCon

type XXCmd GhcTc

Defined in GHC.Hs.Expr

type XXCmd GhcTc = HsWrap HsCmd

type XXExpr GhcPs

Defined in GHC.Hs.Expr

type XXExpr GhcPs = NoExtCon

type XXExpr GhcRn

Defined in GHC.Hs.Expr

type XXExpr GhcRn = HsExpansion (HsExpr GhcRn) (HsExpr GhcRn)

type XXExpr GhcTc

Defined in GHC.Hs.Expr

type XXExpr GhcTc = XXExprGhcTc

type XXPat GhcPs

Defined in GHC.Hs.Pat

type XXPat GhcPs = NoExtCon

type XXPat GhcRn

Defined in GHC.Hs.Pat

type XXPat GhcRn = NoExtCon

type XXPat GhcTc

Defined in GHC.Hs.Pat

type XXPat GhcTc = CoPat

type XXSplice GhcPs

Defined in GHC.Hs.Expr

type XXSplice GhcPs = NoExtCon

type XXSplice GhcRn

Defined in GHC.Hs.Expr

type XXSplice GhcRn = NoExtCon

type XXSplice GhcTc

Defined in GHC.Hs.Expr

type XXSplice GhcTc = HsSplicedT

type ConLikeP GhcPs

Defined in GHC.Hs.Pat

type ConLikeP GhcPs = RdrName

type ConLikeP GhcRn

Defined in GHC.Hs.Pat

type ConLikeP GhcRn = Name

type ConLikeP GhcTc

Defined in GHC.Hs.Pat

type ConLikeP GhcTc = ConLike

type XHsOuterExplicit GhcPs _1

Defined in GHC.Hs.Type

type XHsOuterExplicit GhcPs _1 = EpAnnForallTy

type XHsOuterExplicit GhcRn _1

Defined in GHC.Hs.Type

type XHsOuterExplicit GhcRn _1 = NoExtField

type XHsOuterExplicit GhcTc flag

Defined in GHC.Hs.Type

type XHsOuterExplicit GhcTc flag = [VarBndr TyVar flag]

type XHsWC GhcPs b

Defined in GHC.Hs.Type

type XHsWC GhcPs b = NoExtField

type XHsWC GhcRn b

Defined in GHC.Hs.Type

type XHsWC GhcRn b = [Name]

type XHsWC GhcTc b

Defined in GHC.Hs.Type

type XHsWC GhcTc b = [Name]

type XMG GhcPs b

Defined in GHC.Hs.Expr

type XMG GhcPs b = NoExtField

type XMG GhcRn b

Defined in GHC.Hs.Expr

type XMG GhcRn b = NoExtField

type XMG GhcTc b

Defined in GHC.Hs.Expr

type XMG GhcTc b = MatchGroupTc

type XPatBind GhcPs (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcPs (GhcPass pR) = EpAnn [AddEpAnn]

type XPatBind GhcRn (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcRn (GhcPass pR) = NameSet

type XPatBind GhcTc (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcTc (GhcPass pR) = Type

type Body (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

type Body (PatBuilder GhcPs) = PatBuilder

type Body (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

type Body (HsCmd GhcPs) = HsCmd

type Body (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

type Body (HsExpr GhcPs) = HsExpr

type FunArg (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs

type FunArg (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

type FunArg (HsCmd GhcPs) = HsExpr GhcPs

type FunArg (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

type FunArg (HsExpr GhcPs) = HsExpr GhcPs

type InfixOp (PatBuilder GhcPs)

Defined in GHC.Parser.PostProcess

type InfixOp (PatBuilder GhcPs) = RdrName

type InfixOp (HsCmd GhcPs)

Defined in GHC.Parser.PostProcess

type InfixOp (HsCmd GhcPs) = HsExpr GhcPs

type InfixOp (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

type InfixOp (HsExpr GhcPs) = HsExpr GhcPs

type HsBracketRn (GhcPass _1)

Defined in GHC.Hs.Expr

type HsBracketRn (GhcPass _1) = GhcRn

type HsDoRn (GhcPass _1)

Defined in GHC.Hs.Expr

type HsDoRn (GhcPass _1) = GhcRn

type PendingRnSplice' (GhcPass _1)

Defined in GHC.Hs.Expr

type PendingRnSplice' (GhcPass _1) = PendingRnSplice

type PendingTcSplice' (GhcPass _1)

Defined in GHC.Hs.Expr

type PendingTcSplice' (GhcPass _1) = PendingTcSplice

type SyntaxExpr (GhcPass p)

Defined in GHC.Hs.Expr

type SyntaxExpr (GhcPass p) = SyntaxExprGhc p

type Anno (IE (GhcPass p))

Defined in GHC.Hs.ImpExp

type Anno (IE (GhcPass p)) = SrcSpanAnnA

type Anno (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

type Anno (ImportDecl (GhcPass p)) = SrcSpanAnnA

type Anno (LocatedA (IE (GhcPass p)))

Defined in GHC.Hs.ImpExp

type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA

type Anno (FixitySig (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (FixitySig (GhcPass p)) = SrcSpanAnnA

type Anno (IPBind (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (IPBind (GhcPass p)) = SrcSpanAnnA

type Anno (Sig (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (Sig (GhcPass p)) = SrcSpanAnnA

type Anno (AnnDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (AnnDecl (GhcPass p)) = SrcSpanAnnA

type Anno (ClsInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ClsInstDecl (GhcPass p)) = SrcSpanAnnA

type Anno (ConDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ConDecl (GhcPass p)) = SrcSpanAnnA

type Anno (DataFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DataFamInstDecl (GhcPass p)) = SrcSpanAnnA

type Anno (DefaultDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA

type Anno (DerivClauseTys (GhcPass _1))

Defined in GHC.Hs.Decls

type Anno (DerivClauseTys (GhcPass _1)) = SrcSpanAnnC

type Anno (DerivDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA

type Anno (DerivStrategy (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DerivStrategy (GhcPass p)) = SrcSpan

type Anno (FamilyDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA

type Anno (FamilyResultSig (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FamilyResultSig (GhcPass p)) = SrcSpan

type Anno (ForeignDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA

type Anno (FunDep (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FunDep (GhcPass p)) = SrcSpanAnnA

type Anno (HsDecl (GhcPass _1))

Defined in GHC.Hs.Decls

type Anno (HsDecl (GhcPass _1)) = SrcSpanAnnA

type Anno (HsDerivingClause (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (HsDerivingClause (GhcPass p)) = SrcSpan

type Anno (InjectivityAnn (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (InjectivityAnn (GhcPass p)) = SrcSpan

type Anno (InstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (InstDecl (GhcPass p)) = SrcSpanAnnA

type Anno (RoleAnnotDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RoleAnnotDecl (GhcPass p)) = SrcSpanAnnA

type Anno (RuleBndr (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleBndr (GhcPass p)) = SrcSpan

type Anno (RuleDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleDecl (GhcPass p)) = SrcSpanAnnA

type Anno (RuleDecls (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleDecls (GhcPass p)) = SrcSpanAnnA

type Anno (SpliceDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (SpliceDecl (GhcPass p)) = SrcSpanAnnA

type Anno (StandaloneKindSig (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA

type Anno (TyClDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA

type Anno (TyFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (TyFamInstDecl (GhcPass p)) = SrcSpanAnnA

type Anno (WarnDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (WarnDecl (GhcPass p)) = SrcSpanAnnA

type Anno (WarnDecls (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (WarnDecls (GhcPass p)) = SrcSpanAnnA

type Anno (HsCmd (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsCmd (GhcPass p)) = SrcSpanAnnA

type Anno (HsCmdTop (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsCmdTop (GhcPass p)) = SrcSpan

type Anno (HsExpr (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsExpr (GhcPass p)) = SrcSpanAnnA

type Anno (HsSplice (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsSplice (GhcPass p)) = SrcSpanAnnA

type Anno (HsOverLit (GhcPass p))

Defined in GHC.Hs.Pat

type Anno (HsOverLit (GhcPass p)) = SrcSpan

type Anno (Pat (GhcPass p))

Defined in GHC.Hs.Pat

type Anno (Pat (GhcPass p)) = SrcSpanAnnA

type Anno (AmbiguousFieldOcc GhcTc)

Defined in GHC.Hs.Pat

type Anno (AmbiguousFieldOcc GhcTc) = SrcSpanAnnA

type Anno (BangType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (BangType (GhcPass p)) = SrcSpanAnnA

type Anno (ConDeclField (GhcPass p))

Defined in GHC.Hs.Type

type Anno (ConDeclField (GhcPass p)) = SrcSpanAnnA

type Anno (FieldOcc (GhcPass p))

Defined in GHC.Hs.Type

type Anno (FieldOcc (GhcPass p)) = SrcSpan

type Anno (HsKind (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsKind (GhcPass p)) = SrcSpanAnnA

type Anno (HsSigType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsSigType (GhcPass p)) = SrcSpanAnnA

type Anno (HsType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsType (GhcPass p)) = SrcSpanAnnA

type Anno [LocatedA (IE (GhcPass p))]

Defined in GHC.Hs.ImpExp

type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.PostProcess

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.Types

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (ConDeclField (GhcPass _1))]

Defined in GHC.Hs.Decls

type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type Anno [LocatedA (HsType (GhcPass p))]

Defined in GHC.Hs.Type

type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC

type IdP (GhcPass p)

Defined in GHC.Hs.Extension

type IdP (GhcPass p) = IdGhcP p

type NoGhcTc (GhcPass pass)

Marks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because HsType GhcTc should never occur. See Note [NoGhcTc]

Defined in GHC.Hs.Extension

type NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)

type XABE (GhcPass p)

Defined in GHC.Hs.Binds

type XABE (GhcPass p) = NoExtField

type XAnnD (GhcPass _1)

Defined in GHC.Hs.Decls

type XAnnD (GhcPass _1) = NoExtField

type XApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XApp (GhcPass _1) = EpAnnCO

type XAppKindTy (GhcPass _1)

Defined in GHC.Hs.Type

type XAppKindTy (GhcPass _1) = SrcSpan

type XAppTy (GhcPass _1)

Defined in GHC.Hs.Type

type XAppTy (GhcPass _1) = NoExtField

type XApplicativeArgMany (GhcPass _1)

Defined in GHC.Hs.Expr

type XApplicativeArgMany (GhcPass _1) = NoExtField

type XBangTy (GhcPass _1)

Defined in GHC.Hs.Type

type XBangTy (GhcPass _1) = EpAnn [AddEpAnn]

type XBinTick (GhcPass _1)

Defined in GHC.Hs.Expr

type XBinTick (GhcPass _1) = NoExtField

type XBracket (GhcPass _1)

Defined in GHC.Hs.Expr

type XBracket (GhcPass _1) = EpAnn [AddEpAnn]

type XCDerivDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCDerivDecl (GhcPass _1) = EpAnn [AddEpAnn]

type XCFamilyDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCFamilyDecl (GhcPass _1) = EpAnn [AddEpAnn]

type XCFunDep (GhcPass _1)

Defined in GHC.Hs.Decls

type XCFunDep (GhcPass _1) = EpAnn [AddEpAnn]

type XCHsDataDefn (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsDataDefn (GhcPass _1) = NoExtField

type XCHsDerivingClause (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsDerivingClause (GhcPass _1) = EpAnn [AddEpAnn]

type XCHsFieldLabel (GhcPass _1)

Defined in GHC.Hs.Expr

type XCHsFieldLabel (GhcPass _1) = EpAnn AnnFieldLabel

type XCHsGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsGroup (GhcPass _1) = NoExtField

type XCIPBind (GhcPass p)

Defined in GHC.Hs.Binds

type XCIPBind (GhcPass p) = EpAnn [AddEpAnn]

type XCInjectivityAnn (GhcPass _1)

Defined in GHC.Hs.Decls

type XCInjectivityAnn (GhcPass _1) = EpAnn [AddEpAnn]

type XCKindSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XCKindSig (GhcPass _1) = NoExtField

type XCRuleBndr (GhcPass _1)

Defined in GHC.Hs.Decls

type XCRuleBndr (GhcPass _1) = EpAnn [AddEpAnn]

type XCTyClGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XCTyClGroup (GhcPass _1) = NoExtField

type XCTyFamInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCTyFamInstDecl (GhcPass _1) = EpAnn [AddEpAnn]

type XClassOpSig (GhcPass p)

Defined in GHC.Hs.Binds

type XClassOpSig (GhcPass p) = EpAnn AnnSig

type XClsInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XClsInstD (GhcPass _1) = NoExtField

type XCmdApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdApp (GhcPass _1) = EpAnnCO

type XCmdLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdLam (GhcPass _1) = NoExtField

type XCmdLamCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdLamCase (GhcPass _1) = EpAnn [AddEpAnn]

type XCmdPar (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdPar (GhcPass _1) = EpAnn AnnParen

type XCmdWrap (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdWrap (GhcPass _1) = NoExtField

type XCompleteMatchSig (GhcPass p)

Defined in GHC.Hs.Binds

type XCompleteMatchSig (GhcPass p) = EpAnn [AddEpAnn]

type XConDeclField (GhcPass _1)

Defined in GHC.Hs.Type

type XConDeclField (GhcPass _1) = EpAnn [AddEpAnn]

type XConDeclGADT (GhcPass _1)

Defined in GHC.Hs.Decls

type XConDeclGADT (GhcPass _1) = EpAnn [AddEpAnn]

type XConDeclH98 (GhcPass _1)

Defined in GHC.Hs.Decls

type XConDeclH98 (GhcPass _1) = EpAnn [AddEpAnn]

type XConLikeOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XConLikeOut (GhcPass _1) = NoExtField

type XConLikeOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XConLikeOut (GhcPass _1) = NoExtField

type XDctMulti (GhcPass _1)

Defined in GHC.Hs.Decls

type XDctMulti (GhcPass _1) = NoExtField

type XDctSingle (GhcPass _1)

Defined in GHC.Hs.Decls

type XDctSingle (GhcPass _1) = NoExtField

type XDecBrG (GhcPass _1)

Defined in GHC.Hs.Expr

type XDecBrG (GhcPass _1) = NoExtField

type XDecBrL (GhcPass _1)

Defined in GHC.Hs.Expr

type XDecBrL (GhcPass _1) = NoExtField

type XDefD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDefD (GhcPass _1) = NoExtField

type XDerivD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDerivD (GhcPass _1) = NoExtField

type XDocD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDocD (GhcPass _1) = NoExtField

type XDocTy (GhcPass _1)

Defined in GHC.Hs.Type

type XDocTy (GhcPass _1) = EpAnn [AddEpAnn]

type XExpBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XExpBr (GhcPass _1) = NoExtField

type XFamDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XFamDecl (GhcPass _1) = NoExtField

type XFixSig (GhcPass p)

Defined in GHC.Hs.Binds

type XFixSig (GhcPass p) = EpAnn [AddEpAnn]

type XFixitySig (GhcPass p)

Defined in GHC.Hs.Binds

type XFixitySig (GhcPass p) = NoExtField

type XForAllTy (GhcPass _1)

Defined in GHC.Hs.Type

type XForAllTy (GhcPass _1) = NoExtField

type XForD (GhcPass _1)

Defined in GHC.Hs.Decls

type XForD (GhcPass _1) = NoExtField

type XFunTy (GhcPass _1)

Defined in GHC.Hs.Type

type XFunTy (GhcPass _1) = EpAnn TrailingAnn

type XHsAnnotation (GhcPass _1)

Defined in GHC.Hs.Decls

type XHsAnnotation (GhcPass _1) = EpAnn AnnPragma

type XHsChar (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsChar (GhcPass _1) = SourceText

type XHsCharPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsCharPrim (GhcPass _1) = SourceText

type XHsDoublePrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsDoublePrim (GhcPass _1) = NoExtField

type XHsFloatPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsFloatPrim (GhcPass _1) = NoExtField

type XHsForAllInvis (GhcPass _1)

Defined in GHC.Hs.Type

type XHsForAllInvis (GhcPass _1) = EpAnnForallTy

type XHsForAllVis (GhcPass _1)

Defined in GHC.Hs.Type

type XHsForAllVis (GhcPass _1) = EpAnnForallTy

type XHsInt (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInt (GhcPass _1) = NoExtField

type XHsInt64Prim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInt64Prim (GhcPass _1) = SourceText

type XHsIntPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsIntPrim (GhcPass _1) = SourceText

type XHsInteger (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInteger (GhcPass _1) = SourceText

type XHsRat (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsRat (GhcPass _1) = NoExtField

type XHsSig (GhcPass _1)

Defined in GHC.Hs.Type

type XHsSig (GhcPass _1) = NoExtField

type XHsString (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsString (GhcPass _1) = SourceText

type XHsStringPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsStringPrim (GhcPass _1) = SourceText

type XHsWord64Prim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsWord64Prim (GhcPass _1) = SourceText

type XHsWordPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsWordPrim (GhcPass _1) = SourceText

type XIEDoc (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEDoc (GhcPass _1) = NoExtField

type XIEDocNamed (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEDocNamed (GhcPass _1) = NoExtField

type XIEGroup (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEGroup (GhcPass _1) = NoExtField

type XIEThingAbs (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingAbs (GhcPass _1) = EpAnn [AddEpAnn]

type XIEThingAll (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingAll (GhcPass _1) = EpAnn [AddEpAnn]

type XIEThingWith (GhcPass 'Parsed)

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass 'Parsed) = EpAnn [AddEpAnn]

type XIEThingWith (GhcPass 'Renamed)

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass 'Renamed) = [Located FieldLabel]

type XIEThingWith (GhcPass 'Typechecked)

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass 'Typechecked) = NoExtField

type XIPVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XIPVar (GhcPass _1) = EpAnnCO

type XIParamTy (GhcPass _1)

Defined in GHC.Hs.Type

type XIParamTy (GhcPass _1) = EpAnn [AddEpAnn]

type XIdSig (GhcPass p)

Defined in GHC.Hs.Binds

type XIdSig (GhcPass p) = NoExtField

type XInlineSig (GhcPass p)

Defined in GHC.Hs.Binds

type XInlineSig (GhcPass p) = EpAnn [AddEpAnn]

type XInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XInstD (GhcPass _1) = NoExtField

type XKindSig (GhcPass _1)

Defined in GHC.Hs.Type

type XKindSig (GhcPass _1) = EpAnn [AddEpAnn]

type XKindSigD (GhcPass _1)

Defined in GHC.Hs.Decls

type XKindSigD (GhcPass _1) = NoExtField

type XKindedTyVar (GhcPass _1)

Defined in GHC.Hs.Type

type XKindedTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type XLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XLam (GhcPass _1) = NoExtField

type XLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XLam (GhcPass _1) = NoExtField

type XLamCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XLamCase (GhcPass _1) = EpAnn [AddEpAnn]

type XListTy (GhcPass _1)

Defined in GHC.Hs.Type

type XListTy (GhcPass _1) = EpAnn AnnParen

type XLitE (GhcPass _1)

Defined in GHC.Hs.Expr

type XLitE (GhcPass _1) = EpAnnCO

type XLitPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XLitPat (GhcPass _1) = NoExtField

type XMinimalSig (GhcPass p)

Defined in GHC.Hs.Binds

type XMinimalSig (GhcPass p) = EpAnn [AddEpAnn]

type XNoSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XNoSig (GhcPass _1) = NoExtField

type XOpTy (GhcPass _1)

Defined in GHC.Hs.Type

type XOpTy (GhcPass _1) = NoExtField

type XOverLitE (GhcPass _1)

Defined in GHC.Hs.Expr

type XOverLitE (GhcPass _1) = EpAnnCO

type XPar (GhcPass _1)

Defined in GHC.Hs.Expr

type XPar (GhcPass _1) = EpAnn AnnParen

type XParPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XParPat (GhcPass _1) = EpAnn AnnParen

type XParTy (GhcPass _1)

Defined in GHC.Hs.Type

type XParTy (GhcPass _1) = EpAnn AnnParen

type XPatBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XPatBr (GhcPass _1) = NoExtField

type XPatSynSig (GhcPass p)

Defined in GHC.Hs.Binds

type XPatSynSig (GhcPass p) = EpAnn AnnSig

type XPragE (GhcPass _1)

Defined in GHC.Hs.Expr

type XPragE (GhcPass _1) = NoExtField

type XPresent (GhcPass _1)

Defined in GHC.Hs.Expr

type XPresent (GhcPass _1) = EpAnn [AddEpAnn]

type XProc (GhcPass _1)

Defined in GHC.Hs.Expr

type XProc (GhcPass _1) = EpAnn [AddEpAnn]

type XQualTy (GhcPass _1)

Defined in GHC.Hs.Type

type XQualTy (GhcPass _1) = NoExtField

type XQuasiQuote (GhcPass _1)

Defined in GHC.Hs.Expr

type XQuasiQuote (GhcPass _1) = NoExtField

type XRecFld (GhcPass _1)

Defined in GHC.Hs.Expr

type XRecFld (GhcPass _1) = NoExtField

type XRecFld (GhcPass _1)

Defined in GHC.Hs.Expr

type XRecFld (GhcPass _1) = NoExtField

type XRnBracketOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XRnBracketOut (GhcPass _1) = NoExtField

type XRoleAnnotD (GhcPass _1)

Defined in GHC.Hs.Decls

type XRoleAnnotD (GhcPass _1) = NoExtField

type XRuleBndrSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XRuleBndrSig (GhcPass _1) = EpAnn [AddEpAnn]

type XRuleD (GhcPass _1)

Defined in GHC.Hs.Decls

type XRuleD (GhcPass _1) = NoExtField

type XSCC (GhcPass _1)

Defined in GHC.Hs.Expr

type XSCC (GhcPass _1) = EpAnn AnnPragma

type XSCCFunSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSCCFunSig (GhcPass p) = EpAnn [AddEpAnn]

type XSigD (GhcPass _1)

Defined in GHC.Hs.Decls

type XSigD (GhcPass _1) = NoExtField

type XSpecInstSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSpecInstSig (GhcPass p) = EpAnn [AddEpAnn]

type XSpecSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSpecSig (GhcPass p) = EpAnn [AddEpAnn]

type XSpliceD (GhcPass _1)

Defined in GHC.Hs.Decls

type XSpliceD (GhcPass _1) = NoExtField

type XSpliceDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XSpliceDecl (GhcPass _1) = NoExtField

type XSpliceE (GhcPass _1)

Defined in GHC.Hs.Expr

type XSpliceE (GhcPass _1) = EpAnnCO

type XSplicePat (GhcPass _1)

Defined in GHC.Hs.Pat

type XSplicePat (GhcPass _1) = NoExtField

type XSpliced (GhcPass _1)

Defined in GHC.Hs.Expr

type XSpliced (GhcPass _1) = NoExtField

type XStarTy (GhcPass _1)

Defined in GHC.Hs.Type

type XStarTy (GhcPass _1) = NoExtField

type XSumTy (GhcPass _1)

Defined in GHC.Hs.Type

type XSumTy (GhcPass _1) = EpAnn AnnParen

type XTExpBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XTExpBr (GhcPass _1) = NoExtField

type XTcBracketOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XTcBracketOut (GhcPass _1) = NoExtField

type XTick (GhcPass _1)

Defined in GHC.Hs.Expr

type XTick (GhcPass _1) = NoExtField

type XTupleTy (GhcPass _1)

Defined in GHC.Hs.Type

type XTupleTy (GhcPass _1) = EpAnn AnnParen

type XTyClD (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyClD (GhcPass _1) = NoExtField

type XTyLit (GhcPass _1)

Defined in GHC.Hs.Type

type XTyLit (GhcPass _1) = NoExtField

type XTyVar (GhcPass _1)

Defined in GHC.Hs.Type

type XTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type XTyVarSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyVarSig (GhcPass _1) = NoExtField

type XTypBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XTypBr (GhcPass _1) = NoExtField

type XTypeSig (GhcPass p)

Defined in GHC.Hs.Binds

type XTypeSig (GhcPass p) = EpAnn AnnSig

type XTypedSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XTypedSplice (GhcPass _1) = EpAnn [AddEpAnn]

type XUntypedSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XUntypedSplice (GhcPass _1) = EpAnn [AddEpAnn]

type XUserTyVar (GhcPass _1)

Defined in GHC.Hs.Type

type XUserTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type XValD (GhcPass _1)

Defined in GHC.Hs.Decls

type XValD (GhcPass _1) = NoExtField

type XVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XVar (GhcPass _1) = NoExtField

type XVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XVar (GhcPass _1) = NoExtField

type XVarBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XVarBr (GhcPass _1) = NoExtField

type XVarPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XVarPat (GhcPass _1) = NoExtField

type XWarning (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarning (GhcPass _1) = EpAnn [AddEpAnn]

type XWarningD (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarningD (GhcPass _1) = NoExtField

type XWildCardTy (GhcPass _1)

Defined in GHC.Hs.Type

type XWildCardTy (GhcPass _1) = NoExtField

type XXABExport (GhcPass p)

Defined in GHC.Hs.Binds

type XXABExport (GhcPass p) = NoExtCon

type XXAmbiguousFieldOcc (GhcPass _1)

Defined in GHC.Hs.Type

type XXAmbiguousFieldOcc (GhcPass _1) = NoExtCon

type XXAnnDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXAnnDecl (GhcPass _1) = NoExtCon

type XXApplicativeArg (GhcPass _1)

Defined in GHC.Hs.Expr

type XXApplicativeArg (GhcPass _1) = NoExtCon

type XXBracket (GhcPass _1)

Defined in GHC.Hs.Expr

type XXBracket (GhcPass _1) = NoExtCon

type XXClsInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXClsInstDecl (GhcPass _1) = NoExtCon

type XXCmdTop (GhcPass _1)

Defined in GHC.Hs.Expr

type XXCmdTop (GhcPass _1) = NoExtCon

type XXConDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXConDecl (GhcPass _1) = NoExtCon

type XXConDeclField (GhcPass _1)

Defined in GHC.Hs.Type

type XXConDeclField (GhcPass _1) = NoExtCon

type XXDefaultDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDefaultDecl (GhcPass _1) = NoExtCon

type XXDerivClauseTys (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDerivClauseTys (GhcPass _1) = NoExtCon

type XXDerivDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDerivDecl (GhcPass _1) = NoExtCon

type XXFamilyDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFamilyDecl (GhcPass _1) = NoExtCon

type XXFamilyResultSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFamilyResultSig (GhcPass _1) = NoExtCon

type XXFieldOcc (GhcPass _1)

Defined in GHC.Hs.Type

type XXFieldOcc (GhcPass _1) = NoExtCon

type XXFixitySig (GhcPass p)

Defined in GHC.Hs.Binds

type XXFixitySig (GhcPass p) = NoExtCon

type XXForeignDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXForeignDecl (GhcPass _1) = NoExtCon

type XXFunDep (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFunDep (GhcPass _1) = NoExtCon

type XXHsDataDefn (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDataDefn (GhcPass _1) = NoExtCon

type XXHsDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDecl (GhcPass _1) = NoExtCon

type XXHsDerivingClause (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDerivingClause (GhcPass _1) = NoExtCon

type XXHsFieldLabel (GhcPass _1)

Defined in GHC.Hs.Expr

type XXHsFieldLabel (GhcPass _1) = NoExtCon

type XXHsForAllTelescope (GhcPass _1)

Defined in GHC.Hs.Type

type XXHsForAllTelescope (GhcPass _1) = NoExtCon

type XXHsGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsGroup (GhcPass _1) = NoExtCon

type XXHsIPBinds (GhcPass p)

Defined in GHC.Hs.Binds

type XXHsIPBinds (GhcPass p) = NoExtCon

type XXHsOuterTyVarBndrs (GhcPass _1)

Defined in GHC.Hs.Type

type XXHsOuterTyVarBndrs (GhcPass _1) = NoExtCon

type XXHsPatSigType (GhcPass _1)

Defined in GHC.Hs.Type

type XXHsPatSigType (GhcPass _1) = NoExtCon

type XXHsSigType (GhcPass _1)

Defined in GHC.Hs.Type

type XXHsSigType (GhcPass _1) = NoExtCon

type XXIE (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XXIE (GhcPass _1) = NoExtCon

type XXIPBind (GhcPass p)

Defined in GHC.Hs.Binds

type XXIPBind (GhcPass p) = NoExtCon

type XXImportDecl (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XXImportDecl (GhcPass _1) = NoExtCon

type XXInjectivityAnn (GhcPass _1)

Defined in GHC.Hs.Decls

type XXInjectivityAnn (GhcPass _1) = NoExtCon

type XXInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXInstDecl (GhcPass _1) = NoExtCon

type XXLHsQTyVars (GhcPass _1)

Defined in GHC.Hs.Type

type XXLHsQTyVars (GhcPass _1) = NoExtCon

type XXLit (GhcPass _1)

Defined in GHC.Hs.Lit

type XXLit (GhcPass _1) = NoExtCon

type XXOverLit (GhcPass _1)

Defined in GHC.Hs.Lit

type XXOverLit (GhcPass _1) = NoExtCon

type XXPragE (GhcPass _1)

Defined in GHC.Hs.Expr

type XXPragE (GhcPass _1) = NoExtCon

type XXRoleAnnotDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRoleAnnotDecl (GhcPass _1) = NoExtCon

type XXRuleBndr (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleBndr (GhcPass _1) = NoExtCon

type XXRuleDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleDecl (GhcPass _1) = NoExtCon

type XXRuleDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleDecls (GhcPass _1) = NoExtCon

type XXSig (GhcPass p)

Defined in GHC.Hs.Binds

type XXSig (GhcPass p) = NoExtCon

type XXSpliceDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXSpliceDecl (GhcPass _1) = NoExtCon

type XXStandaloneKindSig (GhcPass p)

Defined in GHC.Hs.Decls

type XXStandaloneKindSig (GhcPass p) = NoExtCon

type XXTupArg (GhcPass _1)

Defined in GHC.Hs.Expr

type XXTupArg (GhcPass _1) = NoExtCon

type XXTyClDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyClDecl (GhcPass _1) = NoExtCon

type XXTyClGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyClGroup (GhcPass _1) = NoExtCon

type XXTyFamInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyFamInstDecl (GhcPass _1) = NoExtCon

type XXTyVarBndr (GhcPass _1)

Defined in GHC.Hs.Type

type XXTyVarBndr (GhcPass _1) = NoExtCon

type XXType (GhcPass _1)

Defined in GHC.Hs.Type

type XXType (GhcPass _1) = HsCoreTy

type XXWarnDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXWarnDecl (GhcPass _1) = NoExtCon

type XXWarnDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XXWarnDecls (GhcPass _1) = NoExtCon

type XCFamEqn (GhcPass _1) r

Defined in GHC.Hs.Decls

type XCFamEqn (GhcPass _1) r = EpAnn [AddEpAnn]

type XCGRHS (GhcPass _1) _2

Defined in GHC.Hs.Expr

type XCGRHS (GhcPass _1) _2 = EpAnn GrhsAnn

type XCGRHSs (GhcPass _1) _2

Defined in GHC.Hs.Expr

type XCGRHSs (GhcPass _1) _2 = EpAnnComments

type XCMatch (GhcPass _1) b

Defined in GHC.Hs.Expr

type XCMatch (GhcPass _1) b = EpAnn [AddEpAnn]

type XFunBind (GhcPass pL) GhcPs

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcPs = NoExtField

type XFunBind (GhcPass pL) GhcRn

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcRn = NameSet

type XFunBind (GhcPass pL) GhcTc

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcTc = HsWrapper

type XPSB (GhcPass idL) GhcPs

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcPs = EpAnn [AddEpAnn]

type XPSB (GhcPass idL) GhcRn

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcRn = NameSet

type XPSB (GhcPass idL) GhcTc

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcTc = NameSet

type XRec (GhcPass p) a

Defined in GHC.Hs.Extension

type XRec (GhcPass p) a = GenLocated (Anno a) a

type XXFamEqn (GhcPass _1) r

Defined in GHC.Hs.Decls

type XXFamEqn (GhcPass _1) r = NoExtCon

type XXGRHS (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXGRHS (GhcPass _1) b = NoExtCon

type XXGRHSs (GhcPass _1) _2

Defined in GHC.Hs.Expr

type XXGRHSs (GhcPass _1) _2 = NoExtCon

type XXHsWildCardBndrs (GhcPass _1) _2

Defined in GHC.Hs.Type

type XXHsWildCardBndrs (GhcPass _1) _2 = NoExtCon

type XXMatch (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXMatch (GhcPass _1) b = NoExtCon

type XXMatchGroup (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXMatchGroup (GhcPass _1) b = NoExtCon

type XApplicativeStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField

type XApplicativeStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField

type XApplicativeStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcTc b = Type

type XBindStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcPs b = EpAnn [AddEpAnn]

type XBindStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcRn b = XBindStmtRn

type XBindStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcTc b = XBindStmtTc

type XBodyStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcPs b = NoExtField

type XBodyStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcRn b = NoExtField

type XBodyStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcTc b = Type

type XParStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcPs b = NoExtField

type XParStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcRn b = NoExtField

type XParStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcTc b = Type

type XRecStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcPs b = EpAnn AnnList

type XRecStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcRn b = NoExtField

type XRecStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc

type XTransStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcPs b = EpAnn [AddEpAnn]

type XTransStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcRn b = NoExtField

type XTransStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcTc b = Type

type XAbsBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField

type XHsIPBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XHsIPBinds (GhcPass pL) (GhcPass pR) = EpAnn AnnList

type XHsValBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XHsValBinds (GhcPass pL) (GhcPass pR) = EpAnn AnnList

type XParStmtBlock (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Expr

type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField

type XPatSynBind (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField

type XValBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XValBinds (GhcPass pL) (GhcPass pR) = AnnSortKey

type XVarBind (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField

type XXHsBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type XXParStmtBlock (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Expr

type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon

type XXPatSynBind (GhcPass idL) (GhcPass idR)

Defined in GHC.Hs.Binds

type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExtCon

type XXValBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)

type XLastStmt (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type XLetStmt (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XLetStmt (GhcPass _1) (GhcPass _2) b = EpAnn [AddEpAnn]

type XXStmtLR (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExtCon

type Anno (HsBindLR (GhcPass idL) (GhcPass idR))

Defined in GHC.Hs.Binds

type Anno (HsBindLR (GhcPass idL) (GhcPass idR)) = SrcSpanAnnA

type Anno (FamEqn (GhcPass p) _1)

Defined in GHC.Hs.Decls

type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA

type Anno (FamEqn (GhcPass p) _1)

Defined in GHC.Hs.Decls

type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpan

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpan

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpan

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (HsRecField (GhcPass p) arg)

Defined in GHC.Hs.Pat

type Anno (HsRecField (GhcPass p) arg) = SrcSpanAnnA

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsOuterTyVarBndrs _1 (GhcPass _2))

Defined in GHC.Hs.Type

type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag (GhcPass _1))

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag (GhcPass _1)) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcPs)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcPs) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcRn)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcRn) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcTc)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcTc) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))

Defined in GHC.Hs.Expr

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

pprIfTc :: forall (p :: Pass). IsPass p => (p ~ 'Typechecked => SDoc) -> SDoc

pprIfRn :: forall (p :: Pass). IsPass p => (p ~ 'Renamed => SDoc) -> SDoc

pprIfPs :: forall (p :: Pass). IsPass p => (p ~ 'Parsed => SDoc) -> SDoc

mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr

type TcMCoercionR = MCoercionR

type TcMCoercionN = MCoercionN

type TcMCoercion = MCoercion

data TcEvBinds

Constructors

TcEvBinds EvBindsVar

EvBinds (Bag EvBind)

Instances

Data TcEvBinds

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: TcEvBinds -> Constr

dataTypeOf :: TcEvBinds -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable TcEvBinds

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: TcEvBinds -> SDoc

type TcCoercionR = CoercionR

type TcCoercionP = CoercionP

type TcCoercionN = CoercionN

type TcCoercion = Coercion

data QuoteWrapper

Constructors

QuoteWrapper EvVar Type

Instances

Data QuoteWrapper

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: QuoteWrapper -> Constr

dataTypeOf :: QuoteWrapper -> DataType

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

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

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

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

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

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

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

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

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

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

data HsWrapper

Constructors

WpHole

WpCompose HsWrapper HsWrapper

WpFun HsWrapper HsWrapper (Scaled TcType) SDoc

WpCast TcCoercionR

WpEvLam EvVar

WpEvApp EvTerm

WpTyLam TyVar

WpTyApp KindOrType

WpLet TcEvBinds

WpMultCoercion Coercion

Instances

Data HsWrapper

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: HsWrapper -> Constr

dataTypeOf :: HsWrapper -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable HsWrapper

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: HsWrapper -> SDoc

data HoleExprRef

Where to store evidence for expression holes See Note [Holes] in GHC.Tc.Types.Constraint

Constructors

HER

Fields

• (IORef EvTerm)

  where to write the erroring expression

• TcType

  expected type of that expression

• Unique

  for debug output only

Instances

Data HoleExprRef

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: HoleExprRef -> Constr

dataTypeOf :: HoleExprRef -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable HoleExprRef

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: HoleExprRef -> SDoc

data EvTypeable

Instructions on how to make a Typeable dictionary. See Note [Typeable evidence terms]

Constructors

EvTypeableTyCon TyCon [EvTerm]

Dictionary for Typeable T where T is a type constructor with all of its kind variables saturated. The [EvTerm] is Typeable evidence for the applied kinds..

EvTypeableTyApp EvTerm EvTerm

Dictionary for Typeable (s t), given a dictionaries for s and t.

EvTypeableTrFun EvTerm EvTerm EvTerm

Dictionary for Typeable (s # w -> t), given a dictionaries for w, s, and t.

EvTypeableTyLit EvTerm

Dictionary for a type literal, e.g. Typeable "foo" or Typeable 3 The EvTerm is evidence of, e.g., KnownNat 3 (see #10348)

Instances

Data EvTypeable

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: EvTypeable -> Constr

dataTypeOf :: EvTypeable -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable EvTypeable

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvTypeable -> SDoc

data EvTerm

Constructors

EvExpr EvExpr

EvTypeable Type EvTypeable

EvFun

Fields

• et_tvs :: [TyVar]
• et_given :: [EvVar]
• et_binds :: TcEvBinds
• et_body :: EvVar

Instances

Data EvTerm

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: EvTerm -> Constr

dataTypeOf :: EvTerm -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable EvTerm

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvTerm -> SDoc

type EvExpr = CoreExpr

data EvCallStack

Evidence for CallStack implicit parameters.

Constructors

EvCsEmpty

EvCsPushCall Name RealSrcSpan EvExpr

EvCsPushCall name loc stk represents a call to name, occurring at loc, in a calling context stk.

Instances

Data EvCallStack

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: EvCallStack -> Constr

dataTypeOf :: EvCallStack -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable EvCallStack

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvCallStack -> SDoc

data EvBindsVar

Constructors

EvBindsVar

Fields

• ebv_uniq :: Unique
• ebv_binds :: IORef EvBindMap
• ebv_tcvs :: IORef CoVarSet

CoEvBindsVar

Fields

• ebv_uniq :: Unique
• ebv_tcvs :: IORef CoVarSet

Instances

Uniquable EvBindsVar

Defined in GHC.Tc.Types.Evidence

Methods

getUnique :: EvBindsVar -> Unique

Outputable EvBindsVar

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBindsVar -> SDoc

newtype EvBindMap

Constructors

EvBindMap

Fields

• ev_bind_varenv :: DVarEnv EvBind

Instances

Outputable EvBindMap

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBindMap -> SDoc

data EvBind

Constructors

EvBind

Fields

• eb_lhs :: EvVar
• eb_rhs :: EvTerm
• eb_is_given :: Bool

Instances

Outputable EvBind

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBind -> SDoc

wrapIP :: Type -> CoercionR

Create a Expr that wraps a value in an implicit-parameter dictionary. See unwrapIP.

varSetMinusEvBindMap :: VarSet -> EvBindMap -> VarSet

unwrapIP :: Type -> CoercionR

Create a Expr that unwraps an implicit-parameter or overloaded-label dictionary to expose the underlying value. We expect the Expr to have the form `IP sym ty` or `IsLabel sym ty`, and return a Expr `co :: IP sym ty ~ ty` or `co :: IsLabel sym ty ~ ty`. See also Note [Type-checking overloaded labels] in GHC.Tc.Gen.Expr.

tcDowngradeRole :: Role -> Role -> TcCoercion -> TcCoercion

tcCoercionRole :: TcCoercion -> Role

tcCoercionKind :: TcCoercion -> Pair TcType

quoteWrapperTyVarTy :: QuoteWrapper -> Type

pprHsWrapper :: HsWrapper -> (Bool -> SDoc) -> SDoc

nonDetStrictFoldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a

mkWpTyLams :: [TyVar] -> HsWrapper

mkWpTyApps :: [Type] -> HsWrapper

mkWpLet :: TcEvBinds -> HsWrapper

mkWpLams :: [Var] -> HsWrapper

mkWpFun :: HsWrapper -> HsWrapper -> Scaled TcType -> TcType -> SDoc -> HsWrapper

mkWpEvVarApps :: [EvVar] -> HsWrapper

mkWpEvApps :: [EvTerm] -> HsWrapper

mkWpCastR :: TcCoercionR -> HsWrapper

mkWpCastN :: TcCoercionN -> HsWrapper

mkWantedEvBind :: EvVar -> EvTerm -> EvBind

mkTcUnbranchedAxInstCo :: CoAxiom Unbranched -> [TcType] -> [TcCoercion] -> TcCoercionR

mkTcTyConAppCo :: Role -> TyCon -> [TcCoercion] -> TcCoercion

mkTcTransCo :: TcCoercion -> TcCoercion -> TcCoercion

mkTcSymMCo :: TcMCoercion -> TcMCoercion

mkTcSymCo :: TcCoercion -> TcCoercion

mkTcSubCo :: HasDebugCallStack => TcCoercionN -> TcCoercionR

mkTcRepReflCo :: TcType -> TcCoercionR

mkTcReflCo :: Role -> TcType -> TcCoercion

mkTcPhantomCo :: TcCoercionN -> TcType -> TcType -> TcCoercionP

mkTcNthCo :: Role -> Int -> TcCoercion -> TcCoercion

mkTcNomReflCo :: TcType -> TcCoercionN

mkTcLRCo :: LeftOrRight -> TcCoercion -> TcCoercion

mkTcKindCo :: TcCoercion -> TcCoercionN

mkTcGReflRightMCo :: Role -> TcType -> TcMCoercionN -> TcCoercion

mkTcGReflRightCo :: Role -> TcType -> TcCoercionN -> TcCoercion

mkTcGReflLeftMCo :: Role -> TcType -> TcMCoercionN -> TcCoercion

mkTcGReflLeftCo :: Role -> TcType -> TcCoercionN -> TcCoercion

mkTcFunCo :: Role -> TcCoercion -> TcCoercion -> TcCoercion -> TcCoercion

mkTcForAllCos :: [(TyVar, TcCoercionN)] -> TcCoercion -> TcCoercion

mkTcForAllCo :: TyVar -> TcCoercionN -> TcCoercion -> TcCoercion

mkTcFamilyTyConAppCo :: TyCon -> [TcCoercionN] -> TcCoercionN

mkTcCoherenceRightCo :: Role -> TcType -> TcCoercionN -> TcCoercion -> TcCoercion

mkTcCoherenceLeftCo :: Role -> TcType -> TcCoercionN -> TcCoercion -> TcCoercion

mkTcCoVarCo :: CoVar -> TcCoercion

mkTcAxiomRuleCo :: CoAxiomRule -> [TcCoercion] -> TcCoercionR

mkTcAxInstCo :: forall (br :: BranchFlag). Role -> CoAxiom br -> BranchIndex -> [TcType] -> [TcCoercion] -> TcCoercion

mkTcAppCo :: TcCoercion -> TcCoercionN -> TcCoercion

mkGivenEvBind :: EvVar -> EvTerm -> EvBind

mkEvScSelectors :: Class -> [TcType] -> [(TcPredType, EvExpr)]

mkEvCast :: EvExpr -> TcCoercion -> EvTerm

maybeTcSymCo :: SwapFlag -> TcCoercion -> TcCoercion

If a SwapFlag is IsSwapped, flip the orientation of a coercion

maybeTcSubCo :: HasDebugCallStack => EqRel -> TcCoercionN -> TcCoercion

If the EqRel is ReprEq, makes a SubCo; otherwise, does nothing. Note that the input coercion should always be nominal.

lookupEvBind :: EvBindMap -> EvVar -> Maybe EvBind

isTcReflexiveCo :: TcCoercion -> Bool

This version does a slow check, calculating the related types and seeing if they are equal.

isTcReflCo :: TcCoercion -> Bool

isIdHsWrapper :: HsWrapper -> Bool

isEmptyTcEvBinds :: TcEvBinds -> Bool

isEmptyEvBindMap :: EvBindMap -> Bool

isCoEvBindsVar :: EvBindsVar -> Bool

idHsWrapper :: HsWrapper

hsWrapDictBinders :: HsWrapper -> Bag DictId

Identifies the lambda-bound dictionaries of an HsWrapper. This is used (only) to allow the pattern-match overlap checker to know what Given dictionaries are in scope.

We specifically do not collect dictionaries bound in a WpLet. These are either superclasses of lambda-bound ones, or (extremely numerous) results of binding Wanted dictionaries. We definitely don't want all those cluttering up the Given dictionaries for pattern-match overlap checking!

foldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a

findNeededEvVars :: EvBindMap -> VarSet -> VarSet

filterEvBindMap :: (EvBind -> Bool) -> EvBindMap -> EvBindMap

extendEvBinds :: EvBindMap -> EvBind -> EvBindMap

evVarsOfTerm :: EvTerm -> VarSet

evTypeable :: Type -> EvTypeable -> EvTerm

evTermCoercion_maybe :: EvTerm -> Maybe TcCoercion

evTermCoercion :: EvTerm -> TcCoercion

evSelector :: Id -> [Type] -> [EvExpr] -> EvExpr

evId :: EvId -> EvExpr

Any sort of evidence Id, including coercions

evDataConApp :: DataCon -> [Type] -> [EvExpr] -> EvTerm

evDFunApp :: DFunId -> [Type] -> [EvExpr] -> EvTerm

evCoercion :: TcCoercion -> EvTerm

evCast :: EvExpr -> TcCoercion -> EvTerm

d |> co

evBindVar :: EvBind -> EvVar

evBindMapToVarSet :: EvBindMap -> VarSet

evBindMapBinds :: EvBindMap -> Bag EvBind

emptyTcEvBinds :: TcEvBinds

emptyEvBindMap :: EvBindMap

collectHsWrapBinders :: HsWrapper -> ([Var], HsWrapper)

applyQuoteWrapper :: QuoteWrapper -> HsWrapper

Convert the QuoteWrapper into a normal HsWrapper which can be used to apply its contents.

(<.>) :: HsWrapper -> HsWrapper -> HsWrapper

type VisibleOrphanModules = ModuleSet

Set of visible orphan modules, according to what modules have been directly imported. This is based off of the dep_orphs field, which records transitively reachable orphan modules (modules that define orphan instances).

type InstMatch = (ClsInst, [DFunInstType])

data InstEnvs

InstEnvs represents the combination of the global type class instance environment, the local type class instance environment, and the set of transitively reachable orphan modules (according to what modules have been directly imported) used to test orphan instance visibility.

Constructors

InstEnvs

Fields

• ie_global :: InstEnv
• ie_local :: InstEnv
• ie_visible :: VisibleOrphanModules

type InstEnv = UniqDFM Class ClsInstEnv

type DFunInstType = Maybe Type

type ClsInstLookupResult = ([InstMatch], [ClsInst], [InstMatch])

data ClsInst

A type-class instance. Note that there is some tricky laziness at work here. See Note [ClsInst laziness and the rough-match fields] for more details.

Constructors

ClsInst

Fields

• is_cls_nm :: Name

  Class name

• is_tcs :: [RoughMatchTc]

  Top of type args

• is_dfun_name :: Name

  is_dfun_name = idName . is_dfun.

  We use is_dfun_name for the visibility check, instIsVisible, which needs to know the Module which the dictionary is defined in. However, we cannot use the Module attached to is_dfun since doing so would mean we would potentially pull in an entire interface file unnecessarily. This was the cause of #12367.

• is_tvs :: [TyVar]
• is_cls :: Class
• is_tys :: [Type]
• is_dfun :: DFunId
• is_flag :: OverlapFlag
• is_orphan :: IsOrphan

Instances

Data ClsInst

Defined in GHC.Core.InstEnv

Methods

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

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

toConstr :: ClsInst -> Constr

dataTypeOf :: ClsInst -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing ClsInst

Defined in GHC.Core.InstEnv

Methods

getOccName :: ClsInst -> OccName

getName :: ClsInst -> Name

Outputable ClsInst

Defined in GHC.Core.InstEnv

Methods

ppr :: ClsInst -> SDoc

updateClsInstDFun :: (DFunId -> DFunId) -> ClsInst -> ClsInst

pprInstances :: [ClsInst] -> SDoc

pprInstanceHdr :: ClsInst -> SDoc

pprInstance :: ClsInst -> SDoc

orphNamesOfClsInst :: ClsInst -> NameSet

Collects the names of concrete types and type constructors that make up the head of a class instance. For instance, given `class Foo a b`:

`instance Foo (Either (Maybe Int) a) Bool` would yield [Either, Maybe, Int, Bool]

Used in the implementation of ":info" in GHCi.

The tcSplitSigmaTy is because of instance Foo a => Baz T where ... The decl is an orphan if Baz and T are both not locally defined, even if Foo *is* locally defined

mkLocalInstance :: DFunId -> OverlapFlag -> [TyVar] -> Class -> [Type] -> ClsInst

mkImportedInstance

Arguments

:: Name

the name of the class

-> [RoughMatchTc]

the types which the class was applied to

-> Name

the Name of the dictionary binding

-> DFunId

the Id of the dictionary.

-> OverlapFlag

may this instance overlap?

-> IsOrphan

is this instance an orphan?

-> ClsInst

memberInstEnv :: InstEnv -> ClsInst -> Bool

Checks for an exact match of ClsInst in the instance environment. We use this when we do signature checking in GHC.Tc.Module

lookupUniqueInstEnv :: InstEnvs -> Class -> [Type] -> Either SDoc (ClsInst, [Type])

Look up an instance in the given instance environment. The given class application must match exactly one instance and the match may not contain any flexi type variables. If the lookup is unsuccessful, yield 'Left errorMessage'.

lookupInstEnv :: Bool -> InstEnvs -> Class -> [Type] -> ClsInstLookupResult

See Note [Rules for instance lookup] ^ See Note [Safe Haskell Overlapping Instances] in GHC.Tc.Solver ^ See Note [Safe Haskell Overlapping Instances Implementation] in GHC.Tc.Solver

isOverlapping :: ClsInst -> Bool

isOverlappable :: ClsInst -> Bool

isIncoherent :: ClsInst -> Bool

instanceSig :: ClsInst -> ([TyVar], [Type], Class, [Type])

instanceRoughTcs :: ClsInst -> [RoughMatchTc]

instanceHead :: ClsInst -> ([TyVar], Class, [Type])

instanceDFunId :: ClsInst -> DFunId

instanceBindFun :: BindFun

instIsVisible :: VisibleOrphanModules -> ClsInst -> Bool

Test if an instance is visible, by checking that its origin module is in VisibleOrphanModules. See Note [Instance lookup and orphan instances]

instEnvElts :: InstEnv -> [ClsInst]

instEnvClasses :: InstEnv -> [Class]

identicalClsInstHead :: ClsInst -> ClsInst -> Bool

True when when the instance heads are the same e.g. both are Eq [(a,b)] Used for overriding in GHCi Obviously should be insensitive to alpha-renaming

fuzzyClsInstCmp :: ClsInst -> ClsInst -> Ordering

A fuzzy comparison function for class instances, intended for sorting instances before displaying them to the user.

extendInstEnvList :: InstEnv -> [ClsInst] -> InstEnv

extendInstEnv :: InstEnv -> ClsInst -> InstEnv

emptyInstEnv :: InstEnv

deleteFromInstEnv :: InstEnv -> ClsInst -> InstEnv

deleteDFunFromInstEnv :: InstEnv -> DFunId -> InstEnv

classInstances :: InstEnvs -> Class -> [ClsInst]

data TcLclEnv

Constructors

TcLclEnv

Fields

• tcl_loc :: RealSrcSpan
• tcl_ctxt :: [ErrCtxt]
• tcl_in_gen_code :: Bool
• tcl_tclvl :: TcLevel
• tcl_th_ctxt :: ThStage
• tcl_th_bndrs :: ThBindEnv
• tcl_arrow_ctxt :: ArrowCtxt
• tcl_rdr :: LocalRdrEnv
• tcl_env :: TcTypeEnv
• tcl_usage :: TcRef UsageEnv
• tcl_bndrs :: TcBinderStack
• tcl_lie :: TcRef WantedConstraints
• tcl_errs :: TcRef (Messages DecoratedSDoc)

setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv

setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv

getLclEnvTcLevel :: TcLclEnv -> TcLevel

getLclEnvLoc :: TcLclEnv -> RealSrcSpan

type TypeSize = IntWithInf

type TcType = Type

type TcTyVarSet = TyVarSet

type TcTyVarBinder = TyVarBinder

type TcTyCon = TyCon

type TcTyCoVarSet = TyCoVarSet

type TcTyCoVar = Var

type TcThetaType = ThetaType

type TcTauType = TcType

type TcSigmaType = TcType

type TcRhoType = TcType

type TcReqTVBinder = ReqTVBinder

type TcPredType = PredType

newtype TcLevel

Constructors

TcLevel Int

Instances

Outputable TcLevel

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: TcLevel -> SDoc

Eq TcLevel

Defined in GHC.Tc.Utils.TcType

Methods

(==) :: TcLevel -> TcLevel -> Bool

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

Ord TcLevel

Defined in GHC.Tc.Utils.TcType

Methods

compare :: TcLevel -> TcLevel -> Ordering

(<) :: TcLevel -> TcLevel -> Bool

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

(>) :: TcLevel -> TcLevel -> Bool

(>=) :: TcLevel -> TcLevel -> Bool

max :: TcLevel -> TcLevel -> TcLevel

min :: TcLevel -> TcLevel -> TcLevel

type TcKind = Kind

type TcInvisTVBinder = InvisTVBinder

type TcDTyVarSet = DTyVarSet

type TcDTyCoVarSet = DTyCoVarSet

type TcCoVar = CoVar

data SyntaxOpType

What to expect for an argument to a rebindable-syntax operator. Quite like Type, but allows for holes to be filled in by tcSyntaxOp. The callback called from tcSyntaxOp gets a list of types; the meaning of these types is determined by a left-to-right depth-first traversal of the SyntaxOpType tree. So if you pass in

SynAny `SynFun` (SynList `SynFun` SynType Int) `SynFun` SynAny

you'll get three types back: one for the first SynAny, the element type of the list, and one for the last SynAny. You don't get anything for the SynType, because you've said positively that it should be an Int, and so it shall be.

You'll also get three multiplicities back: one for each function arrow. See also Note [Linear types] in Multiplicity.

This is defined here to avoid defining it in GHC.Tc.Gen.Expr boot file.

Constructors

SynAny

Any type

SynRho

A rho type, skolemised or instantiated as appropriate

SynList

A list type. You get back the element type of the list

SynFun SyntaxOpType SyntaxOpType infixr 0

A function.

SynType ExpType

A known type.

data MetaInfo

Constructors

TauTv

TyVarTv

RuntimeUnkTv

CycleBreakerTv

Instances

Outputable MetaInfo

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: MetaInfo -> SDoc

data InferResult

Constructors

IR

Fields

• ir_uniq :: Unique
• ir_lvl :: TcLevel
• ir_ref :: IORef (Maybe TcType)

Instances

Outputable InferResult

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: InferResult -> SDoc

data ExpType

An expected type to check against during type-checking. See Note [ExpType] in GHC.Tc.Utils.TcMType, where you'll also find manipulators.

Constructors

Check TcType

Infer !InferResult

Instances

Outputable ExpType

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: ExpType -> SDoc

type ExpSigmaType = ExpType

type ExpRhoType = ExpType

transSuperClasses :: PredType -> [PredType]

topTcLevel :: TcLevel

tcTypeLevel :: TcType -> TcLevel

tcTyVarLevel :: TcTyVar -> TcLevel

tcTyFamInstsAndVis :: Type -> [(Bool, TyCon, [Type])]

Like tcTyFamInsts, except that the output records whether the type family and its arguments occur as an invisible argument in some type application. This information is useful because it helps GHC know when to turn on -fprint-explicit-kinds during error reporting so that users can actually see the type family being mentioned.

As an example, consider:

class C a
data T (a :: k)
type family F a :: k
instance C (T @(F Int) (F Bool))

There are two occurrences of the type family F in that C instance, so tcTyFamInstsAndVis (C (T @(F Int) (F Bool))) will return:

[ (True,  F, [Int])
, (False, F, [Bool]) ]

F Int is paired with True since it appears as an invisible argument to C, whereas F Bool is paired with False since it appears an a visible argument to C.

See also Note [Kind arguments in error messages] in GHC.Tc.Errors.

tcTyFamInsts :: Type -> [(TyCon, [Type])]

Finds outermost type-family applications occurring in a type, after expanding synonyms. In the list (F, tys) that is returned we guarantee that tys matches F's arity. For example, given type family F a :: * -> * (arity 1) calling tcTyFamInsts on (Maybe (F Int Bool) will return (F, [Int]), not (F, [Int,Bool])

This is important for its use in deciding termination of type instances (see #11581). E.g. type instance G [Int] = ...(F Int <big type>)... we don't need to take <big type> into account when asking if the calls on the RHS are smaller than the LHS

tcTyConVisibilities :: TyCon -> [Bool]

For every arg a tycon can take, the returned list says True if the argument is taken visibly, and False otherwise. Ends with an infinite tail of Trues to allow for oversaturation.

tcTyConAppTyFamInstsAndVis :: TyCon -> [Type] -> [(Bool, TyCon, [Type])]

In an application of a TyCon to some arguments, find the outermost occurrences of type family applications within the arguments. This function will not consider the TyCon itself when checking for type family applications.

See tcTyFamInstsAndVis for more details on how this works (as this function is called inside of tcTyFamInstsAndVis).

tcTyConAppTyCon_maybe :: Type -> Maybe TyCon

Like tcRepSplitTyConApp_maybe, but only returns the TyCon.

tcTyConAppTyCon :: Type -> TyCon

tcTyConAppArgs :: Type -> [Type]

tcSplitTyConApp :: Type -> (TyCon, [Type])

tcSplitSomeForAllTyVars :: (ArgFlag -> Bool) -> Type -> ([TyVar], Type)

Like tcSplitForAllTyVars, but only splits a ForAllTy if argf_pred argf is True, where argf is the visibility of the ForAllTy's binder and argf_pred is a predicate over visibilities provided as an argument to this function.

tcSplitSigmaTy :: Type -> ([TyVar], ThetaType, Type)

Split a sigma type into its parts. This only splits invisible type variable binders, as these are the only forms of binder that the typechecker will implicitly instantiate.

tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)

tcSplitPiTys :: Type -> ([TyBinder], Type)

Splits a forall type into a list of TyBinders and the inner type. Always succeeds, even if it returns an empty list.

tcSplitPiTy_maybe :: Type -> Maybe (TyBinder, Type)

Splits a type into a TyBinder and a body, if possible. Panics otherwise

tcSplitPhiTy :: Type -> (ThetaType, Type)

tcSplitNestedSigmaTys :: Type -> ([TyVar], ThetaType, Type)

Split a sigma type into its parts, going underneath as many arrows and foralls as possible. See Note [tcSplitNestedSigmaTys]

tcSplitMethodTy :: Type -> ([TyVar], PredType, Type)

tcSplitIOType_maybe :: Type -> Maybe (TyCon, Type)

tcSplitFunTysN :: Arity -> TcRhoType -> Either Arity ([Scaled TcSigmaType], TcSigmaType)

Split off exactly the specified number argument types Returns (Left m) if there are m missing arrows in the type (Right (tys,res)) if the type looks like t1 -> ... -> tn -> res

tcSplitFunTys :: Type -> ([Scaled Type], Type)

tcSplitFunTy_maybe :: Type -> Maybe (Scaled Type, Type)

tcSplitForAllTyVars :: Type -> ([TyVar], Type)

Like tcSplitPiTys, but splits off only named binders, returning just the tyvars.

tcSplitForAllTyVarBinders :: Type -> ([TyVarBinder], Type)

Like tcSplitForAllTyVars, but splits off only named binders.

tcSplitForAllTyVarBinder_maybe :: Type -> Maybe (TyVarBinder, Type)

tcSplitForAllReqTVBinders :: Type -> ([TcReqTVBinder], Type)

Like tcSplitForAllTyVars, but only splits ForAllTys with Required type variable binders. All split tyvars are annotated with ().

tcSplitForAllInvisTyVars :: Type -> ([TyVar], Type)

Like tcSplitForAllTyVars, but only splits ForAllTys with Invisible type variable binders.

tcSplitForAllInvisTVBinders :: Type -> ([TcInvisTVBinder], Type)

Like tcSplitForAllTyVars, but only splits ForAllTys with Invisible type variable binders. All split tyvars are annotated with their Specificity.

tcSplitDFunTy :: Type -> ([TyVar], [Type], Class, [Type])

tcSplitDFunHead :: Type -> (Class, [Type])

tcSplitAppTys :: Type -> (Type, [Type])

tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)

tcSplitAppTy :: Type -> (Type, Type)

tcRepGetNumAppTys :: Type -> Arity

Returns the number of arguments in the given type, without looking through synonyms. This is used only for error reporting. We don't look through synonyms because of #11313.

tcIsTyVarTy :: Type -> Bool

tcIsTcTyVar :: TcTyVar -> Bool

tcIsForAllTy :: Type -> Bool

Is this a ForAllTy with a named binder?

tcGetTyVar_maybe :: Type -> Maybe TyVar

tcGetTyVar :: String -> Type -> TyVar

tcGetCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)

If the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind type

tcFunResultTyN :: HasDebugCallStack => Arity -> Type -> Type

Strips off n *visible* arguments and returns the resulting type

tcFunResultTy :: Type -> Type

tcFunArgTy :: Type -> Scaled Type

tcEqTypeVis :: TcType -> TcType -> Bool

Like tcEqType, but returns True if the visible part of the types are equal, even if they are really unequal (in the invisible bits)

tcEqTypeNoKindCheck :: TcType -> TcType -> Bool

Just like tcEqType, but will return True for types of different kinds as long as their non-coercion structure is identical.

tcEqType :: HasDebugCallStack => TcType -> TcType -> Bool

tcEqType implements typechecker equality, as described in Note [Typechecker equality vs definitional equality].

tcEqTyConApps :: TyCon -> [Type] -> TyCon -> [Type] -> Bool

Check whether two TyConApps are the same; if the number of arguments are different, just checks the common prefix of arguments.

tcEqKind :: HasDebugCallStack => TcKind -> TcKind -> Bool

synKnownType :: TcType -> SyntaxOpType

Like SynType but accepts a regular TcType

superSkolemTv :: TcTyVarDetails

strictlyDeeperThan :: TcLevel -> TcLevel -> Bool

sizeTypes :: [Type] -> TypeSize

sizeType :: Type -> TypeSize

setMetaTyVarTcLevel :: TcTyVar -> TcLevel -> TcTyVar

sameDepthAs :: TcLevel -> TcLevel -> Bool

pushTcLevel :: TcLevel -> TcLevel

promoteSkolemsX :: TcLevel -> TCvSubst -> [TcTyVar] -> (TCvSubst, [TcTyVar])

promoteSkolemX :: TcLevel -> TCvSubst -> TcTyVar -> (TCvSubst, TcTyVar)

Change the TcLevel in a skolem, extending a substitution

promoteSkolem :: TcLevel -> TcTyVar -> TcTyVar

pickyEqType :: TcType -> TcType -> Bool

Like pickyEqTypeVis, but returns a Bool for convenience

pickQuantifiablePreds :: TyVarSet -> TcThetaType -> TcThetaType

When inferring types, should we quantify over a given predicate? Generally true of classes; generally false of equality constraints. Equality constraints that mention quantified type variables and implicit variables complicate the story. See Notes [Inheriting implicit parameters] and [Quantifying over equality constraints]

pickCapturedPreds :: TyVarSet -> TcThetaType -> TcThetaType

mkTyVarNamePairs :: [TyVar] -> [(Name, TyVar)]

mkTcCastTy :: Type -> Coercion -> Type

mkTcAppTys :: Type -> [Type] -> Type

mkTcAppTy :: Type -> Type -> Type

mkSynFunTys :: [SyntaxOpType] -> ExpType -> SyntaxOpType

Like mkFunTys but for SyntaxOpType

mkSpecSigmaTy :: [TyVar] -> [PredType] -> Type -> Type

Make a sigma ty where all type variables are "specified". That is, they can be used with visible type application

mkSigmaTy :: [TyCoVarBinder] -> [PredType] -> Type -> Type

mkPhiTy :: [PredType] -> Type -> Type

mkMinimalBySCs :: (a -> PredType) -> [a] -> [a]

mkInfSigmaTy :: [TyCoVar] -> [PredType] -> Type -> Type

Make a sigma ty where all type variables are Inferred. That is, they cannot be used with visible type application.

mkCheckExpType :: TcType -> ExpType

Make an ExpType suitable for checking.

metaTyVarTcLevel_maybe :: TcTyVar -> Maybe TcLevel

metaTyVarTcLevel :: TcTyVar -> TcLevel

metaTyVarRef :: TyVar -> IORef MetaDetails

metaTyVarInfo :: TcTyVar -> MetaInfo

maxTcLevel :: TcLevel -> TcLevel -> TcLevel

isWordTy :: Type -> Bool

isUnitTy :: Type -> Bool

isTyVarTyVar :: Var -> Bool

isTyVarClassPred :: PredType -> Bool

isTyFamFree :: Type -> Bool

Check that a type does not contain any type family applications.

isTouchableMetaTyVar :: TcLevel -> TcTyVar -> Bool

isTopTcLevel :: TcLevel -> Bool

isStringTy :: Type -> Bool

Is a type String?

isSkolemTyVar :: TcTyVar -> Bool

isSigmaTy :: TcType -> Bool

isRuntimeUnkSkol :: TyVar -> Bool

isRigidTy :: TcType -> Bool

isRhoTy :: TcType -> Bool

isRhoExpTy :: ExpType -> Bool

Like isRhoTy, but also says True for Infer types

isPromotableMetaTyVar :: TcTyVar -> Bool

isOverloadedTy :: Type -> Bool

isOverlappableTyVar :: TcTyVar -> Bool

isNextTyConArgVisible :: TyCon -> [Type] -> Bool

If the tycon is applied to the types, is the next argument visible?

isNextArgVisible :: TcType -> Bool

Should this type be applied to a visible argument?

isNaturalTy :: Type -> Bool

isMetaTyVarTy :: TcType -> Bool

isIntegerTy :: Type -> Bool

isIntTy :: Type -> Bool

isIndirect :: MetaDetails -> Bool

isImprovementPred :: PredType -> Bool

isImmutableTyVar :: TyVar -> Bool

isFunPtrTy :: Type -> Bool

isFloatingTy :: Type -> Bool

Does a type represent a floating-point number?

isFloatTy :: Type -> Bool

isFlexi :: MetaDetails -> Bool

isFFITy :: Type -> Bool

isFFIPrimResultTy :: DynFlags -> Type -> Validity

isFFIPrimArgumentTy :: DynFlags -> Type -> Validity

isFFILabelTy :: Type -> Validity

isFFIImportResultTy :: DynFlags -> Type -> Validity

isFFIExternalTy :: Type -> Validity

isFFIExportResultTy :: Type -> Validity

isFFIDynTy :: Type -> Type -> Validity

isFFIArgumentTy :: DynFlags -> Safety -> Type -> Validity

isDoubleTy :: Type -> Bool

isCycleBreakerTyVar :: TcTyVar -> Bool

isCharTy :: Type -> Bool

isCallStackTy :: Type -> Bool

Is a type a CallStack?

isCallStackPred :: Class -> [Type] -> Maybe FastString

Is a PredType a CallStack implicit parameter?

If so, return the name of the parameter.

isBoolTy :: Type -> Bool

isAmbiguousTyVar :: TcTyVar -> Bool

immSuperClasses :: Class -> [Type] -> [PredType]

hasTyVarHead :: Type -> Bool

getDFunTyKey :: Type -> OccName

findDupTyVarTvs :: [(Name, TcTyVar)] -> [(Name, Name)]

exactTyCoVarsOfTypes :: [Type] -> TyCoVarSet

exactTyCoVarsOfType :: Type -> TyCoVarSet

evVarPred :: EvVar -> PredType

deeperThanOrSame :: TcLevel -> TcLevel -> Bool

deNoteType :: Type -> Type

checkValidClsArgs :: Bool -> Class -> [KindOrType] -> Bool

boxEqPred :: EqRel -> Type -> Type -> Maybe (Class, [Type])

anyRewritableTyVar :: Bool -> EqRel -> (EqRel -> TcTyVar -> Bool) -> TcType -> Bool

anyRewritableTyFamApp :: EqRel -> (EqRel -> TyCon -> [TcType] -> Bool) -> TcType -> Bool

anyRewritableCanEqLHS :: EqRel -> (EqRel -> TcTyVar -> Bool) -> (EqRel -> TyCon -> [TcType] -> Bool) -> TcType -> Bool

orphNamesOfTypes :: [Type] -> NameSet

orphNamesOfType :: Type -> NameSet

orphNamesOfCoCon :: forall (br :: BranchFlag). CoAxiom br -> NameSet

orphNamesOfCo :: Coercion -> NameSet

lookupOrigNameCache :: OrigNameCache -> Module -> OccName -> Maybe Name

extendNameCache :: OrigNameCache -> Module -> OccName -> Name -> OrigNameCache

wordTyConName :: Name

wordTyCon :: TyCon

wordTy :: Type

wordDataCon :: DataCon

word8TyCon :: TyCon

word8Ty :: Type

word8DataCon :: DataCon

wiredInTyCons :: [TyCon]

unrestrictedFunTyConName :: Name

unliftedTypeKindTyConName :: Name

unliftedRepTyConName :: Name

unliftedDataConTyCon :: TyCon

unitTyConKey :: Unique

unitTyCon :: TyCon

unitDataConId :: Id

unitDataCon :: DataCon

unboxedUnitTyCon :: TyCon

unboxedUnitTy :: Type

unboxedUnitDataCon :: DataCon

unboxedSumKind :: [Type] -> Kind

Specialization of unboxedTupleSumKind for sums

typeToTypeKind :: Kind

typeSymbolKindCon :: TyCon

tupleDataConName :: Boxity -> Arity -> Name

true_RDR :: RdrName

trueDataConId :: Id

trueDataCon :: DataCon

sumRepDataConTyCon :: TyCon

stringTyCon_RDR :: RdrName

stringTy :: Type

soloTyCon :: TyCon

promotedTrueDataCon :: TyCon

promotedNothingDataCon :: TyCon

promotedNilDataCon :: TyCon

promotedLTDataCon :: TyCon

promotedJustDataCon :: TyCon

promotedGTDataCon :: TyCon

promotedFalseDataCon :: TyCon

promotedEQDataCon :: TyCon

promotedConsDataCon :: TyCon

pairTyCon :: TyCon

orderingTyCon :: TyCon

ordLTDataConId :: Id

ordLTDataCon :: DataCon

ordGTDataConId :: Id

ordGTDataCon :: DataCon

ordEQDataConId :: Id

ordEQDataCon :: DataCon

oneDataConName :: Name

oneDataCon :: DataCon

nothingDataConName :: Name

nothingDataCon :: DataCon

nonEmptyTyConName :: Name

nonEmptyTyCon :: TyCon

nonEmptyDataConName :: Name

nonEmptyDataCon :: DataCon

nilDataConName :: Name

nilDataCon :: DataCon

naturalTyConName :: Name

naturalTyCon :: TyCon

naturalNSDataConName :: Name

naturalNSDataCon :: DataCon

naturalNBDataConName :: Name

naturalNBDataCon :: DataCon

multiplicityTyConName :: Name

mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name

mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name

mkTupleTy1 :: Boxity -> [Type] -> Type

Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are *not* flattened. See Note [One-tuples] and Note [Don't flatten tuples from HsSyn] in GHC.Core.Make

mkTupleTy :: Boxity -> [Type] -> Type

Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are flattened. See Note [One-tuples]

mkTupleStr :: Boxity -> Arity -> String

mkSumTy :: [Type] -> Type

mkPromotedPairTy :: Kind -> Kind -> Type -> Type -> Type

mkPromotedMaybeTy :: Kind -> Maybe Type -> Type

mkMaybeTy :: Type -> Kind

mkListTy :: Type -> Type

maybeTyConName :: Name

maybeTyCon :: TyCon

manyDataConName :: Name

manyDataCon :: DataCon

makeRecoveryTyCon :: TyCon -> TyCon

Make a fake, recovery TyCon from an existing one. Used when recovering from errors in type declarations

listTyCon_RDR :: RdrName

listTyConName :: Name

liftedTypeKindTyConName :: Name

liftedRepTyConName :: Name

justDataConName :: Name

justDataCon :: DataCon

isPromotedPairType :: Type -> Maybe (Type, Type)

isPromotedMaybeTy :: Type -> Maybe (Maybe Type)

isCTupleTyConName :: Name -> Bool

isBuiltInOcc_maybe :: OccName -> Maybe Name

Built-in syntax isn't "in scope" so these OccNames map to wired-in Names with BuiltInSyntax. However, this should only be necessary while resolving names produced by Template Haskell splices since we take care to encode built-in syntax names specially in interface files. See Note [Symbol table representation of names].

Moreover, there is no need to include names of things that the user can't write (e.g. type representation bindings like $tc(,,,)).

integerTyConName :: Name

integerTyCon :: TyCon

integerISDataConName :: Name

integerISDataCon :: DataCon

integerIPDataConName :: Name

integerIPDataCon :: DataCon

integerINDataConName :: Name

integerINDataCon :: DataCon

intTyCon_RDR :: RdrName

intTyConName :: Name

intTyCon :: TyCon

intTy :: Type

intDataCon_RDR :: RdrName

intDataCon :: DataCon

heqTyConName :: Name

heqDataCon :: DataCon

heqClass :: Class

floatTyConName :: Name

floatTyCon :: TyCon

floatTy :: Type

floatDataCon :: DataCon

filterCTuple :: RdrName -> RdrName

Replaces constraint tuple names with corresponding boxed ones.

false_RDR :: RdrName

falseDataConId :: Id

falseDataCon :: DataCon

eqTyCon_RDR :: RdrName

eqTyConName :: Name

eqTyCon :: TyCon

eqDataCon :: DataCon

eqClass :: Class

doubleTyConName :: Name

doubleTyCon :: TyCon

doubleTy :: Type

doubleDataCon :: DataCon

constraintKindTyConName :: Name

constraintKindTyCon :: TyCon

consDataCon_RDR :: RdrName

consDataConName :: Name

consDataCon :: DataCon

coercibleTyConName :: Name

coercibleDataCon :: DataCon

coercibleClass :: Class

charTyCon_RDR :: RdrName

charTyConName :: Name

charTyCon :: TyCon

charDataCon :: DataCon

cTupleTyConNames :: [Name]

cTupleTyConNameArity_maybe :: Name -> Maybe Arity

If the given name is that of a constraint tuple, return its arity.

cTupleTyCon :: Arity -> TyCon

cTupleSelId :: ConTag -> Arity -> Id

cTupleDataConNames :: [Name]

boxingDataCon_maybe :: TyCon -> Maybe DataCon

boolTyCon_RDR :: RdrName

boolTyConName :: Name

boolTyCon :: TyCon

boolTy :: Type

anyTyCon :: TyCon

anyTy :: Type

zapStableUnfolding :: Id -> Id

zapLamIdInfo :: Id -> Id

zapJoinId :: Id -> Id

zapIdUsedOnceInfo :: Id -> Id

zapIdUsageInfo :: Id -> Id

zapIdUsageEnvInfo :: Id -> Id

zapIdTailCallInfo :: Id -> Id

zapIdStrictness :: Id -> Id

zapIdOccInfo :: Id -> Id

zapIdDemandInfo :: Id -> Id

zapFragileIdInfo :: Id -> Id

updOneShotInfo :: Id -> OneShotInfo -> Id

typeOneShot :: Type -> OneShotInfo

transferPolyIdInfo :: Id -> [Var] -> Id -> Id

stateHackOneShot :: OneShotInfo

Should we apply the state hack to values of this Type?

setOneShotLambda :: Id -> Id

setInlinePragma :: Id -> InlinePragma -> Id infixl 1

setInlineActivation :: Id -> Activation -> Id infixl 1

setIdUnique :: Id -> Unique -> Id

setIdUnfolding :: Id -> Unfolding -> Id infixl 1

setIdType :: Id -> Type -> Id

Not only does this set the Id Type, it also evaluates the type to try and reduce space usage

setIdStrictness :: Id -> StrictSig -> Id infixl 1

setIdSpecialisation :: Id -> RuleInfo -> Id infixl 1

setIdOneShotInfo :: Id -> OneShotInfo -> Id infixl 1

setIdOccInfo :: Id -> OccInfo -> Id infixl 1

setIdNotExported :: Id -> Id

setIdName :: Id -> Name -> Id

setIdLFInfo :: Id -> LambdaFormInfo -> Id

setIdInfo :: Id -> IdInfo -> Id

setIdExported :: Id -> Id

setIdDemandInfo :: Id -> Demand -> Id infixl 1

setIdCprInfo :: Id -> CprSig -> Id infixl 1

setIdCallArity :: Id -> Arity -> Id infixl 1

setIdCafInfo :: Id -> CafInfo -> Id

setIdArity :: Id -> Arity -> Id infixl 1

setCaseBndrEvald :: StrictnessMark -> Id -> Id

scaleVarBy :: Mult -> Var -> Var

Like scaleIdBy, but skips non-Ids. Useful for scaling a mixed list of ids and tyvars.

scaleIdBy :: Mult -> Id -> Id

recordSelectorTyCon_maybe :: Id -> Maybe RecSelParent

recordSelectorTyCon :: Id -> RecSelParent

If the Id is that for a record selector, extract the sel_tycon. Panic otherwise.

realIdUnfolding :: Id -> Unfolding

modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id

modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id

mkWorkerId :: Unique -> Id -> Type -> Id

Workers get local names. CoreTidy will externalise these if necessary

mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id

Make a global Id with no global information but some generic IdInfo

mkVanillaGlobal :: Name -> Type -> Id

Make a global Id without any extra information at all

mkUserLocalOrCoVar :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id

Like mkUserLocal, but checks if we have a coercion type

mkUserLocal :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id

Create a user local Id. These are local Ids (see GHC.Types.Var) with a name and location that the user might recognize

mkTemplateLocalsNum :: Int -> [Type] -> [Id]

Create a template local for a series of type, but start from a specified template local

mkTemplateLocals :: [Type] -> [Id]

Create a template local for a series of types

mkTemplateLocal :: Int -> Type -> Id

Create a template local: a family of system local Ids in bijection with Ints, typically used in unfoldings

mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Mult -> Type -> m Id

mkSysLocalOrCoVar :: FastString -> Unique -> Mult -> Type -> Id

Like mkSysLocal, but checks to see if we have a covar type

mkSysLocalM :: MonadUnique m => FastString -> Mult -> Type -> m Id

mkSysLocal :: FastString -> Unique -> Mult -> Type -> Id

Create a system local Id. These are local Ids (see Var) that are created by the compiler out of thin air

mkScaledTemplateLocal :: Int -> Scaled Type -> Id

mkLocalIdWithInfo :: HasDebugCallStack => Name -> Mult -> Type -> IdInfo -> Id

mkLocalIdOrCoVar :: Name -> Mult -> Type -> Id

Like mkLocalId, but checks the type to see if it should make a covar

mkLocalId :: HasDebugCallStack => Name -> Mult -> Type -> Id

For an explanation of global vs. local Ids, see GHC.Types.Var

mkLocalCoVar :: Name -> Type -> CoVar

Make a local CoVar

mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id

For an explanation of global vs. local Ids, see GHC.Types.Var.Var

mkExportedVanillaId :: Name -> Type -> Id

mkExportedLocalId :: IdDetails -> Name -> Type -> Id

Create a local Id that is marked as exported. This prevents things attached to it from being removed as dead code. See Note [Exported LocalIds]

maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id

localiseId :: Id -> Id

lazySetIdInfo :: Id -> IdInfo -> Id

isStrictId :: Id -> Bool

This predicate says whether the Id has a strict demand placed on it or has a type such that it can always be evaluated strictly (i.e an unlifted type, as of GHC 7.6). We need to check separately whether the Id has a so-called "strict type" because if the demand for the given id hasn't been computed yet but id has a strict type, we still want isStrictId id to be True.

isStateHackType :: Type -> Bool

isRecordSelector :: Id -> Bool

isProbablyOneShotLambda :: Id -> Bool

isPrimOpId_maybe :: Id -> Maybe PrimOp

isPrimOpId :: Id -> Bool

isPatSynRecordSelector :: Id -> Bool

isOneShotBndr :: Var -> Bool

Returns whether the lambda associated with the Id is certainly applied at most once This one is the "business end", called externally. It works on type variables as well as Ids, returning True Its main purpose is to encapsulate the Horrible State Hack See Note [The state-transformer hack] in GHC.Core.Opt.Arity

isNeverLevPolyId :: Id -> Bool

isNaughtyRecordSelector :: Id -> Bool

isJoinId_maybe :: Var -> Maybe JoinArity

isJoinId :: Var -> Bool

isImplicitId :: Id -> Bool

isImplicitId tells whether an Ids info is implied by other declarations, so we don't need to put its signature in an interface file, even if it's mentioned in some other interface unfolding.

isFCallId_maybe :: Id -> Maybe ForeignCall

isFCallId :: Id -> Bool

isDeadEndId :: Var -> Bool

Returns true if an application to n args diverges or throws an exception See Note [Dead ends] in GHC.Types.Demand.

isDeadBinder :: Id -> Bool

isDataConWrapId_maybe :: Id -> Maybe DataCon

isDataConWrapId :: Id -> Bool

isDataConWorkId_maybe :: Id -> Maybe DataCon

isDataConWorkId :: Id -> Bool

isDataConRecordSelector :: Id -> Bool

isDataConId_maybe :: Id -> Maybe DataCon

isDFunId :: Id -> Bool

isConLikeId :: Id -> Bool

isClassOpId_maybe :: Id -> Maybe Class

isClassOpId :: Id -> Bool

idUnique :: Id -> Unique

idUnfolding :: Id -> Unfolding

idType :: Id -> Kind

idStrictness :: Id -> StrictSig

Accesses the Id's strictnessInfo.

idStateHackOneShotInfo :: Id -> OneShotInfo

Like idOneShotInfo, but taking the Horrible State Hack in to account See Note [The state-transformer hack] in GHC.Core.Opt.Arity

idSpecialisation :: Id -> RuleInfo

idScaledType :: Id -> Scaled Type

idRuleMatchInfo :: Id -> RuleMatchInfo

idOneShotInfo :: Id -> OneShotInfo

idOccInfo :: Id -> OccInfo

idMult :: Id -> Mult

idLFInfo_maybe :: Id -> Maybe LambdaFormInfo

idJoinArity :: JoinId -> JoinArity

idIsFrom :: Module -> Id -> Bool

idInlinePragma :: Id -> InlinePragma

idInlineActivation :: Id -> Activation

idHasRules :: Id -> Bool

idFunRepArity :: Id -> RepArity

idDemandInfo :: Id -> Demand

idDataCon :: Id -> DataCon

Get from either the worker or the wrapper Id to the DataCon. Currently used only in the desugarer.

INVARIANT: idDataCon (dataConWrapId d) = d: remember, dataConWrapId can return either the wrapper or the worker

idCprInfo :: Id -> CprSig

idCoreRules :: Id -> [CoreRule]

idCallArity :: Id -> Arity

idCafInfo :: Id -> CafInfo infixl 1

idArity :: Id -> Arity

hasNoBinding :: Id -> Bool

Returns True of an Id which may not have a binding, even though it is defined in this module.

clearOneShotLambda :: Id -> Id

asJoinId_maybe :: Id -> Maybe JoinArity -> Id infixl 1

asJoinId :: Id -> JoinArity -> JoinId infixl 1

type family SyntaxExpr p

Syntax Expression

SyntaxExpr is represents the function used in interpreting rebindable syntax. In the parser, we have no information to supply; in the renamer, we have the name of the function (but see Note [Monad fail : Rebindable syntax, overloaded strings] for a wrinkle) and in the type-checker we have a more elaborate structure SyntaxExprTc.

In some contexts, rebindable syntax is not implemented, and so we have constructors to represent that possibility in both the renamer and typechecker instantiations.

E.g. (>>=) is filled in before the renamer by the appropriate Name for (>>=), and then instantiated by the type checker with its type args etc

Instances

type SyntaxExpr (GhcPass p)

Defined in GHC.Hs.Expr

type SyntaxExpr (GhcPass p) = SyntaxExprGhc p

data MatchGroup p body

Constructors

MG

Fields

• mg_ext :: XMG p body
• mg_alts :: XRec p [LMatch p body]
• mg_origin :: Origin

XMatchGroup !(XXMatchGroup p body)

type LHsExpr p

Arguments

 = XRec p (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Expression

data HsSplice id

Haskell Splice

Constructors

HsTypedSplice (XTypedSplice id) SpliceDecoration (IdP id) (LHsExpr id)

HsUntypedSplice (XUntypedSplice id) SpliceDecoration (IdP id) (LHsExpr id)

HsQuasiQuote (XQuasiQuote id) (IdP id) (IdP id) SrcSpan FastString

HsSpliced (XSpliced id) ThModFinalizers (HsSplicedThing id)

XSplice !(XXSplice id)

Instances

type Anno (HsSplice (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsSplice (GhcPass p)) = SrcSpanAnnA

data HsExpr p

A Haskell expression.

Constructors

HsVar (XVar p) (LIdP p)

Variable See Note [Located RdrNames]

HsUnboundVar (XUnboundVar p) OccName

Unbound variable; also used for "holes" (_ or _x). Turned from HsVar to HsUnboundVar by the renamer, when it finds an out-of-scope variable or hole. The (XUnboundVar p) field becomes an HoleExprRef after typechecking; this is where the erroring expression will be written after solving. See Note [Holes] in GHC.Tc.Types.Constraint.

HsConLikeOut (XConLikeOut p) ConLike

After typechecker only; must be different HsVar for pretty printing

HsRecFld (XRecFld p) (AmbiguousFieldOcc p)

Variable pointing to record selector The parser produces HsVars The renamer renames record-field selectors to HsRecFld The typechecker preserves HsRecFld

HsOverLabel (XOverLabel p) FastString

Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels)

HsIPVar (XIPVar p) HsIPName

Implicit parameter (not in use after typechecking)

HsOverLit (XOverLitE p) (HsOverLit p)

Overloaded literals

HsLit (XLitE p) (HsLit p)

Simple (non-overloaded) literals

HsLam (XLam p) (MatchGroup p (LHsExpr p))

Lambda abstraction. Currently always a single match

• AnnKeywordId : AnnLam, AnnRarrow,

HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p))

Lambda-case

• AnnKeywordId : AnnLam, AnnCase,AnnOpen, AnnClose

HsApp (XApp p) (LHsExpr p) (LHsExpr p)

Application

HsAppType (XAppTypeE p) (LHsExpr p) (LHsWcType (NoGhcTc p))

Visible type application

Explicit type argument; e.g f @Int x y NB: Has wildcards, but no implicit quantification

• AnnKeywordId : AnnAt,

OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)

Operator applications: NB Bracketed ops such as (+) come out as Vars.

NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)

Negation operator. Contains the negated expression and the name of negate

• AnnKeywordId : AnnMinus

HsPar

• AnnKeywordId : AnnOpen '(', AnnClose ')'

Fields

• (XPar p)
• (LHsExpr p)

  Parenthesised expr; see Note [Parens in HsSyn]

SectionL (XSectionL p) (LHsExpr p) (LHsExpr p)

SectionR (XSectionR p) (LHsExpr p) (LHsExpr p)

ExplicitTuple (XExplicitTuple p) [HsTupArg p] Boxity

Used for explicit tuples and sections thereof

• AnnKeywordId : AnnOpen, AnnClose

ExplicitSum (XExplicitSum p) ConTag Arity (LHsExpr p)

Used for unboxed sum types

• AnnKeywordId : AnnOpen '(#', AnnVbar, AnnClose '#)',

There will be multiple AnnVbar, (1 - alternative) before the expression, (arity - alternative) after it

HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))

• AnnKeywordId : AnnCase, AnnOf,AnnOpen '{', AnnClose '}'

HsIf (XIf p) (LHsExpr p) (LHsExpr p) (LHsExpr p)

• AnnKeywordId : AnnIf, AnnSemi, AnnThen,AnnSemi, AnnElse,

HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]

Multi-way if

• AnnKeywordId : AnnIf AnnOpen,AnnClose,

HsLet (XLet p) (HsLocalBinds p) (LHsExpr p)

let(rec)

• AnnKeywordId : AnnLet, AnnOpen '{', AnnClose '}',AnnIn

HsDo (XDo p) (HsStmtContext (HsDoRn p)) (XRec p [ExprLStmt p])

• AnnKeywordId : AnnDo, AnnOpen, AnnSemi, AnnVbar, AnnClose

ExplicitList (XExplicitList p) [LHsExpr p]

Syntactic list: [a,b,c,...]

• AnnKeywordId : AnnOpen '[', AnnClose ']'

RecordCon

Record construction

• AnnKeywordId : AnnOpen '{', AnnDotdot,AnnClose '}'

Fields

• rcon_ext :: XRecordCon p
• rcon_con :: XRec p (ConLikeP p)
• rcon_flds :: HsRecordBinds p

RecordUpd

Record update

• AnnKeywordId : AnnOpen '{', AnnDotdot,AnnClose '}' 'GHC.Parser.Annotation.AnnComma, AnnDot, AnnClose '}'

Fields

• rupd_ext :: XRecordUpd p
• rupd_expr :: LHsExpr p
• rupd_flds :: Either [LHsRecUpdField p] [LHsRecUpdProj p]

HsGetField

Record field selection e.g z.x.

• AnnKeywordId : AnnDot

This case only arises when the OverloadedRecordDot langauge extension is enabled.

Fields

• gf_ext :: XGetField p
• gf_expr :: LHsExpr p
• gf_field :: Located (HsFieldLabel p)

HsProjection

Record field selector. e.g. (.x) or (.x.y)

• AnnKeywordId : AnnOpenP AnnDot, AnnCloseP

This case only arises when the OverloadedRecordDot langauge extensions is enabled.

Fields

• proj_ext :: XProjection p
• proj_flds :: NonEmpty (Located (HsFieldLabel p))

ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))

Expression with an explicit type signature. e :: type

• AnnKeywordId : AnnDcolon

ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)

Arithmetic sequence

• AnnKeywordId : AnnOpen '[', AnnComma,AnnDotdot, AnnClose ']'

HsBracket (XBracket p) (HsBracket p)

• AnnKeywordId : AnnOpen, AnnOpenE,AnnOpenEQ, AnnClose,AnnCloseQ

HsRnBracketOut (XRnBracketOut p) (HsBracket (HsBracketRn p)) [PendingRnSplice' p]

HsTcBracketOut (XTcBracketOut p) (Maybe QuoteWrapper) (HsBracket (HsBracketRn p)) [PendingTcSplice' p]

HsSpliceE (XSpliceE p) (HsSplice p)

• AnnKeywordId : AnnOpen, AnnClose

HsProc (XProc p) (LPat p) (LHsCmdTop p)

proc notation for Arrows

• AnnKeywordId : AnnProc, AnnRarrow

HsStatic (XStatic p) (LHsExpr p)

• AnnKeywordId : AnnStatic,

HsTick (XTick p) CoreTickish (LHsExpr p)

HsBinTick (XBinTick p) Int Int (LHsExpr p)

HsPragE (XPragE p) (HsPragE p) (LHsExpr p)

XExpr !(XXExpr p)

Instances

DisambECP (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsExpr GhcPs) :: Type -> Type

type InfixOp (HsExpr GhcPs)

type FunArg (HsExpr GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsExpr GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsExpr GhcPs))

mkHsProjUpdatePV :: SrcSpan -> Located [Located (HsFieldLabel GhcPs)] -> LocatedA (HsExpr GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsExpr GhcPs)))

mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs))

mkHsLetPV :: SrcSpan -> HsLocalBinds GhcPs -> LocatedA (HsExpr GhcPs) -> AnnsLet -> PV (LocatedA (HsExpr GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs))

mkHsOpAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> LocatedN (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsExpr GhcPs))

mkHsLamCasePV :: SrcSpan -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

superFunArg :: (DisambECP (FunArg (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs))

mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LocatedA (FunArg (HsExpr GhcPs)) -> PV (LocatedA (HsExpr GhcPs))

mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (HsExpr GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsExpr GhcPs) -> Bool -> LocatedA (HsExpr GhcPs) -> AnnsIf -> PV (LocatedA (HsExpr GhcPs))

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsExpr GhcPs))] -> AnnList -> PV (LocatedA (HsExpr GhcPs))

mkHsParPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> AnnParen -> PV (LocatedA (HsExpr GhcPs))

mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsExpr GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr GhcPs))

mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsExpr GhcPs)] -> AnnList -> PV (LocatedA (HsExpr GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsExpr GhcPs) -> ([Fbind (HsExpr GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsNegAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsLazyPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkHsBangPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs))

rejectPragmaPV :: LocatedA (HsExpr GhcPs) -> PV ()

DisambInfixOp (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

Methods

mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs))

mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs))

mkHsInfixHolePV :: SrcSpan -> (EpAnnComments -> EpAnn EpAnnUnboundVar) -> PV (Located (HsExpr GhcPs))

type Body (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

type Body (HsExpr GhcPs) = HsExpr

type FunArg (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

type FunArg (HsExpr GhcPs) = HsExpr GhcPs

type InfixOp (HsExpr GhcPs)

Defined in GHC.Parser.PostProcess

type InfixOp (HsExpr GhcPs) = HsExpr GhcPs

type Anno (HsExpr (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsExpr (GhcPass p)) = SrcSpanAnnA

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpan

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p)))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

data GRHSs p body

Guarded Right-Hand Sides

GRHSs are used both for pattern bindings and for Matches

• AnnKeywordId : AnnVbar, AnnEqual,AnnWhere, AnnOpen,AnnClose AnnRarrow,AnnSemi

Constructors

GRHSs

Fields

• grhssExt :: XCGRHSs p body
• grhssGRHSs :: [LGRHS p body]

  Guarded RHSs

• grhssLocalBinds :: HsLocalBinds p

  The where clause

XGRHSs !(XXGRHSs p body)

type family XXWarnDecls x

Instances

type XXWarnDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XXWarnDecls (GhcPass _1) = NoExtCon

type family XXWarnDecl x

Instances

type XXWarnDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXWarnDecl (GhcPass _1) = NoExtCon

type family XXValBindsLR x x'

Instances

type XXValBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)

type family XXType x

Instances

type XXType (GhcPass _1)

Defined in GHC.Hs.Type

type XXType (GhcPass _1) = HsCoreTy

type family XXTyVarBndr x

Instances

type XXTyVarBndr (GhcPass _1)

Defined in GHC.Hs.Type

type XXTyVarBndr (GhcPass _1) = NoExtCon

type family XXTyFamInstDecl x

Instances

type XXTyFamInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyFamInstDecl (GhcPass _1) = NoExtCon

type family XXTyClGroup x

Instances

type XXTyClGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyClGroup (GhcPass _1) = NoExtCon

type family XXTyClDecl x

Instances

type XXTyClDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyClDecl (GhcPass _1) = NoExtCon

type family XXTupArg x

Instances

type XXTupArg (GhcPass _1)

Defined in GHC.Hs.Expr

type XXTupArg (GhcPass _1) = NoExtCon

type family XXStmtLR x x' b

Instances

type XXStmtLR (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExtCon

type family XXStandaloneKindSig x

Instances

type XXStandaloneKindSig (GhcPass p)

Defined in GHC.Hs.Decls

type XXStandaloneKindSig (GhcPass p) = NoExtCon

type family XXSpliceDecl x

Instances

type XXSpliceDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXSpliceDecl (GhcPass _1) = NoExtCon

type family XXSplice x

Instances

type XXSplice GhcPs

Defined in GHC.Hs.Expr

type XXSplice GhcPs = NoExtCon

type XXSplice GhcRn

Defined in GHC.Hs.Expr

type XXSplice GhcRn = NoExtCon

type XXSplice GhcTc

Defined in GHC.Hs.Expr

type XXSplice GhcTc = HsSplicedT

type family XXSig x

Instances

type XXSig (GhcPass p)

Defined in GHC.Hs.Binds

type XXSig (GhcPass p) = NoExtCon

type family XXRuleDecls x

Instances

type XXRuleDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleDecls (GhcPass _1) = NoExtCon

type family XXRuleDecl x

Instances

type XXRuleDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleDecl (GhcPass _1) = NoExtCon

type family XXRuleBndr x

Instances

type XXRuleBndr (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleBndr (GhcPass _1) = NoExtCon

type family XXRoleAnnotDecl x

Instances

type XXRoleAnnotDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRoleAnnotDecl (GhcPass _1) = NoExtCon

type family XXPragE x

Instances

type XXPragE (GhcPass _1)

Defined in GHC.Hs.Expr

type XXPragE (GhcPass _1) = NoExtCon

type family XXPatSynBind x x'

Instances

type XXPatSynBind (GhcPass idL) (GhcPass idR)

Defined in GHC.Hs.Binds

type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExtCon

type family XXPat x

Instances

type XXPat GhcPs

Defined in GHC.Hs.Pat

type XXPat GhcPs = NoExtCon

type XXPat GhcRn

Defined in GHC.Hs.Pat

type XXPat GhcRn = NoExtCon

type XXPat GhcTc

Defined in GHC.Hs.Pat

type XXPat GhcTc = CoPat

type family XXParStmtBlock x x'

Instances

type XXParStmtBlock (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Expr

type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon

type family XXOverLit x

Instances

type XXOverLit (GhcPass _1)

Defined in GHC.Hs.Lit

type XXOverLit (GhcPass _1) = NoExtCon

type family XXMatchGroup x b

Instances

type XXMatchGroup (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXMatchGroup (GhcPass _1) b = NoExtCon

type family XXMatch x b

Instances

type XXMatch (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXMatch (GhcPass _1) b = NoExtCon

type family XXLit x

Instances

type XXLit (GhcPass _1)

Defined in GHC.Hs.Lit

type XXLit (GhcPass _1) = NoExtCon

type family XXLHsQTyVars x

Instances

type XXLHsQTyVars (GhcPass _1)

Defined in GHC.Hs.Type

type XXLHsQTyVars (GhcPass _1) = NoExtCon

type family XXInstDecl x

Instances

type XXInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXInstDecl (GhcPass _1) = NoExtCon

type family XXInjectivityAnn x

Instances

type XXInjectivityAnn (GhcPass _1)

Defined in GHC.Hs.Decls

type XXInjectivityAnn (GhcPass _1) = NoExtCon

type family XXImportDecl x

Instances

type XXImportDecl (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XXImportDecl (GhcPass _1) = NoExtCon

type family XXIPBind x

Instances

type XXIPBind (GhcPass p)

Defined in GHC.Hs.Binds

type XXIPBind (GhcPass p) = NoExtCon

type family XXIE x

Instances

type XXIE (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XXIE (GhcPass _1) = NoExtCon

type family XXHsWildCardBndrs x b

Instances

type XXHsWildCardBndrs (GhcPass _1) _2

Defined in GHC.Hs.Type

type XXHsWildCardBndrs (GhcPass _1) _2 = NoExtCon

type family XXHsSigType x

Instances

type XXHsSigType (GhcPass _1)

Defined in GHC.Hs.Type

type XXHsSigType (GhcPass _1) = NoExtCon

type family XXHsPatSigType x

Instances

type XXHsPatSigType (GhcPass _1)

Defined in GHC.Hs.Type

type XXHsPatSigType (GhcPass _1) = NoExtCon

type family XXHsOuterTyVarBndrs x

Instances

type XXHsOuterTyVarBndrs (GhcPass _1)

Defined in GHC.Hs.Type

type XXHsOuterTyVarBndrs (GhcPass _1) = NoExtCon

type family XXHsLocalBindsLR x x'

Instances

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type family XXHsIPBinds x

Instances

type XXHsIPBinds (GhcPass p)

Defined in GHC.Hs.Binds

type XXHsIPBinds (GhcPass p) = NoExtCon

type family XXHsGroup x

Instances

type XXHsGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsGroup (GhcPass _1) = NoExtCon

type family XXHsForAllTelescope x

Instances

type XXHsForAllTelescope (GhcPass _1)

Defined in GHC.Hs.Type

type XXHsForAllTelescope (GhcPass _1) = NoExtCon

type family XXHsFieldLabel x

Instances

type XXHsFieldLabel (GhcPass _1)

Defined in GHC.Hs.Expr

type XXHsFieldLabel (GhcPass _1) = NoExtCon

type family XXHsDerivingClause x

Instances

type XXHsDerivingClause (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDerivingClause (GhcPass _1) = NoExtCon

type family XXHsDecl x

Instances

type XXHsDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDecl (GhcPass _1) = NoExtCon

type family XXHsDataDefn x

Instances

type XXHsDataDefn (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDataDefn (GhcPass _1) = NoExtCon

type family XXHsBindsLR x x'

Instances

type XXHsBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type family XXGRHSs x b

Instances

type XXGRHSs (GhcPass _1) _2

Defined in GHC.Hs.Expr

type XXGRHSs (GhcPass _1) _2 = NoExtCon

type family XXGRHS x b

Instances

type XXGRHS (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXGRHS (GhcPass _1) b = NoExtCon

type family XXFunDep x

Instances

type XXFunDep (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFunDep (GhcPass _1) = NoExtCon

type family XXForeignDecl x

Instances

type XXForeignDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXForeignDecl (GhcPass _1) = NoExtCon

type family XXFixitySig x

Instances

type XXFixitySig (GhcPass p)

Defined in GHC.Hs.Binds

type XXFixitySig (GhcPass p) = NoExtCon

type family XXFieldOcc x

Instances

type XXFieldOcc (GhcPass _1)

Defined in GHC.Hs.Type

type XXFieldOcc (GhcPass _1) = NoExtCon

type family XXFamilyResultSig x

Instances

type XXFamilyResultSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFamilyResultSig (GhcPass _1) = NoExtCon

type family XXFamilyDecl x

Instances

type XXFamilyDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFamilyDecl (GhcPass _1) = NoExtCon

type family XXFamEqn x r

Instances

type XXFamEqn (GhcPass _1) r

Defined in GHC.Hs.Decls

type XXFamEqn (GhcPass _1) r = NoExtCon

type family XXExpr x

Instances

type XXExpr GhcPs

Defined in GHC.Hs.Expr

type XXExpr GhcPs = NoExtCon

type XXExpr GhcRn

Defined in GHC.Hs.Expr

type XXExpr GhcRn = HsExpansion (HsExpr GhcRn) (HsExpr GhcRn)

type XXExpr GhcTc

Defined in GHC.Hs.Expr

type XXExpr GhcTc = XXExprGhcTc

type family XXDerivDecl x

Instances

type XXDerivDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDerivDecl (GhcPass _1) = NoExtCon

type family XXDerivClauseTys x

Instances

type XXDerivClauseTys (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDerivClauseTys (GhcPass _1) = NoExtCon

type family XXDefaultDecl x

Instances

type XXDefaultDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDefaultDecl (GhcPass _1) = NoExtCon

type family XXConDeclField x

Instances

type XXConDeclField (GhcPass _1)

Defined in GHC.Hs.Type

type XXConDeclField (GhcPass _1) = NoExtCon

type family XXConDecl x

Instances

type XXConDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXConDecl (GhcPass _1) = NoExtCon

type family XXCmdTop x

Instances

type XXCmdTop (GhcPass _1)

Defined in GHC.Hs.Expr

type XXCmdTop (GhcPass _1) = NoExtCon

type family XXCmd x

Instances

type XXCmd GhcPs

Defined in GHC.Hs.Expr

type XXCmd GhcPs = NoExtCon

type XXCmd GhcRn

Defined in GHC.Hs.Expr

type XXCmd GhcRn = NoExtCon

type XXCmd GhcTc

Defined in GHC.Hs.Expr

type XXCmd GhcTc = HsWrap HsCmd

type family XXClsInstDecl x

Instances

type XXClsInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXClsInstDecl (GhcPass _1) = NoExtCon

type family XXBracket x

Instances

type XXBracket (GhcPass _1)

Defined in GHC.Hs.Expr

type XXBracket (GhcPass _1) = NoExtCon

type family XXApplicativeArg x

Instances

type XXApplicativeArg (GhcPass _1)

Defined in GHC.Hs.Expr

type XXApplicativeArg (GhcPass _1) = NoExtCon

type family XXAnnDecl x

Instances

type XXAnnDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXAnnDecl (GhcPass _1) = NoExtCon

type family XXAmbiguousFieldOcc x

Instances

type XXAmbiguousFieldOcc (GhcPass _1)

Defined in GHC.Hs.Type

type XXAmbiguousFieldOcc (GhcPass _1) = NoExtCon

type family XXABExport x

Instances

type XXABExport (GhcPass p)

Defined in GHC.Hs.Binds

type XXABExport (GhcPass p) = NoExtCon

type family XWildPat x

Instances

type XWildPat GhcPs

Defined in GHC.Hs.Pat

type XWildPat GhcPs = NoExtField

type XWildPat GhcRn

Defined in GHC.Hs.Pat

type XWildPat GhcRn = NoExtField

type XWildPat GhcTc

Defined in GHC.Hs.Pat

type XWildPat GhcTc = Type

type family XWildCardTy x

Instances

type XWildCardTy (GhcPass _1)

Defined in GHC.Hs.Type

type XWildCardTy (GhcPass _1) = NoExtField

type family XWarnings x

Instances

type XWarnings GhcPs

Defined in GHC.Hs.Decls

type XWarnings GhcPs = EpAnn [AddEpAnn]

type XWarnings GhcRn

Defined in GHC.Hs.Decls

type XWarnings GhcRn = NoExtField

type XWarnings GhcTc

Defined in GHC.Hs.Decls

type XWarnings GhcTc = NoExtField

type family XWarningD x

Instances

type XWarningD (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarningD (GhcPass _1) = NoExtField

type family XWarning x

Instances

type XWarning (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarning (GhcPass _1) = EpAnn [AddEpAnn]

type family XViewPat x

Instances

type XViewPat GhcPs

Defined in GHC.Hs.Pat

type XViewPat GhcPs = EpAnn [AddEpAnn]

type XViewPat GhcRn

Defined in GHC.Hs.Pat

type XViewPat GhcRn = NoExtField

type XViewPat GhcTc

Defined in GHC.Hs.Pat

type XViewPat GhcTc = Type

type family XViaStrategy x

Instances

type XViaStrategy GhcPs

Defined in GHC.Hs.Decls

type XViaStrategy GhcPs = XViaStrategyPs

type XViaStrategy GhcRn

Defined in GHC.Hs.Decls

type XViaStrategy GhcRn = LHsSigType GhcRn

type XViaStrategy GhcTc

Defined in GHC.Hs.Decls

type XViaStrategy GhcTc = Type

type family XVarPat x

Instances

type XVarPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XVarPat (GhcPass _1) = NoExtField

type family XVarBr x

Instances

type XVarBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XVarBr (GhcPass _1) = NoExtField

type family XVarBind x x'

Instances

type XVarBind (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField

type family XVar x

Instances

type XVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XVar (GhcPass _1) = NoExtField

type XVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XVar (GhcPass _1) = NoExtField

type family XValD x

Instances

type XValD (GhcPass _1)

Defined in GHC.Hs.Decls

type XValD (GhcPass _1) = NoExtField

type family XValBinds x x'

Instances

type XValBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XValBinds (GhcPass pL) (GhcPass pR) = AnnSortKey

type family XUserTyVar x

Instances

type XUserTyVar (GhcPass _1)

Defined in GHC.Hs.Type

type XUserTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type family XUntypedSplice x

Instances

type XUntypedSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XUntypedSplice (GhcPass _1) = EpAnn [AddEpAnn]

type family XUnboundVar x

Instances

type XUnboundVar GhcPs

Defined in GHC.Hs.Expr

type XUnboundVar GhcPs = EpAnn EpAnnUnboundVar

type XUnboundVar GhcRn

Defined in GHC.Hs.Expr

type XUnboundVar GhcRn = NoExtField

type XUnboundVar GhcTc

Defined in GHC.Hs.Expr

type XUnboundVar GhcTc = HoleExprRef

type family XUnambiguous x

Instances

type XUnambiguous GhcPs

Defined in GHC.Hs.Type

type XUnambiguous GhcPs = NoExtField

type XUnambiguous GhcRn

Defined in GHC.Hs.Type

type XUnambiguous GhcRn = Name

type XUnambiguous GhcTc

Defined in GHC.Hs.Type

type XUnambiguous GhcTc = Id

type family XTypedSplice x

Instances

type XTypedSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XTypedSplice (GhcPass _1) = EpAnn [AddEpAnn]

type family XTypeSig x

Instances

type XTypeSig (GhcPass p)

Defined in GHC.Hs.Binds

type XTypeSig (GhcPass p) = EpAnn AnnSig

type family XTypBr x

Instances

type XTypBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XTypBr (GhcPass _1) = NoExtField

type family XTyVarSig x

Instances

type XTyVarSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyVarSig (GhcPass _1) = NoExtField

type family XTyVar x

Instances

type XTyVar (GhcPass _1)

Defined in GHC.Hs.Type

type XTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type family XTyLit x

Instances

type XTyLit (GhcPass _1)

Defined in GHC.Hs.Type

type XTyLit (GhcPass _1) = NoExtField

type family XTyFamInstD x

Instances

type XTyFamInstD GhcPs

Defined in GHC.Hs.Decls

type XTyFamInstD GhcPs = NoExtField

type XTyFamInstD GhcRn

Defined in GHC.Hs.Decls

type XTyFamInstD GhcRn = NoExtField

type XTyFamInstD GhcTc

Defined in GHC.Hs.Decls

type XTyFamInstD GhcTc = NoExtField

type family XTyClD x

Instances

type XTyClD (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyClD (GhcPass _1) = NoExtField

type family XTupleTy x

Instances

type XTupleTy (GhcPass _1)

Defined in GHC.Hs.Type

type XTupleTy (GhcPass _1) = EpAnn AnnParen

type family XTuplePat x

Instances

type XTuplePat GhcPs

Defined in GHC.Hs.Pat

type XTuplePat GhcPs = EpAnn [AddEpAnn]

type XTuplePat GhcRn

Defined in GHC.Hs.Pat

type XTuplePat GhcRn = NoExtField

type XTuplePat GhcTc

Defined in GHC.Hs.Pat

type XTuplePat GhcTc = [Type]

type family XTransStmt x x' b

Instances

type XTransStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcPs b = EpAnn [AddEpAnn]

type XTransStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcRn b = NoExtField

type XTransStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcTc b = Type

type family XTick x

Instances

type XTick (GhcPass _1)

Defined in GHC.Hs.Expr

type XTick (GhcPass _1) = NoExtField

type family XTcBracketOut x

Instances

type XTcBracketOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XTcBracketOut (GhcPass _1) = NoExtField

type family XTExpBr x

Instances

type XTExpBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XTExpBr (GhcPass _1) = NoExtField

type family XSynDecl x

Instances

type XSynDecl GhcPs

Defined in GHC.Hs.Decls

type XSynDecl GhcPs = EpAnn [AddEpAnn]

type XSynDecl GhcRn

Defined in GHC.Hs.Decls

type XSynDecl GhcRn = NameSet

type XSynDecl GhcTc

Defined in GHC.Hs.Decls

type XSynDecl GhcTc = NameSet

type family XSumTy x

Instances

type XSumTy (GhcPass _1)

Defined in GHC.Hs.Type

type XSumTy (GhcPass _1) = EpAnn AnnParen

type family XSumPat x

Instances

type XSumPat GhcPs

Defined in GHC.Hs.Pat

type XSumPat GhcPs = EpAnn EpAnnSumPat

type XSumPat GhcRn

Defined in GHC.Hs.Pat

type XSumPat GhcRn = NoExtField

type XSumPat GhcTc

Defined in GHC.Hs.Pat

type XSumPat GhcTc = [Type]

type family XStockStrategy x

Instances

type XStockStrategy GhcPs

Defined in GHC.Hs.Decls

type XStockStrategy GhcPs = EpAnn [AddEpAnn]

type XStockStrategy GhcRn

Defined in GHC.Hs.Decls

type XStockStrategy GhcRn = NoExtField

type XStockStrategy GhcTc

Defined in GHC.Hs.Decls

type XStockStrategy GhcTc = NoExtField

type family XStatic x

Instances

type XStatic GhcPs

Defined in GHC.Hs.Expr

type XStatic GhcPs = EpAnn [AddEpAnn]

type XStatic GhcRn

Defined in GHC.Hs.Expr

type XStatic GhcRn = NameSet

type XStatic GhcTc

Defined in GHC.Hs.Expr

type XStatic GhcTc = NameSet

type family XStarTy x

Instances

type XStarTy (GhcPass _1)

Defined in GHC.Hs.Type

type XStarTy (GhcPass _1) = NoExtField

type family XStandaloneKindSig x

Instances

type XStandaloneKindSig GhcPs

Defined in GHC.Hs.Decls

type XStandaloneKindSig GhcPs = EpAnn [AddEpAnn]

type XStandaloneKindSig GhcRn

Defined in GHC.Hs.Decls

type XStandaloneKindSig GhcRn = NoExtField

type XStandaloneKindSig GhcTc

Defined in GHC.Hs.Decls

type XStandaloneKindSig GhcTc = NoExtField

type family XSpliced x

Instances

type XSpliced (GhcPass _1)

Defined in GHC.Hs.Expr

type XSpliced (GhcPass _1) = NoExtField

type family XSpliceTy x

Instances

type XSpliceTy GhcPs

Defined in GHC.Hs.Type

type XSpliceTy GhcPs = NoExtField

type XSpliceTy GhcRn

Defined in GHC.Hs.Type

type XSpliceTy GhcRn = NoExtField

type XSpliceTy GhcTc

Defined in GHC.Hs.Type

type XSpliceTy GhcTc = Kind

type family XSplicePat x

Instances

type XSplicePat (GhcPass _1)

Defined in GHC.Hs.Pat

type XSplicePat (GhcPass _1) = NoExtField

type family XSpliceE x

Instances

type XSpliceE (GhcPass _1)

Defined in GHC.Hs.Expr

type XSpliceE (GhcPass _1) = EpAnnCO

type family XSpliceDecl x

Instances

type XSpliceDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XSpliceDecl (GhcPass _1) = NoExtField

type family XSpliceD x

Instances

type XSpliceD (GhcPass _1)

Defined in GHC.Hs.Decls

type XSpliceD (GhcPass _1) = NoExtField

type family XSpecSig x

Instances

type XSpecSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSpecSig (GhcPass p) = EpAnn [AddEpAnn]

type family XSpecInstSig x

Instances

type XSpecInstSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSpecInstSig (GhcPass p) = EpAnn [AddEpAnn]

type family XSigPat x

Instances

type XSigPat GhcPs

Defined in GHC.Hs.Pat

type XSigPat GhcPs = EpAnn [AddEpAnn]

type XSigPat GhcRn

Defined in GHC.Hs.Pat

type XSigPat GhcRn = NoExtField

type XSigPat GhcTc

Defined in GHC.Hs.Pat

type XSigPat GhcTc = Type

type family XSigD x

Instances

type XSigD (GhcPass _1)

Defined in GHC.Hs.Decls

type XSigD (GhcPass _1) = NoExtField

type family XSectionR x

Instances

type XSectionR GhcPs

Defined in GHC.Hs.Expr

type XSectionR GhcPs = EpAnnCO

type XSectionR GhcRn

Defined in GHC.Hs.Expr

type XSectionR GhcRn = EpAnnCO

type XSectionR GhcTc

Defined in GHC.Hs.Expr

type XSectionR GhcTc = Void

type family XSectionL x

Instances

type XSectionL GhcPs

Defined in GHC.Hs.Expr

type XSectionL GhcPs = EpAnnCO

type XSectionL GhcRn

Defined in GHC.Hs.Expr

type XSectionL GhcRn = EpAnnCO

type XSectionL GhcTc

Defined in GHC.Hs.Expr

type XSectionL GhcTc = Void

type family XSCCFunSig x

Instances

type XSCCFunSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSCCFunSig (GhcPass p) = EpAnn [AddEpAnn]

type family XSCC x

Instances

type XSCC (GhcPass _1)

Defined in GHC.Hs.Expr

type XSCC (GhcPass _1) = EpAnn AnnPragma

type family XRuleD x

Instances

type XRuleD (GhcPass _1)

Defined in GHC.Hs.Decls

type XRuleD (GhcPass _1) = NoExtField

type family XRuleBndrSig x

Instances

type XRuleBndrSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XRuleBndrSig (GhcPass _1) = EpAnn [AddEpAnn]

type family XRoleAnnotD x

Instances

type XRoleAnnotD (GhcPass _1)

Defined in GHC.Hs.Decls

type XRoleAnnotD (GhcPass _1) = NoExtField

type family XRnBracketOut x

Instances

type XRnBracketOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XRnBracketOut (GhcPass _1) = NoExtField

type family XRecordUpd x

Instances

type XRecordUpd GhcPs

Defined in GHC.Hs.Expr

type XRecordUpd GhcPs = EpAnn [AddEpAnn]

type XRecordUpd GhcRn

Defined in GHC.Hs.Expr

type XRecordUpd GhcRn = NoExtField

type XRecordUpd GhcTc

Defined in GHC.Hs.Expr

type XRecordUpd GhcTc = RecordUpdTc

type family XRecordCon x

Instances

type XRecordCon GhcPs

Defined in GHC.Hs.Expr

type XRecordCon GhcPs = EpAnn [AddEpAnn]

type XRecordCon GhcRn

Defined in GHC.Hs.Expr

type XRecordCon GhcRn = NoExtField

type XRecordCon GhcTc

Defined in GHC.Hs.Expr

type XRecordCon GhcTc = PostTcExpr

type family XRecTy x

Instances

type XRecTy GhcPs

Defined in GHC.Hs.Type

type XRecTy GhcPs = EpAnn AnnList

type XRecTy GhcRn

Defined in GHC.Hs.Type

type XRecTy GhcRn = NoExtField

type XRecTy GhcTc

Defined in GHC.Hs.Type

type XRecTy GhcTc = NoExtField

type family XRecStmt x x' b

Instances

type XRecStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcPs b = EpAnn AnnList

type XRecStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcRn b = NoExtField

type XRecStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc

type family XRecFld x

Instances

type XRecFld (GhcPass _1)

Defined in GHC.Hs.Expr

type XRecFld (GhcPass _1) = NoExtField

type XRecFld (GhcPass _1)

Defined in GHC.Hs.Expr

type XRecFld (GhcPass _1) = NoExtField

type family XRec p a = (r :: Type) | r -> a

GHC's L prefixed variants wrap their vanilla variant in this type family, to add SrcLoc info via Located. Other passes than GhcPass not interested in location information can define this as type instance XRec NoLocated a = a. See Note [XRec and SrcSpans in the AST]

Instances

type XRec (GhcPass p) a

Defined in GHC.Hs.Extension

type XRec (GhcPass p) a = GenLocated (Anno a) a

type family XQuasiQuote x

Instances

type XQuasiQuote (GhcPass _1)

Defined in GHC.Hs.Expr

type XQuasiQuote (GhcPass _1) = NoExtField

type family XQualTy x

Instances

type XQualTy (GhcPass _1)

Defined in GHC.Hs.Type

type XQualTy (GhcPass _1) = NoExtField

type family XProjection x

Instances

type XProjection GhcPs

Defined in GHC.Hs.Expr

type XProjection GhcPs = EpAnn AnnProjection

type XProjection GhcRn

Defined in GHC.Hs.Expr

type XProjection GhcRn = NoExtField

type XProjection GhcTc

Defined in GHC.Hs.Expr

type XProjection GhcTc = Void

type family XProc x

Instances

type XProc (GhcPass _1)

Defined in GHC.Hs.Expr

type XProc (GhcPass _1) = EpAnn [AddEpAnn]

type family XPresent x

Instances

type XPresent (GhcPass _1)

Defined in GHC.Hs.Expr

type XPresent (GhcPass _1) = EpAnn [AddEpAnn]

type family XPragE x

Instances

type XPragE (GhcPass _1)

Defined in GHC.Hs.Expr

type XPragE (GhcPass _1) = NoExtField

type family XPatSynSig x

Instances

type XPatSynSig (GhcPass p)

Defined in GHC.Hs.Binds

type XPatSynSig (GhcPass p) = EpAnn AnnSig

type family XPatSynBind x x'

Instances

type XPatSynBind (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField

type family XPatBr x

Instances

type XPatBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XPatBr (GhcPass _1) = NoExtField

type family XPatBind x x'

Instances

type XPatBind GhcPs (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcPs (GhcPass pR) = EpAnn [AddEpAnn]

type XPatBind GhcRn (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcRn (GhcPass pR) = NameSet

type XPatBind GhcTc (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcTc (GhcPass pR) = Type

type family XParTy x

Instances

type XParTy (GhcPass _1)

Defined in GHC.Hs.Type

type XParTy (GhcPass _1) = EpAnn AnnParen

type family XParStmtBlock x x'

Instances

type XParStmtBlock (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Expr

type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField

type family XParStmt x x' b

Instances

type XParStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcPs b = NoExtField

type XParStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcRn b = NoExtField

type XParStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcTc b = Type

type family XParPat x

Instances

type XParPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XParPat (GhcPass _1) = EpAnn AnnParen

type family XPar x

Instances

type XPar (GhcPass _1)

Defined in GHC.Hs.Expr

type XPar (GhcPass _1) = EpAnn AnnParen

type family XPSB x x'

Instances

type XPSB (GhcPass idL) GhcPs

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcPs = EpAnn [AddEpAnn]

type XPSB (GhcPass idL) GhcRn

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcRn = NameSet

type XPSB (GhcPass idL) GhcTc

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcTc = NameSet

type family XOverLitE x

Instances

type XOverLitE (GhcPass _1)

Defined in GHC.Hs.Expr

type XOverLitE (GhcPass _1) = EpAnnCO

type family XOverLit x

Instances

type XOverLit GhcPs

Defined in GHC.Hs.Lit

type XOverLit GhcPs = NoExtField

type XOverLit GhcRn

Defined in GHC.Hs.Lit

type XOverLit GhcRn = Bool

type XOverLit GhcTc

Defined in GHC.Hs.Lit

type XOverLit GhcTc = OverLitTc

type family XOverLabel x

Instances

type XOverLabel GhcPs

Defined in GHC.Hs.Expr

type XOverLabel GhcPs = EpAnnCO

type XOverLabel GhcRn

Defined in GHC.Hs.Expr

type XOverLabel GhcRn = EpAnnCO

type XOverLabel GhcTc

Defined in GHC.Hs.Expr

type XOverLabel GhcTc = Void

type family XOpTy x

Instances

type XOpTy (GhcPass _1)

Defined in GHC.Hs.Type

type XOpTy (GhcPass _1) = NoExtField

type family XOpApp x

Instances

type XOpApp GhcPs

Defined in GHC.Hs.Expr

type XOpApp GhcPs = EpAnn [AddEpAnn]

type XOpApp GhcRn

Defined in GHC.Hs.Expr

type XOpApp GhcRn = Fixity

type XOpApp GhcTc

Defined in GHC.Hs.Expr

type XOpApp GhcTc = Void

type family XNoSig x

Instances

type XNoSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XNoSig (GhcPass _1) = NoExtField

type family XNewtypeStrategy x

Instances

type XNewtypeStrategy GhcPs

Defined in GHC.Hs.Decls

type XNewtypeStrategy GhcPs = EpAnn [AddEpAnn]

type XNewtypeStrategy GhcRn

Defined in GHC.Hs.Decls

type XNewtypeStrategy GhcRn = NoExtField

type XNewtypeStrategy GhcTc

Defined in GHC.Hs.Decls

type XNewtypeStrategy GhcTc = NoExtField

type family XNegApp x

Instances

type XNegApp GhcPs

Defined in GHC.Hs.Expr

type XNegApp GhcPs = EpAnn [AddEpAnn]

type XNegApp GhcRn

Defined in GHC.Hs.Expr

type XNegApp GhcRn = NoExtField

type XNegApp GhcTc

Defined in GHC.Hs.Expr

type XNegApp GhcTc = NoExtField

type family XNPlusKPat x

Instances

type XNPlusKPat GhcPs

Defined in GHC.Hs.Pat

type XNPlusKPat GhcPs = EpAnn EpaLocation

type XNPlusKPat GhcRn

Defined in GHC.Hs.Pat

type XNPlusKPat GhcRn = NoExtField

type XNPlusKPat GhcTc

Defined in GHC.Hs.Pat

type XNPlusKPat GhcTc = Type

type family XNPat x

Instances

type XNPat GhcPs

Defined in GHC.Hs.Pat

type XNPat GhcPs = EpAnn [AddEpAnn]

type XNPat GhcRn

Defined in GHC.Hs.Pat

type XNPat GhcRn = EpAnn [AddEpAnn]

type XNPat GhcTc

Defined in GHC.Hs.Pat

type XNPat GhcTc = Type

type family XMultiIf x

Instances

type XMultiIf GhcPs

Defined in GHC.Hs.Expr

type XMultiIf GhcPs = EpAnn [AddEpAnn]

type XMultiIf GhcRn

Defined in GHC.Hs.Expr

type XMultiIf GhcRn = NoExtField

type XMultiIf GhcTc

Defined in GHC.Hs.Expr

type XMultiIf GhcTc = Type

type family XMissing x

Instances

type XMissing GhcPs

Defined in GHC.Hs.Expr

type XMissing GhcPs = EpAnn EpaLocation

type XMissing GhcRn

Defined in GHC.Hs.Expr

type XMissing GhcRn = NoExtField

type XMissing GhcTc

Defined in GHC.Hs.Expr

type XMissing GhcTc = Scaled Type

type family XMinimalSig x

Instances

type XMinimalSig (GhcPass p)

Defined in GHC.Hs.Binds

type XMinimalSig (GhcPass p) = EpAnn [AddEpAnn]

type family XMG x b

Instances

type XMG GhcPs b

Defined in GHC.Hs.Expr

type XMG GhcPs b = NoExtField

type XMG GhcRn b

Defined in GHC.Hs.Expr

type XMG GhcRn b = NoExtField

type XMG GhcTc b

Defined in GHC.Hs.Expr

type XMG GhcTc b = MatchGroupTc

type family XLitPat x

Instances

type XLitPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XLitPat (GhcPass _1) = NoExtField

type family XLitE x

Instances

type XLitE (GhcPass _1)

Defined in GHC.Hs.Expr

type XLitE (GhcPass _1) = EpAnnCO

type family XListTy x

Instances

type XListTy (GhcPass _1)

Defined in GHC.Hs.Type

type XListTy (GhcPass _1) = EpAnn AnnParen

type family XListPat x

Instances

type XListPat GhcPs

Defined in GHC.Hs.Pat

type XListPat GhcPs = EpAnn AnnList

type XListPat GhcRn

Defined in GHC.Hs.Pat

type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)

type XListPat GhcTc

Defined in GHC.Hs.Pat

type XListPat GhcTc = ListPatTc

type family XLetStmt x x' b

Instances

type XLetStmt (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XLetStmt (GhcPass _1) (GhcPass _2) b = EpAnn [AddEpAnn]

type family XLet x

Instances

type XLet GhcPs

Defined in GHC.Hs.Expr

type XLet GhcPs = EpAnn AnnsLet

type XLet GhcRn

Defined in GHC.Hs.Expr

type XLet GhcRn = NoExtField

type XLet GhcTc

Defined in GHC.Hs.Expr

type XLet GhcTc = NoExtField

type family XLazyPat x

Instances

type XLazyPat GhcPs

Defined in GHC.Hs.Pat

type XLazyPat GhcPs = EpAnn [AddEpAnn]

type XLazyPat GhcRn

Defined in GHC.Hs.Pat

type XLazyPat GhcRn = NoExtField

type XLazyPat GhcTc

Defined in GHC.Hs.Pat

type XLazyPat GhcTc = NoExtField

type family XLastStmt x x' b

Instances

type XLastStmt (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type family XLamCase x

Instances

type XLamCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XLamCase (GhcPass _1) = EpAnn [AddEpAnn]

type family XLam x

Instances

type XLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XLam (GhcPass _1) = NoExtField

type XLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XLam (GhcPass _1) = NoExtField

type family XKindedTyVar x

Instances

type XKindedTyVar (GhcPass _1)

Defined in GHC.Hs.Type

type XKindedTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type family XKindSigD x

Instances

type XKindSigD (GhcPass _1)

Defined in GHC.Hs.Decls

type XKindSigD (GhcPass _1) = NoExtField

type family XKindSig x

Instances

type XKindSig (GhcPass _1)

Defined in GHC.Hs.Type

type XKindSig (GhcPass _1) = EpAnn [AddEpAnn]

type family XInstD x

Instances

type XInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XInstD (GhcPass _1) = NoExtField

type family XInlineSig x

Instances

type XInlineSig (GhcPass p)

Defined in GHC.Hs.Binds

type XInlineSig (GhcPass p) = EpAnn [AddEpAnn]

type family XIf x

Instances

type XIf GhcPs

Defined in GHC.Hs.Expr

type XIf GhcPs = EpAnn AnnsIf

type XIf GhcRn

Defined in GHC.Hs.Expr

type XIf GhcRn = NoExtField

type XIf GhcTc

Defined in GHC.Hs.Expr

type XIf GhcTc = NoExtField

type family XIdSig x

Instances

type XIdSig (GhcPass p)

Defined in GHC.Hs.Binds

type XIdSig (GhcPass p) = NoExtField

type family XIParamTy x

Instances

type XIParamTy (GhcPass _1)

Defined in GHC.Hs.Type

type XIParamTy (GhcPass _1) = EpAnn [AddEpAnn]

type family XIPVar x

Instances

type XIPVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XIPVar (GhcPass _1) = EpAnnCO

type family XIPBinds x

Instances

type XIPBinds GhcPs

Defined in GHC.Hs.Binds

type XIPBinds GhcPs = NoExtField

type XIPBinds GhcRn

Defined in GHC.Hs.Binds

type XIPBinds GhcRn = NoExtField

type XIPBinds GhcTc

Defined in GHC.Hs.Binds

type XIPBinds GhcTc = TcEvBinds

type family XIEVar x

Instances

type XIEVar GhcPs

Defined in GHC.Hs.ImpExp

type XIEVar GhcPs = NoExtField

type XIEVar GhcRn

Defined in GHC.Hs.ImpExp

type XIEVar GhcRn = NoExtField

type XIEVar GhcTc

Defined in GHC.Hs.ImpExp

type XIEVar GhcTc = NoExtField

type family XIEThingWith x

Instances

type XIEThingWith (GhcPass 'Parsed)

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass 'Parsed) = EpAnn [AddEpAnn]

type XIEThingWith (GhcPass 'Renamed)

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass 'Renamed) = [Located FieldLabel]

type XIEThingWith (GhcPass 'Typechecked)

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass 'Typechecked) = NoExtField

type family XIEThingAll x

Instances

type XIEThingAll (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingAll (GhcPass _1) = EpAnn [AddEpAnn]

type family XIEThingAbs x

Instances

type XIEThingAbs (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingAbs (GhcPass _1) = EpAnn [AddEpAnn]

type family XIEModuleContents x

Instances

type XIEModuleContents GhcPs

Defined in GHC.Hs.ImpExp

type XIEModuleContents GhcPs = EpAnn [AddEpAnn]

type XIEModuleContents GhcRn

Defined in GHC.Hs.ImpExp

type XIEModuleContents GhcRn = NoExtField

type XIEModuleContents GhcTc

Defined in GHC.Hs.ImpExp

type XIEModuleContents GhcTc = NoExtField

type family XIEGroup x

Instances

type XIEGroup (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEGroup (GhcPass _1) = NoExtField

type family XIEDocNamed x

Instances

type XIEDocNamed (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEDocNamed (GhcPass _1) = NoExtField

type family XIEDoc x

Instances

type XIEDoc (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEDoc (GhcPass _1) = NoExtField

type family XHsWordPrim x

Instances

type XHsWordPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsWordPrim (GhcPass _1) = SourceText

type family XHsWord64Prim x

Instances

type XHsWord64Prim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsWord64Prim (GhcPass _1) = SourceText

type family XHsWC x b

Instances

type XHsWC GhcPs b

Defined in GHC.Hs.Type

type XHsWC GhcPs b = NoExtField

type XHsWC GhcRn b

Defined in GHC.Hs.Type

type XHsWC GhcRn b = [Name]

type XHsWC GhcTc b

Defined in GHC.Hs.Type

type XHsWC GhcTc b = [Name]

type family XHsValBinds x x'

Instances

type XHsValBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XHsValBinds (GhcPass pL) (GhcPass pR) = EpAnn AnnList

type family XHsStringPrim x

Instances

type XHsStringPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsStringPrim (GhcPass _1) = SourceText

type family XHsString x

Instances

type XHsString (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsString (GhcPass _1) = SourceText

type family XHsSig x

Instances

type XHsSig (GhcPass _1)

Defined in GHC.Hs.Type

type XHsSig (GhcPass _1) = NoExtField

type family XHsRule x

Instances

type XHsRule GhcPs

Defined in GHC.Hs.Decls

type XHsRule GhcPs = EpAnn HsRuleAnn

type XHsRule GhcRn

Defined in GHC.Hs.Decls

type XHsRule GhcRn = HsRuleRn

type XHsRule GhcTc

Defined in GHC.Hs.Decls

type XHsRule GhcTc = HsRuleRn

type family XHsRecField x

Instances

type XHsRecField _1

Defined in GHC.Hs.Pat

type XHsRecField _1 = EpAnn [AddEpAnn]

type family XHsRat x

Instances

type XHsRat (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsRat (GhcPass _1) = NoExtField

type family XHsQTvs x

Instances

type XHsQTvs GhcPs

Defined in GHC.Hs.Type

type XHsQTvs GhcPs = NoExtField

type XHsQTvs GhcRn

Defined in GHC.Hs.Type

type XHsQTvs GhcRn = HsQTvsRn

type XHsQTvs GhcTc

Defined in GHC.Hs.Type

type XHsQTvs GhcTc = HsQTvsRn

type family XHsPS x

Instances

type XHsPS GhcPs

Defined in GHC.Hs.Type

type XHsPS GhcPs = EpAnn EpaLocation

type XHsPS GhcRn

Defined in GHC.Hs.Type

type XHsPS GhcRn = HsPSRn

type XHsPS GhcTc

Defined in GHC.Hs.Type

type XHsPS GhcTc = HsPSRn

type family XHsOuterImplicit x

Instances

type XHsOuterImplicit GhcPs

Defined in GHC.Hs.Type

type XHsOuterImplicit GhcPs = NoExtField

type XHsOuterImplicit GhcRn

Defined in GHC.Hs.Type

type XHsOuterImplicit GhcRn = [Name]

type XHsOuterImplicit GhcTc

Defined in GHC.Hs.Type

type XHsOuterImplicit GhcTc = [TyVar]

type family XHsOuterExplicit x flag

Instances

type XHsOuterExplicit GhcPs _1

Defined in GHC.Hs.Type

type XHsOuterExplicit GhcPs _1 = EpAnnForallTy

type XHsOuterExplicit GhcRn _1

Defined in GHC.Hs.Type

type XHsOuterExplicit GhcRn _1 = NoExtField

type XHsOuterExplicit GhcTc flag

Defined in GHC.Hs.Type

type XHsOuterExplicit GhcTc flag = [VarBndr TyVar flag]

type family XHsInteger x

Instances

type XHsInteger (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInteger (GhcPass _1) = SourceText

type family XHsIntPrim x

Instances

type XHsIntPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsIntPrim (GhcPass _1) = SourceText

type family XHsInt64Prim x

Instances

type XHsInt64Prim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInt64Prim (GhcPass _1) = SourceText

type family XHsInt x

Instances

type XHsInt (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInt (GhcPass _1) = NoExtField

type family XHsIPBinds x x'

Instances

type XHsIPBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XHsIPBinds (GhcPass pL) (GhcPass pR) = EpAnn AnnList

type family XHsForAllVis x

Instances

type XHsForAllVis (GhcPass _1)

Defined in GHC.Hs.Type

type XHsForAllVis (GhcPass _1) = EpAnnForallTy

type family XHsForAllInvis x

Instances

type XHsForAllInvis (GhcPass _1)

Defined in GHC.Hs.Type

type XHsForAllInvis (GhcPass _1) = EpAnnForallTy

type family XHsFloatPrim x

Instances

type XHsFloatPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsFloatPrim (GhcPass _1) = NoExtField

type family XHsDoublePrim x

Instances

type XHsDoublePrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsDoublePrim (GhcPass _1) = NoExtField

type family XHsCharPrim x

Instances

type XHsCharPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsCharPrim (GhcPass _1) = SourceText

type family XHsChar x

Instances

type XHsChar (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsChar (GhcPass _1) = SourceText

type family XHsAnnotation x

Instances

type XHsAnnotation (GhcPass _1)

Defined in GHC.Hs.Decls

type XHsAnnotation (GhcPass _1) = EpAnn AnnPragma

type family XGetField x

Instances

type XGetField GhcPs

Defined in GHC.Hs.Expr

type XGetField GhcPs = EpAnnCO

type XGetField GhcRn

Defined in GHC.Hs.Expr

type XGetField GhcRn = NoExtField

type XGetField GhcTc

Defined in GHC.Hs.Expr

type XGetField GhcTc = Void

type family XFunTy x

Instances

type XFunTy (GhcPass _1)

Defined in GHC.Hs.Type

type XFunTy (GhcPass _1) = EpAnn TrailingAnn

type family XFunBind x x'

Instances

type XFunBind (GhcPass pL) GhcPs

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcPs = NoExtField

type XFunBind (GhcPass pL) GhcRn

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcRn = NameSet

type XFunBind (GhcPass pL) GhcTc

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcTc = HsWrapper

type family XForeignImport x

Instances

type XForeignImport GhcPs

Defined in GHC.Hs.Decls

type XForeignImport GhcPs = EpAnn [AddEpAnn]

type XForeignImport GhcRn

Defined in GHC.Hs.Decls

type XForeignImport GhcRn = NoExtField

type XForeignImport GhcTc

Defined in GHC.Hs.Decls

type XForeignImport GhcTc = Coercion

type family XForeignExport x

Instances

type XForeignExport GhcPs

Defined in GHC.Hs.Decls

type XForeignExport GhcPs = EpAnn [AddEpAnn]

type XForeignExport GhcRn

Defined in GHC.Hs.Decls

type XForeignExport GhcRn = NoExtField

type XForeignExport GhcTc

Defined in GHC.Hs.Decls

type XForeignExport GhcTc = Coercion

type family XForD x

Instances

type XForD (GhcPass _1)

Defined in GHC.Hs.Decls

type XForD (GhcPass _1) = NoExtField

type family XForAllTy x

Instances

type XForAllTy (GhcPass _1)

Defined in GHC.Hs.Type

type XForAllTy (GhcPass _1) = NoExtField

type family XFixitySig x

Instances

type XFixitySig (GhcPass p)

Defined in GHC.Hs.Binds

type XFixitySig (GhcPass p) = NoExtField

type family XFixSig x

Instances

type XFixSig (GhcPass p)

Defined in GHC.Hs.Binds

type XFixSig (GhcPass p) = EpAnn [AddEpAnn]

type family XFamDecl x

Instances

type XFamDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XFamDecl (GhcPass _1) = NoExtField

type family XExprWithTySig x

Instances

type XExprWithTySig GhcPs

Defined in GHC.Hs.Expr

type XExprWithTySig GhcPs = EpAnn [AddEpAnn]

type XExprWithTySig GhcRn

Defined in GHC.Hs.Expr

type XExprWithTySig GhcRn = NoExtField

type XExprWithTySig GhcTc

Defined in GHC.Hs.Expr

type XExprWithTySig GhcTc = NoExtField

type family XExplicitTupleTy x

Instances

type XExplicitTupleTy GhcPs

Defined in GHC.Hs.Type

type XExplicitTupleTy GhcPs = EpAnn [AddEpAnn]

type XExplicitTupleTy GhcRn

Defined in GHC.Hs.Type

type XExplicitTupleTy GhcRn = NoExtField

type XExplicitTupleTy GhcTc

Defined in GHC.Hs.Type

type XExplicitTupleTy GhcTc = [Kind]

type family XExplicitTuple x

Instances

type XExplicitTuple GhcPs

Defined in GHC.Hs.Expr

type XExplicitTuple GhcPs = EpAnn [AddEpAnn]

type XExplicitTuple GhcRn

Defined in GHC.Hs.Expr

type XExplicitTuple GhcRn = NoExtField

type XExplicitTuple GhcTc

Defined in GHC.Hs.Expr

type XExplicitTuple GhcTc = NoExtField

type family XExplicitSum x

Instances

type XExplicitSum GhcPs

Defined in GHC.Hs.Expr

type XExplicitSum GhcPs = EpAnn AnnExplicitSum

type XExplicitSum GhcRn

Defined in GHC.Hs.Expr

type XExplicitSum GhcRn = NoExtField

type XExplicitSum GhcTc

Defined in GHC.Hs.Expr

type XExplicitSum GhcTc = [Type]

type family XExplicitListTy x

Instances

type XExplicitListTy GhcPs

Defined in GHC.Hs.Type

type XExplicitListTy GhcPs = EpAnn [AddEpAnn]

type XExplicitListTy GhcRn

Defined in GHC.Hs.Type

type XExplicitListTy GhcRn = NoExtField

type XExplicitListTy GhcTc

Defined in GHC.Hs.Type

type XExplicitListTy GhcTc = Kind

type family XExplicitList x

Instances

type XExplicitList GhcPs

Defined in GHC.Hs.Expr

type XExplicitList GhcPs = EpAnn AnnList

type XExplicitList GhcRn

Defined in GHC.Hs.Expr

type XExplicitList GhcRn = NoExtField

type XExplicitList GhcTc

Defined in GHC.Hs.Expr

type XExplicitList GhcTc = Type

type family XExpBr x

Instances

type XExpBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XExpBr (GhcPass _1) = NoExtField

type family XEmptyLocalBinds x x'

Instances

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XDocTy x

Instances

type XDocTy (GhcPass _1)

Defined in GHC.Hs.Type

type XDocTy (GhcPass _1) = EpAnn [AddEpAnn]

type family XDocD x

Instances

type XDocD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDocD (GhcPass _1) = NoExtField

type family XDo x

Instances

type XDo GhcPs

Defined in GHC.Hs.Expr

type XDo GhcPs = EpAnn AnnList

type XDo GhcRn

Defined in GHC.Hs.Expr

type XDo GhcRn = NoExtField

type XDo GhcTc

Defined in GHC.Hs.Expr

type XDo GhcTc = Type

type family XDerivD x

Instances

type XDerivD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDerivD (GhcPass _1) = NoExtField

type family XDefD x

Instances

type XDefD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDefD (GhcPass _1) = NoExtField

type family XDecBrL x

Instances

type XDecBrL (GhcPass _1)

Defined in GHC.Hs.Expr

type XDecBrL (GhcPass _1) = NoExtField

type family XDecBrG x

Instances

type XDecBrG (GhcPass _1)

Defined in GHC.Hs.Expr

type XDecBrG (GhcPass _1) = NoExtField

type family XDctSingle x

Instances

type XDctSingle (GhcPass _1)

Defined in GHC.Hs.Decls

type XDctSingle (GhcPass _1) = NoExtField

type family XDctMulti x

Instances

type XDctMulti (GhcPass _1)

Defined in GHC.Hs.Decls

type XDctMulti (GhcPass _1) = NoExtField

type family XDataFamInstD x

Instances

type XDataFamInstD GhcPs

Defined in GHC.Hs.Decls

type XDataFamInstD GhcPs = EpAnn [AddEpAnn]

type XDataFamInstD GhcRn

Defined in GHC.Hs.Decls

type XDataFamInstD GhcRn = NoExtField

type XDataFamInstD GhcTc

Defined in GHC.Hs.Decls

type XDataFamInstD GhcTc = NoExtField

type family XDataDecl x

Instances

type XDataDecl GhcPs

Defined in GHC.Hs.Decls

type XDataDecl GhcPs = EpAnn [AddEpAnn]

type XDataDecl GhcRn

Defined in GHC.Hs.Decls

type XDataDecl GhcRn = DataDeclRn

type XDataDecl GhcTc

Defined in GHC.Hs.Decls

type XDataDecl GhcTc = DataDeclRn

type family XConPat x

Instances

type XConPat GhcPs

Defined in GHC.Hs.Pat

type XConPat GhcPs = EpAnn [AddEpAnn]

type XConPat GhcRn

Defined in GHC.Hs.Pat

type XConPat GhcRn = NoExtField

type XConPat GhcTc

Defined in GHC.Hs.Pat

type XConPat GhcTc = ConPatTc

type family XConLikeOut x

Instances

type XConLikeOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XConLikeOut (GhcPass _1) = NoExtField

type XConLikeOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XConLikeOut (GhcPass _1) = NoExtField

type family XConDeclH98 x

Instances

type XConDeclH98 (GhcPass _1)

Defined in GHC.Hs.Decls

type XConDeclH98 (GhcPass _1) = EpAnn [AddEpAnn]

type family XConDeclGADT x

Instances

type XConDeclGADT (GhcPass _1)

Defined in GHC.Hs.Decls

type XConDeclGADT (GhcPass _1) = EpAnn [AddEpAnn]

type family XConDeclField x

Instances

type XConDeclField (GhcPass _1)

Defined in GHC.Hs.Type

type XConDeclField (GhcPass _1) = EpAnn [AddEpAnn]

type family XCompleteMatchSig x

Instances

type XCompleteMatchSig (GhcPass p)

Defined in GHC.Hs.Binds

type XCompleteMatchSig (GhcPass p) = EpAnn [AddEpAnn]

type family XCoPat x

type family XCmdWrap x

Instances

type XCmdWrap (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdWrap (GhcPass _1) = NoExtField

type family XCmdTop x

Instances

type XCmdTop GhcPs

Defined in GHC.Hs.Expr

type XCmdTop GhcPs = NoExtField

type XCmdTop GhcRn

Defined in GHC.Hs.Expr

type XCmdTop GhcRn = CmdSyntaxTable GhcRn

type XCmdTop GhcTc

Defined in GHC.Hs.Expr

type XCmdTop GhcTc = CmdTopTc

type family XCmdPar x

Instances

type XCmdPar (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdPar (GhcPass _1) = EpAnn AnnParen

type family XCmdLet x

Instances

type XCmdLet GhcPs

Defined in GHC.Hs.Expr

type XCmdLet GhcPs = EpAnn AnnsLet

type XCmdLet GhcRn

Defined in GHC.Hs.Expr

type XCmdLet GhcRn = NoExtField

type XCmdLet GhcTc

Defined in GHC.Hs.Expr

type XCmdLet GhcTc = NoExtField

type family XCmdLamCase x

Instances

type XCmdLamCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdLamCase (GhcPass _1) = EpAnn [AddEpAnn]

type family XCmdLam x

Instances

type XCmdLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdLam (GhcPass _1) = NoExtField

type family XCmdIf x

Instances

type XCmdIf GhcPs

Defined in GHC.Hs.Expr

type XCmdIf GhcPs = EpAnn AnnsIf

type XCmdIf GhcRn

Defined in GHC.Hs.Expr

type XCmdIf GhcRn = NoExtField

type XCmdIf GhcTc

Defined in GHC.Hs.Expr

type XCmdIf GhcTc = NoExtField

type family XCmdDo x

Instances

type XCmdDo GhcPs

Defined in GHC.Hs.Expr

type XCmdDo GhcPs = EpAnn AnnList

type XCmdDo GhcRn

Defined in GHC.Hs.Expr

type XCmdDo GhcRn = NoExtField

type XCmdDo GhcTc

Defined in GHC.Hs.Expr

type XCmdDo GhcTc = Type

type family XCmdCase x

Instances

type XCmdCase GhcPs

Defined in GHC.Hs.Expr

type XCmdCase GhcPs = EpAnn EpAnnHsCase

type XCmdCase GhcRn

Defined in GHC.Hs.Expr

type XCmdCase GhcRn = NoExtField

type XCmdCase GhcTc

Defined in GHC.Hs.Expr

type XCmdCase GhcTc = NoExtField

type family XCmdArrForm x

Instances

type XCmdArrForm GhcPs

Defined in GHC.Hs.Expr

type XCmdArrForm GhcPs = EpAnn AnnList

type XCmdArrForm GhcRn

Defined in GHC.Hs.Expr

type XCmdArrForm GhcRn = NoExtField

type XCmdArrForm GhcTc

Defined in GHC.Hs.Expr

type XCmdArrForm GhcTc = NoExtField

type family XCmdArrApp x

Instances

type XCmdArrApp GhcPs

Defined in GHC.Hs.Expr

type XCmdArrApp GhcPs = EpAnn AddEpAnn

type XCmdArrApp GhcRn

Defined in GHC.Hs.Expr

type XCmdArrApp GhcRn = NoExtField

type XCmdArrApp GhcTc

Defined in GHC.Hs.Expr

type XCmdArrApp GhcTc = Type

type family XCmdApp x

Instances

type XCmdApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdApp (GhcPass _1) = EpAnnCO

type family XClsInstD x

Instances

type XClsInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XClsInstD (GhcPass _1) = NoExtField

type family XClassOpSig x

Instances

type XClassOpSig (GhcPass p)

Defined in GHC.Hs.Binds

type XClassOpSig (GhcPass p) = EpAnn AnnSig

type family XClassDecl x

Instances

type XClassDecl GhcPs

Defined in GHC.Hs.Decls

type XClassDecl GhcPs = (EpAnn [AddEpAnn], AnnSortKey, LayoutInfo)

type XClassDecl GhcRn

Defined in GHC.Hs.Decls

type XClassDecl GhcRn = NameSet

type XClassDecl GhcTc

Defined in GHC.Hs.Decls

type XClassDecl GhcTc = NameSet

type family XCase x

Instances

type XCase GhcPs

Defined in GHC.Hs.Expr

type XCase GhcPs = EpAnn EpAnnHsCase

type XCase GhcRn

Defined in GHC.Hs.Expr

type XCase GhcRn = NoExtField

type XCase GhcTc

Defined in GHC.Hs.Expr

type XCase GhcTc = NoExtField

type family XCTyFamInstDecl x

Instances

type XCTyFamInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCTyFamInstDecl (GhcPass _1) = EpAnn [AddEpAnn]

type family XCTyClGroup x

Instances

type XCTyClGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XCTyClGroup (GhcPass _1) = NoExtField

type family XCRuleDecls x

Instances

type XCRuleDecls GhcPs

Defined in GHC.Hs.Decls

type XCRuleDecls GhcPs = EpAnn [AddEpAnn]

type XCRuleDecls GhcRn

Defined in GHC.Hs.Decls

type XCRuleDecls GhcRn = NoExtField

type XCRuleDecls GhcTc

Defined in GHC.Hs.Decls

type XCRuleDecls GhcTc = NoExtField

type family XCRuleBndr x

Instances

type XCRuleBndr (GhcPass _1)

Defined in GHC.Hs.Decls

type XCRuleBndr (GhcPass _1) = EpAnn [AddEpAnn]

type family XCRoleAnnotDecl x

Instances

type XCRoleAnnotDecl GhcPs

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl GhcPs = EpAnn [AddEpAnn]

type XCRoleAnnotDecl GhcRn

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl GhcRn = NoExtField

type XCRoleAnnotDecl GhcTc

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl GhcTc = NoExtField

type family XCMatch x b

Instances

type XCMatch (GhcPass _1) b

Defined in GHC.Hs.Expr

type XCMatch (GhcPass _1) b = EpAnn [AddEpAnn]

type family XCKindSig x

Instances

type XCKindSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XCKindSig (GhcPass _1) = NoExtField

type family XCInjectivityAnn x

Instances

type XCInjectivityAnn (GhcPass _1)

Defined in GHC.Hs.Decls

type XCInjectivityAnn (GhcPass _1) = EpAnn [AddEpAnn]

type family XCImportDecl x

Instances

type XCImportDecl GhcPs

Defined in GHC.Hs.ImpExp

type XCImportDecl GhcPs = EpAnn EpAnnImportDecl

type XCImportDecl GhcRn

Defined in GHC.Hs.ImpExp

type XCImportDecl GhcRn = NoExtField

type XCImportDecl GhcTc

Defined in GHC.Hs.ImpExp

type XCImportDecl GhcTc = NoExtField

type family XCIPBind x

Instances

type XCIPBind (GhcPass p)

Defined in GHC.Hs.Binds

type XCIPBind (GhcPass p) = EpAnn [AddEpAnn]

type family XCHsGroup x

Instances

type XCHsGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsGroup (GhcPass _1) = NoExtField

type family XCHsFieldLabel x

Instances

type XCHsFieldLabel (GhcPass _1)

Defined in GHC.Hs.Expr

type XCHsFieldLabel (GhcPass _1) = EpAnn AnnFieldLabel

type family XCHsDerivingClause x

Instances

type XCHsDerivingClause (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsDerivingClause (GhcPass _1) = EpAnn [AddEpAnn]

type family XCHsDataDefn x

Instances

type XCHsDataDefn (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsDataDefn (GhcPass _1) = NoExtField

type family XCGRHSs x b

Instances

type XCGRHSs (GhcPass _1) _2

Defined in GHC.Hs.Expr

type XCGRHSs (GhcPass _1) _2 = EpAnnComments

type family XCGRHS x b

Instances

type XCGRHS (GhcPass _1) _2

Defined in GHC.Hs.Expr

type XCGRHS (GhcPass _1) _2 = EpAnn GrhsAnn

type family XCFunDep x

Instances

type XCFunDep (GhcPass _1)

Defined in GHC.Hs.Decls

type XCFunDep (GhcPass _1) = EpAnn [AddEpAnn]

type family XCFieldOcc x

Instances

type XCFieldOcc GhcPs

Defined in GHC.Hs.Type

type XCFieldOcc GhcPs = NoExtField

type XCFieldOcc GhcRn

Defined in GHC.Hs.Type

type XCFieldOcc GhcRn = Name

type XCFieldOcc GhcTc

Defined in GHC.Hs.Type

type XCFieldOcc GhcTc = Id

type family XCFamilyDecl x

Instances

type XCFamilyDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCFamilyDecl (GhcPass _1) = EpAnn [AddEpAnn]

type family XCFamEqn x r

Instances

type XCFamEqn (GhcPass _1) r

Defined in GHC.Hs.Decls

type XCFamEqn (GhcPass _1) r = EpAnn [AddEpAnn]

type family XCDerivDecl x

Instances

type XCDerivDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCDerivDecl (GhcPass _1) = EpAnn [AddEpAnn]

type family XCDefaultDecl x

Instances

type XCDefaultDecl GhcPs

Defined in GHC.Hs.Decls

type XCDefaultDecl GhcPs = EpAnn [AddEpAnn]

type XCDefaultDecl GhcRn

Defined in GHC.Hs.Decls

type XCDefaultDecl GhcRn = NoExtField

type XCDefaultDecl GhcTc

Defined in GHC.Hs.Decls

type XCDefaultDecl GhcTc = NoExtField

type family XCClsInstDecl x

Instances

type XCClsInstDecl GhcPs

Defined in GHC.Hs.Decls

type XCClsInstDecl GhcPs = (EpAnn [AddEpAnn], AnnSortKey)

type XCClsInstDecl GhcRn

Defined in GHC.Hs.Decls

type XCClsInstDecl GhcRn = NoExtField

type XCClsInstDecl GhcTc

Defined in GHC.Hs.Decls

type XCClsInstDecl GhcTc = NoExtField

type family XBracket x

Instances

type XBracket (GhcPass _1)

Defined in GHC.Hs.Expr

type XBracket (GhcPass _1) = EpAnn [AddEpAnn]

type family XBodyStmt x x' b

Instances

type XBodyStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcPs b = NoExtField

type XBodyStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcRn b = NoExtField

type XBodyStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcTc b = Type

type family XBindStmt x x' b

Instances

type XBindStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcPs b = EpAnn [AddEpAnn]

type XBindStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcRn b = XBindStmtRn

type XBindStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcTc b = XBindStmtTc

type family XBinTick x

Instances

type XBinTick (GhcPass _1)

Defined in GHC.Hs.Expr

type XBinTick (GhcPass _1) = NoExtField

type family XBangTy x

Instances

type XBangTy (GhcPass _1)

Defined in GHC.Hs.Type

type XBangTy (GhcPass _1) = EpAnn [AddEpAnn]

type family XBangPat x

Instances

type XBangPat GhcPs

Defined in GHC.Hs.Pat

type XBangPat GhcPs = EpAnn [AddEpAnn]

type XBangPat GhcRn

Defined in GHC.Hs.Pat

type XBangPat GhcRn = NoExtField

type XBangPat GhcTc

Defined in GHC.Hs.Pat

type XBangPat GhcTc = NoExtField

type family XAsPat x

Instances

type XAsPat GhcPs

Defined in GHC.Hs.Pat

type XAsPat GhcPs = EpAnn [AddEpAnn]

type XAsPat GhcRn

Defined in GHC.Hs.Pat

type XAsPat GhcRn = NoExtField

type XAsPat GhcTc

Defined in GHC.Hs.Pat

type XAsPat GhcTc = NoExtField

type family XArithSeq x

Instances

type XArithSeq GhcPs

Defined in GHC.Hs.Expr

type XArithSeq GhcPs = EpAnn [AddEpAnn]

type XArithSeq GhcRn

Defined in GHC.Hs.Expr

type XArithSeq GhcRn = NoExtField

type XArithSeq GhcTc

Defined in GHC.Hs.Expr

type XArithSeq GhcTc = PostTcExpr

type family XApplicativeStmt x x' b

Instances

type XApplicativeStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField

type XApplicativeStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField

type XApplicativeStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcTc b = Type

type family XApplicativeArgOne x

Instances

type XApplicativeArgOne GhcPs

Defined in GHC.Hs.Expr

type XApplicativeArgOne GhcPs = NoExtField

type XApplicativeArgOne GhcRn

Defined in GHC.Hs.Expr

type XApplicativeArgOne GhcRn = FailOperator GhcRn

type XApplicativeArgOne GhcTc

Defined in GHC.Hs.Expr

type XApplicativeArgOne GhcTc = FailOperator GhcTc

type family XApplicativeArgMany x

Instances

type XApplicativeArgMany (GhcPass _1)

Defined in GHC.Hs.Expr

type XApplicativeArgMany (GhcPass _1) = NoExtField

type family XAppTypeE x

Instances

type XAppTypeE GhcPs

Defined in GHC.Hs.Expr

type XAppTypeE GhcPs = SrcSpan

type XAppTypeE GhcRn

Defined in GHC.Hs.Expr

type XAppTypeE GhcRn = NoExtField

type XAppTypeE GhcTc

Defined in GHC.Hs.Expr

type XAppTypeE GhcTc = Type

type family XAppTy x

Instances

type XAppTy (GhcPass _1)

Defined in GHC.Hs.Type

type XAppTy (GhcPass _1) = NoExtField

type family XAppKindTy x

Instances

type XAppKindTy (GhcPass _1)

Defined in GHC.Hs.Type

type XAppKindTy (GhcPass _1) = SrcSpan

type family XApp x

Instances

type XApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XApp (GhcPass _1) = EpAnnCO

type family XAnyClassStrategy x

Instances

type XAnyClassStrategy GhcPs

Defined in GHC.Hs.Decls

type XAnyClassStrategy GhcPs = EpAnn [AddEpAnn]

type XAnyClassStrategy GhcRn

Defined in GHC.Hs.Decls

type XAnyClassStrategy GhcRn = NoExtField

type XAnyClassStrategy GhcTc

Defined in GHC.Hs.Decls

type XAnyClassStrategy GhcTc = NoExtField

type family XAnnD x

Instances

type XAnnD (GhcPass _1)

Defined in GHC.Hs.Decls

type XAnnD (GhcPass _1) = NoExtField

type family XAmbiguous x

Instances

type XAmbiguous GhcPs

Defined in GHC.Hs.Type

type XAmbiguous GhcPs = NoExtField

type XAmbiguous GhcRn

Defined in GHC.Hs.Type

type XAmbiguous GhcRn = NoExtField

type XAmbiguous GhcTc

Defined in GHC.Hs.Type

type XAmbiguous GhcTc = Id

type family XAbsBinds x x'

Instances

type XAbsBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XABE x

Instances

type XABE (GhcPass p)

Defined in GHC.Hs.Binds

type XABE (GhcPass p) = NoExtField

class WrapXRec p a where

The trivial wrapper that carries no additional information See Note [XRec and SrcSpans in the AST]

Methods

wrapXRec :: a -> XRec p a

class UnXRec p where

We can strip off the XRec to access the underlying data. See Note [XRec and SrcSpans in the AST]

Methods

unXRec :: XRec p a -> a

Instances

UnXRec (GhcPass p)

Defined in GHC.Hs.Extension

Methods

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

type family NoGhcTc p

See Note [NoGhcTc] in GHC.Hs.Extension. It has to be in this module because it is used like an extension point (in the data definitions of types that should be parameter-agnostic.

Instances

type NoGhcTc (GhcPass pass)

Marks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because HsType GhcTc should never occur. See Note [NoGhcTc]

Defined in GHC.Hs.Extension

type NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)

data NoExtField

A placeholder type for TTG extension points that are not currently unused to represent any particular value.

This should not be confused with NoExtCon, which are found in unused extension constructors and therefore should never be inhabited. In contrast, NoExtField is used in extension points (e.g., as the field of some constructor), so it must have an inhabitant to construct AST passes that manipulate fields with that extension point as their type.

Constructors

NoExtField

Instances

Data NoExtField

Defined in Language.Haskell.Syntax.Extension

Methods

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

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

toConstr :: NoExtField -> Constr

dataTypeOf :: NoExtField -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable NoExtField

Defined in Language.Haskell.Syntax.Extension

Methods

ppr :: NoExtField -> SDoc

Eq NoExtField

Defined in Language.Haskell.Syntax.Extension

Methods

(==) :: NoExtField -> NoExtField -> Bool

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

Ord NoExtField

Defined in Language.Haskell.Syntax.Extension

Methods

compare :: NoExtField -> NoExtField -> Ordering

(<) :: NoExtField -> NoExtField -> Bool

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

(>) :: NoExtField -> NoExtField -> Bool

(>=) :: NoExtField -> NoExtField -> Bool

max :: NoExtField -> NoExtField -> NoExtField

min :: NoExtField -> NoExtField -> NoExtField

data NoExtCon

Used in TTG extension constructors that have yet to be extended with anything. If an extension constructor has NoExtCon as its field, it is not intended to ever be constructed anywhere, and any function that consumes the extension constructor can eliminate it by way of noExtCon.

This should not be confused with NoExtField, which are found in unused extension points (not constructors) and therefore can be inhabited.

Instances

Data NoExtCon

Defined in Language.Haskell.Syntax.Extension

Methods

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

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

toConstr :: NoExtCon -> Constr

dataTypeOf :: NoExtCon -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable NoExtCon

Defined in Language.Haskell.Syntax.Extension

Methods

ppr :: NoExtCon -> SDoc

Eq NoExtCon

Defined in Language.Haskell.Syntax.Extension

Methods

(==) :: NoExtCon -> NoExtCon -> Bool

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

Ord NoExtCon

Defined in Language.Haskell.Syntax.Extension

Methods

compare :: NoExtCon -> NoExtCon -> Ordering

(<) :: NoExtCon -> NoExtCon -> Bool

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

(>) :: NoExtCon -> NoExtCon -> Bool

(>=) :: NoExtCon -> NoExtCon -> Bool

max :: NoExtCon -> NoExtCon -> NoExtCon

min :: NoExtCon -> NoExtCon -> NoExtCon

class MapXRec p where

We can map over the underlying type contained in an XRec while preserving the annotation as is.

Methods

mapXRec :: Anno a ~ Anno b => (a -> b) -> XRec p a -> XRec p b

Instances

MapXRec (GhcPass p)

Defined in GHC.Hs.Extension

Methods

mapXRec :: Anno a ~ Anno b => (a -> b) -> XRec (GhcPass p) a -> XRec (GhcPass p) b

type LIdP p = XRec p (IdP p)

type family IdP p

Maps the "normal" id type for a given pass

Instances

type IdP (GhcPass p)

Defined in GHC.Hs.Extension

type IdP (GhcPass p) = IdGhcP p

type family Anno a = (b :: Type)

Instances

type Anno ConLike

Defined in GHC.Hs.Pat

type Anno ConLike = SrcSpanAnnN

type Anno OverlapMode

Defined in GHC.Hs.Decls

type Anno OverlapMode = SrcSpanAnnP

type Anno OverlapMode

Defined in GHC.Hs.Decls

type Anno OverlapMode = SrcSpanAnnP

type Anno CType

Defined in GHC.Hs.Decls

type Anno CType = SrcSpanAnnP

type Anno Name

Defined in GHC.Hs.Extension

type Anno Name = SrcSpanAnnN

type Anno RdrName

Defined in GHC.Hs.Extension

type Anno RdrName = SrcSpanAnnN

type Anno StringLiteral

Defined in GHC.Hs.Binds

type Anno StringLiteral = SrcSpan

type Anno Id

Defined in GHC.Hs.Extension

type Anno Id = SrcSpanAnnN

type Anno ModuleName

Defined in GHC.Hs.ImpExp

type Anno ModuleName = SrcSpanAnnA

type Anno DocDecl

Defined in GHC.Hs.Decls

type Anno DocDecl = SrcSpanAnnA

type Anno HsIPName

Defined in GHC.Hs.Type

type Anno HsIPName = SrcSpan

type Anno Bool

Defined in GHC.Hs.Decls

type Anno Bool = SrcSpan

type Anno (IE (GhcPass p))

Defined in GHC.Hs.ImpExp

type Anno (IE (GhcPass p)) = SrcSpanAnnA

type Anno (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

type Anno (ImportDecl (GhcPass p)) = SrcSpanAnnA

type Anno (LocatedA (IE (GhcPass p)))

Defined in GHC.Hs.ImpExp

type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno (LocatedN RdrName)

Defined in GHC.Hs.Binds

type Anno (LocatedN RdrName) = SrcSpan

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno (FixitySig (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (FixitySig (GhcPass p)) = SrcSpanAnnA

type Anno (IPBind (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (IPBind (GhcPass p)) = SrcSpanAnnA

type Anno (Sig (GhcPass p))

Defined in GHC.Hs.Binds

type Anno (Sig (GhcPass p)) = SrcSpanAnnA

type Anno (AnnDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (AnnDecl (GhcPass p)) = SrcSpanAnnA

type Anno (ClsInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ClsInstDecl (GhcPass p)) = SrcSpanAnnA

type Anno (ConDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ConDecl (GhcPass p)) = SrcSpanAnnA

type Anno (DataFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DataFamInstDecl (GhcPass p)) = SrcSpanAnnA

type Anno (DefaultDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA

type Anno (DerivClauseTys (GhcPass _1))

Defined in GHC.Hs.Decls

type Anno (DerivClauseTys (GhcPass _1)) = SrcSpanAnnC

type Anno (DerivDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA

type Anno (DerivStrategy (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (DerivStrategy (GhcPass p)) = SrcSpan

type Anno (FamilyDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA

type Anno (FamilyResultSig (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FamilyResultSig (GhcPass p)) = SrcSpan

type Anno (ForeignDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA

type Anno (FunDep (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (FunDep (GhcPass p)) = SrcSpanAnnA

type Anno (HsDecl (GhcPass _1))

Defined in GHC.Hs.Decls

type Anno (HsDecl (GhcPass _1)) = SrcSpanAnnA

type Anno (HsDerivingClause (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (HsDerivingClause (GhcPass p)) = SrcSpan

type Anno (InjectivityAnn (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (InjectivityAnn (GhcPass p)) = SrcSpan

type Anno (InstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (InstDecl (GhcPass p)) = SrcSpanAnnA

type Anno (RoleAnnotDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RoleAnnotDecl (GhcPass p)) = SrcSpanAnnA

type Anno (RuleBndr (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleBndr (GhcPass p)) = SrcSpan

type Anno (RuleDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleDecl (GhcPass p)) = SrcSpanAnnA

type Anno (RuleDecls (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (RuleDecls (GhcPass p)) = SrcSpanAnnA

type Anno (SpliceDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (SpliceDecl (GhcPass p)) = SrcSpanAnnA

type Anno (StandaloneKindSig (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA

type Anno (TyClDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA

type Anno (TyFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (TyFamInstDecl (GhcPass p)) = SrcSpanAnnA

type Anno (WarnDecl (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (WarnDecl (GhcPass p)) = SrcSpanAnnA

type Anno (WarnDecls (GhcPass p))

Defined in GHC.Hs.Decls

type Anno (WarnDecls (GhcPass p)) = SrcSpanAnnA

type Anno (HsCmd (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsCmd (GhcPass p)) = SrcSpanAnnA

type Anno (HsCmdTop (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsCmdTop (GhcPass p)) = SrcSpan

type Anno (HsExpr (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsExpr (GhcPass p)) = SrcSpanAnnA

type Anno (HsSplice (GhcPass p))

Defined in GHC.Hs.Expr

type Anno (HsSplice (GhcPass p)) = SrcSpanAnnA

type Anno (HsOverLit (GhcPass p))

Defined in GHC.Hs.Pat

type Anno (HsOverLit (GhcPass p)) = SrcSpan

type Anno (Pat (GhcPass p))

Defined in GHC.Hs.Pat

type Anno (Pat (GhcPass p)) = SrcSpanAnnA

type Anno (AmbiguousFieldOcc GhcTc)

Defined in GHC.Hs.Pat

type Anno (AmbiguousFieldOcc GhcTc) = SrcSpanAnnA

type Anno (BangType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (BangType (GhcPass p)) = SrcSpanAnnA

type Anno (ConDeclField (GhcPass p))

Defined in GHC.Hs.Type

type Anno (ConDeclField (GhcPass p)) = SrcSpanAnnA

type Anno (FieldOcc (GhcPass p))

Defined in GHC.Hs.Type

type Anno (FieldOcc (GhcPass p)) = SrcSpan

type Anno (HsKind (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsKind (GhcPass p)) = SrcSpanAnnA

type Anno (HsSigType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsSigType (GhcPass p)) = SrcSpanAnnA

type Anno (HsType (GhcPass p))

Defined in GHC.Hs.Type

type Anno (HsType (GhcPass p)) = SrcSpanAnnA

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcSpan

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcSpan

type Anno [LocatedA (IE (GhcPass p))]

Defined in GHC.Hs.ImpExp

type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.PostProcess

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.Types

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (ConDeclField (GhcPass _1))]

Defined in GHC.Hs.Decls

type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type Anno [LocatedA (HsType (GhcPass p))]

Defined in GHC.Hs.Type

type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

type Anno [LocatedN RdrName]

Defined in GHC.Hs.Binds

type Anno [LocatedN RdrName] = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type Anno (HsBindLR (GhcPass idL) (GhcPass idR))

Defined in GHC.Hs.Binds

type Anno (HsBindLR (GhcPass idL) (GhcPass idR)) = SrcSpanAnnA

type Anno (FamEqn (GhcPass p) _1)

Defined in GHC.Hs.Decls

type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA

type Anno (FamEqn (GhcPass p) _1)

Defined in GHC.Hs.Decls

type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA

type Anno (FamEqn p (LocatedA (HsType p)))

Defined in GHC.Hs.Decls

type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpan

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpan

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpan

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (HsRecField (GhcPass p) arg)

Defined in GHC.Hs.Pat

type Anno (HsRecField (GhcPass p) arg) = SrcSpanAnnA

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p)))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p))) = SrcSpanAnnA

type Anno (HsRecField' p arg)

Defined in GHC.Hs.Pat

type Anno (HsRecField' p arg) = SrcSpanAnnA

type Anno (HsOuterTyVarBndrs _1 (GhcPass _2))

Defined in GHC.Hs.Type

type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag (GhcPass _1))

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag (GhcPass _1)) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcPs)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcPs) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcRn)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcRn) = SrcSpanAnnA

type Anno (HsTyVarBndr _flag GhcTc)

Defined in GHC.Hs.Type

type Anno (HsTyVarBndr _flag GhcTc) = SrcSpanAnnA

type Anno (SourceText, RuleName)

Defined in GHC.Hs.Decls

type Anno (SourceText, RuleName) = SrcSpan

type Anno (SourceText, RuleName)

Defined in GHC.Hs.Decls

type Anno (SourceText, RuleName) = SrcSpan

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))

Defined in GHC.Hs.Expr

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

noExtField :: NoExtField

Used when constructing a term with an unused extension point.

noExtCon :: NoExtCon -> a

Eliminate a NoExtCon. Much like absurd.

data IOEnvFailure

Constructors

IOEnvFailure

Instances

Exception IOEnvFailure

Defined in GHC.Data.IOEnv

Methods

toException :: IOEnvFailure -> SomeException

fromException :: SomeException -> Maybe IOEnvFailure

displayException :: IOEnvFailure -> String

Show IOEnvFailure

Defined in GHC.Data.IOEnv

Methods

showsPrec :: Int -> IOEnvFailure -> ShowS

show :: IOEnvFailure -> String

showList :: [IOEnvFailure] -> ShowS

data IOEnv env a

Instances

MonadFail (IOEnv m)

Defined in GHC.Data.IOEnv

Methods

fail :: String -> IOEnv m a

MonadFix (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

mfix :: (a -> IOEnv env a) -> IOEnv env a

MonadIO (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

liftIO :: IO a -> IOEnv env a

Alternative (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

empty :: IOEnv env a

(<|>) :: IOEnv env a -> IOEnv env a -> IOEnv env a

some :: IOEnv env a -> IOEnv env [a]

many :: IOEnv env a -> IOEnv env [a]

Applicative (IOEnv m)

Defined in GHC.Data.IOEnv

Methods

pure :: a -> IOEnv m a

(<*>) :: IOEnv m (a -> b) -> IOEnv m a -> IOEnv m b

liftA2 :: (a -> b -> c) -> IOEnv m a -> IOEnv m b -> IOEnv m c

(*>) :: IOEnv m a -> IOEnv m b -> IOEnv m b

(<*) :: IOEnv m a -> IOEnv m b -> IOEnv m a

Functor (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

fmap :: (a -> b) -> IOEnv env a -> IOEnv env b

(<$) :: a -> IOEnv env b -> IOEnv env a

Monad (IOEnv m)

Defined in GHC.Data.IOEnv

Methods

(>>=) :: IOEnv m a -> (a -> IOEnv m b) -> IOEnv m b

(>>) :: IOEnv m a -> IOEnv m b -> IOEnv m b

return :: a -> IOEnv m a

MonadPlus (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

mzero :: IOEnv env a

mplus :: IOEnv env a -> IOEnv env a -> IOEnv env a

MonadCatch (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

catch :: Exception e => IOEnv env a -> (e -> IOEnv env a) -> IOEnv env a

MonadMask (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

mask :: ((forall a. IOEnv env a -> IOEnv env a) -> IOEnv env b) -> IOEnv env b

uninterruptibleMask :: ((forall a. IOEnv env a -> IOEnv env a) -> IOEnv env b) -> IOEnv env b

generalBracket :: IOEnv env a -> (a -> ExitCase b -> IOEnv env c) -> (a -> IOEnv env b) -> IOEnv env (b, c)

MonadThrow (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

throwM :: Exception e => e -> IOEnv env a

ContainsHooks env => HasHooks (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

getHooks :: IOEnv env Hooks

ContainsDynFlags env => HasDynFlags (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

getDynFlags :: IOEnv env DynFlags

ContainsModule env => HasModule (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

getModule :: IOEnv env Module

ContainsLogger env => HasLogger (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

getLogger :: IOEnv env Logger

writeMutVar :: IORef a -> a -> IOEnv env ()

updMutVarM :: IORef a -> (a -> IOEnv env a) -> IOEnv env ()

updMutVar :: IORef a -> (a -> a) -> IOEnv env ()

updEnv :: (env -> env') -> IOEnv env' a -> IOEnv env a

Perform a computation with an altered environment

unsafeInterleaveM :: IOEnv env a -> IOEnv env a

uninterruptibleMaskM_ :: IOEnv env a -> IOEnv env a

tryMostM :: IOEnv env r -> IOEnv env (Either SomeException r)

tryM :: IOEnv env r -> IOEnv env (Either IOEnvFailure r)

tryAllM :: IOEnv env r -> IOEnv env (Either SomeException r)

setEnv :: env' -> IOEnv env' a -> IOEnv env a

Perform a computation with a different environment

runIOEnv :: env -> IOEnv env a -> IO a

readMutVar :: IORef a -> IOEnv env a

newMutVar :: a -> IOEnv env (IORef a)

getEnv :: IOEnv env env

fixM :: (a -> IOEnv env a) -> IOEnv env a

failWithM :: String -> IOEnv env a

failM :: IOEnv env a

atomicUpdMutVar' :: IORef a -> (a -> (a, b)) -> IOEnv env b

Strict variant of atomicUpdMutVar.

atomicUpdMutVar :: IORef a -> (a -> (a, b)) -> IOEnv env b

Atomically update the reference. Does not force the evaluation of the new variable contents. For strict update, use atomicUpdMutVar'.

data InstalledFindResult

Constructors

InstalledFound ModLocation InstalledModule

InstalledNoPackage UnitId

InstalledNotFound [FilePath] (Maybe UnitId)

type FinderCache = InstalledModuleEnv InstalledFindResult

The FinderCache maps modules to the result of searching for that module. It records the results of searching for modules along the search path. On :load, we flush the entire contents of this cache.

data FindResult

The result of searching for an imported module.

NB: FindResult manages both user source-import lookups (which can result in Module) as well as direct imports for interfaces (which always result in InstalledModule).

Constructors

Found ModLocation Module

The module was found

NoPackage Unit

The requested unit was not found

FoundMultiple [(Module, ModuleOrigin)]

_Error_: both in multiple packages

NotFound

Not found

Fields

• fr_paths :: [FilePath]

  Places where I looked

• fr_pkg :: Maybe Unit

  Just p => module is in this unit's manifest, but couldn't find the .hi file

• fr_mods_hidden :: [Unit]

  Module is in these units, but the *module* is hidden

• fr_pkgs_hidden :: [Unit]

  Module is in these units, but the *unit* is hidden

• fr_unusables :: [(Unit, UnusableUnitReason)]

  Module is in these units, but it is unusable

• fr_suggestions :: [ModuleSuggestion]

  Possible mis-spelled modules

type CompleteMatches = [CompleteMatch]

data CompleteMatch

A list of conlikes which represents a complete pattern match. These arise from COMPLETE signatures. See also Note [Implementation of COMPLETE pragmas].

Instances

Outputable CompleteMatch

Defined in GHC.Types.CompleteMatch

Methods

ppr :: CompleteMatch -> SDoc

data SrcUnpackedness

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack

{-# UNPACK #-} specified

SrcNoUnpack

{-# NOUNPACK #-} specified

NoSrcUnpack

no unpack pragma

Instances

Data SrcUnpackedness

Defined in GHC.Core.DataCon

Methods

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

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

toConstr :: SrcUnpackedness -> Constr

dataTypeOf :: SrcUnpackedness -> DataType

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

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

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

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

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

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

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

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

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

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

Binary SrcUnpackedness

Defined in GHC.Core.DataCon

Methods

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

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

get :: BinHandle -> IO SrcUnpackedness

Outputable SrcUnpackedness

Defined in GHC.Core.DataCon

Methods

ppr :: SrcUnpackedness -> SDoc

Eq SrcUnpackedness

Defined in GHC.Core.DataCon

Methods

(==) :: SrcUnpackedness -> SrcUnpackedness -> Bool

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

data SrcStrictness

Source Strictness

What strictness annotation the user wrote

Constructors

SrcLazy

Lazy, ie ~

SrcStrict

Strict, ie !

NoSrcStrict

no strictness annotation

Instances

Data SrcStrictness

Defined in GHC.Core.DataCon

Methods

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

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

toConstr :: SrcStrictness -> Constr

dataTypeOf :: SrcStrictness -> DataType

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

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

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

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

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

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

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

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

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

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

Binary SrcStrictness

Defined in GHC.Core.DataCon

Methods

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

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

get :: BinHandle -> IO SrcStrictness

Outputable SrcStrictness

Defined in GHC.Core.DataCon

Methods

ppr :: SrcStrictness -> SDoc

Eq SrcStrictness

Defined in GHC.Core.DataCon

Methods

(==) :: SrcStrictness -> SrcStrictness -> Bool

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

data HsSrcBang

Haskell Source Bang

Bangs on data constructor arguments as the user wrote them in the source code.

(HsSrcBang _ SrcUnpack SrcLazy) and (HsSrcBang _ SrcUnpack NoSrcStrict) (without StrictData) makes no sense, we emit a warning (in checkValidDataCon) and treat it like (HsSrcBang _ NoSrcUnpack SrcLazy)

Constructors

HsSrcBang SourceText SrcUnpackedness SrcStrictness

Instances

Data HsSrcBang

Defined in GHC.Core.DataCon

Methods

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

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

toConstr :: HsSrcBang -> Constr

dataTypeOf :: HsSrcBang -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable HsSrcBang

Defined in GHC.Core.DataCon

Methods

ppr :: HsSrcBang -> SDoc

data HsImplBang

Haskell Implementation Bang

Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.

Constructors

HsLazy

Lazy field, or one with an unlifted type

HsStrict

Strict but not unpacked field

HsUnpack (Maybe Coercion)

Strict and unpacked field co :: arg-ty ~ product-ty HsBang

Instances

Data HsImplBang

Defined in GHC.Core.DataCon

Methods

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

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

toConstr :: HsImplBang -> Constr

dataTypeOf :: HsImplBang -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable HsImplBang

Defined in GHC.Core.DataCon

Methods

ppr :: HsImplBang -> SDoc

roughMatchTcs :: [Type] -> [RoughMatchTc]

instanceCantMatch :: [RoughMatchTc] -> [RoughMatchTc] -> Bool

mkClassPred :: Class -> [Type] -> PredType

isIPLikePred :: Type -> Bool

isEqPrimPred :: PredType -> Bool

isEqPredClass :: Class -> Bool

isEqPred :: PredType -> Bool

isClassPred :: PredType -> Bool

type HoleSet = UniqSet CoercionHole

A set of CoercionHoles

pprTypeApp :: TyCon -> [Type] -> SDoc

pprThetaArrowTy :: ThetaType -> SDoc

pprTheta :: ThetaType -> SDoc

pprTCvBndrs :: [TyCoVarBinder] -> SDoc

pprTCvBndr :: TyCoVarBinder -> SDoc

pprSigmaType :: Type -> SDoc

pprParendType :: Type -> SDoc

pprParendTheta :: ThetaType -> SDoc

pprParendKind :: Kind -> SDoc

pprClassPred :: Class -> [Type] -> SDoc

data TyCoMapper env (m :: Type -> Type)

This describes how a "map" operation over a type/coercion should behave

Constructors

TyCoMapper

Fields

• tcm_tyvar :: env -> TyVar -> m Type
• tcm_covar :: env -> CoVar -> m Coercion
• tcm_hole :: env -> CoercionHole -> m Coercion

  What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.

• tcm_tycobinder :: env -> TyCoVar -> ArgFlag -> m (env, TyCoVar)

  The returned env is used in the extended scope

• tcm_tycon :: TyCon -> m TyCon

  This is used only for TcTyCons a) To zonk TcTyCons b) To turn TcTyCons into TyCons. See Note [Type checking recursive type and class declarations] in GHC.Tc.TyCl

userTypeError_maybe :: Type -> Maybe Type

Is this type a custom user error? If so, give us the kind and the error message.

unrestricted :: a -> Scaled a

Scale a payload by Many

typeKind :: HasDebugCallStack => Type -> Kind

tymult :: a -> Scaled a

Scale a payload by Many; used for type arguments in core

tyConsOfType :: Type -> UniqSet TyCon

All type constructors occurring in the type; looking through type synonyms, but not newtypes. When it finds a Class, it returns the class TyCon.

tyConBindersTyCoBinders :: [TyConBinder] -> [TyCoBinder]

tyConArgFlags :: TyCon -> [Type] -> [ArgFlag]

Given a TyCon and a list of argument types to which the TyCon is applied, determine each argument's visibility (Inferred, Specified, or Required).

Wrinkle: consider the following scenario:

T :: forall k. k -> k
tyConArgFlags T [forall m. m -> m -> m, S, R, Q]

After substituting, we get

T (forall m. m -> m -> m) :: (forall m. m -> m -> m) -> forall n. n -> n -> n

Thus, the first argument is invisible, S is visible, R is invisible again, and Q is visible.

tyConAppTyConPicky_maybe :: Type -> Maybe TyCon

Retrieve the tycon heading this type, if there is one. Does not look through synonyms.

tyConAppTyCon :: Type -> TyCon

tyConAppNeedsKindSig

Arguments

:: Bool

Should specified binders count towards injective positions in the kind of the TyCon? (If you're using visible kind applications, then you want True here.

-> TyCon

-> Int

The number of args the TyCon is applied to.

-> Bool

Does T t_1 ... t_n need a kind signature? (Where n is the number of arguments)

Does a TyCon (that is applied to some number of arguments) need to be ascribed with an explicit kind signature to resolve ambiguity if rendered as a source-syntax type? (See Note [When does a tycon application need an explicit kind signature?] for a full explanation of what this function checks for.)

tyConAppArgs_maybe :: Type -> Maybe [Type]

The same as snd . splitTyConApp

tyConAppArgs :: Type -> [Type]

tyConAppArgN :: Int -> Type -> Type

tyCoBinderVar_maybe :: TyCoBinder -> Maybe TyCoVar

tyCoBinderType :: TyCoBinder -> Type

tyBinderType :: TyBinder -> Type

tcTypeKind :: HasDebugCallStack => Type -> Kind

tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type])

Split a type constructor application into its type constructor and applied types. Note that this may fail in the case of a FunTy with an argument of unknown kind FunTy (e.g. FunTy (a :: k) Int. since the kind of a isn't of the form TYPE rep). Consequently, you may need to zonk your type before using this function.

This does *not* split types headed with (=>), as that's not a TyCon in the type-checker.

If you only need the TyCon, consider using tcTyConAppTyCon_maybe.

tcReturnsConstraintKind :: Kind -> Bool

tcRepSplitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])

Like tcSplitTyConApp_maybe, but doesn't look through synonyms. This assumes the synonyms have already been dealt with.

Moreover, for a FunTy, it only succeeds if the argument types have enough info to extract the runtime-rep arguments that the funTyCon requires. This will usually be true; but may be temporarily false during canonicalization: see Note [Decomposing FunTy] in GHC.Tc.Solver.Canonical and Note [The Purely Kinded Type Invariant (PKTI)] in GHC.Tc.Gen.HsType, Wrinkle around FunTy

tcRepSplitAppTy_maybe :: Type -> Maybe (Type, Type)

Does the AppTy split as in tcSplitAppTy_maybe, but assumes that any coreView stuff is already done. Refuses to look through (c => t)

tcIsRuntimeTypeKind :: Kind -> Bool

Is this kind equivalent to TYPE r (for some unknown r)?

This considers Constraint to be distinct from *.

tcIsLiftedTypeKind :: Kind -> Bool

Is this kind equivalent to Type?

This considers Constraint to be distinct from Type. For a version that treats them as the same type, see isLiftedTypeKind.

tcIsConstraintKind :: Kind -> Bool

tcIsBoxedTypeKind :: Kind -> Bool

Is this kind equivalent to TYPE (BoxedRep l) for some l :: Levity?

This considers Constraint to be distinct from Type. For a version that treats them as the same type, see isLiftedTypeKind.

stripCoercionTy :: Type -> Coercion

splitVisVarsOfTypes :: [Type] -> Pair TyCoVarSet

splitVisVarsOfType :: Type -> Pair TyCoVarSet

Retrieve the free variables in this type, splitting them based on whether they are used visibly or invisibly. Invisible ones come first.

splitTyConApp :: Type -> (TyCon, [Type])

Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor. Panics if that is not possible. See also splitTyConApp_maybe

splitPiTys :: Type -> ([TyCoBinder], Type)

Split off all TyCoBinders to a type, splitting both proper foralls and functions

splitPiTy_maybe :: Type -> Maybe (TyCoBinder, Type)

Attempts to take a forall type apart; works with proper foralls and functions

splitPiTy :: Type -> (TyCoBinder, Type)

Takes a forall type apart, or panics

splitListTyConApp_maybe :: Type -> Maybe Type

Attempts to tease a list type apart and gives the type of the elements if successful (looks through type synonyms)

splitInvisPiTysN :: Int -> Type -> ([TyCoBinder], Type)

Same as splitInvisPiTys, but stop when - you have found n TyCoBinders, - or you run out of invisible binders

splitInvisPiTys :: Type -> ([TyCoBinder], Type)

Like splitPiTys, but returns only *invisible* binders, including constraints. Stops at the first visible binder.

splitFunTys :: Type -> ([Scaled Type], Type)

splitFunTy_maybe :: Type -> Maybe (Mult, Type, Type)

Attempts to extract the multiplicity, argument and result types from a type

splitFunTy :: Type -> (Mult, Type, Type)

Attempts to extract the multiplicity, argument and result types from a type, and panics if that is not possible. See also splitFunTy_maybe

splitForAllTyVar_maybe :: Type -> Maybe (TyCoVar, Type)

Like splitForAllTyCoVar_maybe, but only returns Just if it is a tyvar binder.

splitForAllTyCoVars :: Type -> ([TyCoVar], Type)

Take a ForAllTy apart, returning the list of tycovars and the result type. This always succeeds, even if it returns only an empty list. Note that the result type returned may have free variables that were bound by a forall.

splitForAllTyCoVar_maybe :: Type -> Maybe (TyCoVar, Type)

Attempts to take a forall type apart, but only if it's a proper forall, with a named binder

splitForAllTyCoVarBinders :: Type -> ([TyCoVarBinder], Type)

Like splitPiTys but split off only named binders and returns TyCoVarBinders rather than TyCoBinders

splitForAllTyCoVar :: Type -> (TyCoVar, Type)

Take a forall type apart, or panics if that is not possible.

splitForAllReqTVBinders :: Type -> ([ReqTVBinder], Type)

Like splitForAllTyCoVars, but only splits ForAllTys with Required type variable binders. Furthermore, each returned tyvar is annotated with ().

splitForAllInvisTVBinders :: Type -> ([InvisTVBinder], Type)

Like splitForAllTyCoVars, but only splits ForAllTys with Invisible type variable binders. Furthermore, each returned tyvar is annotated with its Specificity.

splitForAllCoVar_maybe :: Type -> Maybe (TyCoVar, Type)

Like splitForAllTyCoVar_maybe, but only returns Just if it is a covar binder.

splitCastTy_maybe :: Type -> Maybe (Type, Coercion)

splitAppTys :: Type -> (Type, [Type])

Recursively splits a type as far as is possible, leaving a residual type being applied to and the type arguments applied to it. Never fails, even if that means returning an empty list of type applications.

splitAppTy_maybe :: Type -> Maybe (Type, Type)

Attempt to take a type application apart, whether it is a function, type constructor, or plain type application. Note that type family applications are NEVER unsaturated by this!

splitAppTy :: Type -> (Type, Type)

Attempts to take a type application apart, as in splitAppTy_maybe, and panics if this is not possible

seqTypes :: [Type] -> ()

seqType :: Type -> ()

scaledSet :: Scaled a -> b -> Scaled b

resultIsLevPoly :: Type -> Bool

Looking past all pi-types, is the end result potentially levity polymorphic? Example: True for (forall r (a :: TYPE r). String -> a) Example: False for (forall r1 r2 (a :: TYPE r1) (b :: TYPE r2). a -> b -> Type)

repSplitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])

Like splitTyConApp_maybe, but doesn't look through synonyms. This assumes the synonyms have already been dealt with.

repSplitAppTys :: HasDebugCallStack => Type -> (Type, [Type])

Like splitAppTys, but doesn't look through type synonyms

repSplitAppTy_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type)

Does the AppTy split as in splitAppTy_maybe, but assumes that any Core view stuff is already done

repGetTyVar_maybe :: Type -> Maybe TyVar

Attempts to obtain the type variable underlying a Type, without any expansion

pprUserTypeErrorTy :: Type -> SDoc

Render a type corresponding to a user type error into a SDoc.

pickyIsLiftedTypeKind :: Kind -> Bool

piResultTys :: HasDebugCallStack => Type -> [Type] -> Type

(piResultTys f_ty [ty1, .., tyn]) gives the type of (f ty1 .. tyn) where f :: f_ty piResultTys is interesting because: 1. f_ty may have more for-alls than there are args 2. Less obviously, it may have fewer for-alls For case 2. think of: piResultTys (forall a.a) [forall b.b, Int] This really can happen, but only (I think) in situations involving undefined. For example: undefined :: forall a. a Term: undefined (forall b. b->b) Int This term should have type (Int -> Int), but notice that there are more type args than foralls in undefineds type.

partitionInvisibles :: [(a, ArgFlag)] -> ([a], [a])

Given a list of things paired with their visibilities, partition the things into (invisible things, visible things).

occCheckExpand :: [Var] -> Type -> Maybe Type

nonDetCmpTypesX :: RnEnv2 -> [Type] -> [Type] -> Ordering

nonDetCmpTypes :: [Type] -> [Type] -> Ordering

nonDetCmpTypeX :: RnEnv2 -> Type -> Type -> Ordering

nonDetCmpType :: Type -> Type -> Ordering

nonDetCmpTc :: TyCon -> TyCon -> Ordering

Compare two TyCons. NB: This should never see Constraint (as recognized by Kind.isConstraintKindCon) which is considered a synonym for Type in Core. See Note [Kind Constraint and kind Type] in GHC.Core.Type. See Note [nonDetCmpType nondeterminism]

newTyConInstRhs :: TyCon -> [Type] -> Type

Unwrap one layer of newtype on a type constructor and its arguments, using an eta-reduced version of the newtype if possible. This requires tys to have at least newTyConInstArity tycon elements.

mkVisForAllTys :: [TyVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and visible

mkTyConBindersPreferAnon

Arguments

:: [TyVar]

binders

-> TyCoVarSet

free variables of result

-> [TyConBinder]

Given a list of type-level vars and the free vars of a result kind, makes TyCoBinders, preferring anonymous binders if the variable is, in fact, not dependent. e.g. mkTyConBindersPreferAnon (k:*),(b:k),(c:k) We want (k:*) Named, (b:k) Anon, (c:k) Anon

All non-coercion binders are visible.

mkTyCoInvForAllTys :: [TyCoVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and Inferred, a common case

mkTyCoInvForAllTy :: TyCoVar -> Type -> Type

Make a dependent forall over an Inferred variable

mkStrLitTy :: FastString -> Type

mkSpecForAllTys :: [TyVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and Specified, a common case

mkSpecForAllTy :: TyVar -> Type -> Type

Like mkForAllTy, but assumes the variable is dependent and Specified, a common case

mkScaled :: Mult -> a -> Scaled a

mkNumLitTy :: Integer -> Type

mkInfForAllTys :: [TyVar] -> Type -> Type

Like mkTyCoInvForAllTys, but tvs should be a list of tyvar

mkInfForAllTy :: TyVar -> Type -> Type

Like mkTyCoInvForAllTy, but tv should be a tyvar

mkFamilyTyConApp :: TyCon -> [Type] -> Type

Given a family instance TyCon and its arg types, return the corresponding family type. E.g:

data family T a
data instance T (Maybe b) = MkT b

Where the instance tycon is :RTL, so:

mkFamilyTyConApp :RTL Int  =  T (Maybe Int)

mkCoercionTy :: Coercion -> Type

mkCharLitTy :: Char -> Type

mkAppTys :: Type -> [Type] -> Type

mkAnonBinder :: AnonArgFlag -> Scaled Type -> TyCoBinder

Make an anonymous binder

mightBeUnliftedType :: Type -> Bool

Returns:

• False if the type is guaranteed lifted or
• True if it is unlifted, OR we aren't sure (e.g. in a levity-polymorphic case)

mapTyCoX :: Monad m => TyCoMapper env m -> (env -> Type -> m Type, env -> [Type] -> m [Type], env -> Coercion -> m Coercion, env -> [Coercion] -> m [Coercion])

mapTyCo :: Monad m => TyCoMapper () m -> (Type -> m Type, [Type] -> m [Type], Coercion -> m Coercion, [Coercion] -> m [Coercion])

linear :: a -> Scaled a

Scale a payload by One

kindRep_maybe :: HasDebugCallStack => Kind -> Maybe Type

Given a kind (TYPE rr), extract its RuntimeRep classifier rr. For example, kindRep_maybe * = Just LiftedRep Returns Nothing if the kind is not of form (TYPE rr) Treats * and Constraint as the same

kindRep :: HasDebugCallStack => Kind -> Type

Extract the RuntimeRep classifier of a type from its kind. For example, kindRep * = LiftedRep; Panics if this is not possible. Treats * and Constraint as the same

isValidJoinPointType :: JoinArity -> Type -> Bool

Determine whether a type could be the type of a join point of given total arity, according to the polymorphism rule. A join point cannot be polymorphic in its return type, since given join j a b x y z = e1 in e2, the types of e1 and e2 must be the same, and a and b are not in scope for e2. (See Note [The polymorphism rule of join points] in GHC.Core.) Returns False also if the type simply doesn't have enough arguments.

Note that we need to know how many arguments (type *and* value) the putative join point takes; for instance, if j :: forall a. a -> Int then j could be a binary join point returning an Int, but it could *not* be a unary join point returning a -> Int.

TODO: See Note [Excess polymorphism and join points]

isUnliftedTypeKind :: Kind -> Bool

Returns True if the kind classifies unlifted types (like 'Int#') and False otherwise. Note that this returns False for levity-polymorphic kinds, which may be specialized to a kind that classifies unlifted types.

isUnliftedType :: HasDebugCallStack => Type -> Bool

See Type for what an unlifted type is. Panics on levity polymorphic types; See mightBeUnliftedType for a more approximate predicate that behaves better in the presence of levity polymorphism.

isUnliftedRuntimeRep :: Type -> Bool

isUnliftedLevity :: Type -> Bool

isUnboxedTupleType :: Type -> Bool

isUnboxedSumType :: Type -> Bool

isTypeLevPoly :: Type -> Bool

Returns True if a type is levity polymorphic. Should be the same as (isKindLevPoly . typeKind) but much faster. Precondition: The type has kind (TYPE blah)

isTyVarTy :: Type -> Bool

isTauTy :: Type -> Bool

isStrictType :: HasDebugCallStack => Type -> Bool

Computes whether an argument (or let right hand side) should be computed strictly or lazily, based only on its type. Currently, it's just isUnliftedType. Panics on levity-polymorphic types.

isStrLitTy :: Type -> Maybe FastString

Is this a symbol literal. We also look through type synonyms.

isRuntimeRepVar :: TyVar -> Bool

Is a tyvar of type RuntimeRep?

isRuntimeRepKindedTy :: Type -> Bool

Is this a type of kind RuntimeRep? (e.g. LiftedRep)

isPrimitiveType :: Type -> Bool

Returns true of types that are opaque to Haskell.

isPiTy :: Type -> Bool

Is this a function or forall?

isOneDataConTy :: Mult -> Bool

isNumLitTy :: Type -> Maybe Integer

Is this a numeric literal. We also look through type synonyms.

isMultiplicityVar :: TyVar -> Bool

Is a tyvar of type Multiplicity?

isManyDataConTy :: Mult -> Bool

isLitTy :: Type -> Maybe TyLit

Is this a type literal (symbol, numeric, or char)?

isLinearType :: Type -> Bool

isLinear t returns True of a if t is a type of (curried) function where at least one argument is linear (or otherwise non-unrestricted). We use this function to check whether it is safe to eta reduce an Id in CorePrep. It is always safe to return True, because True deactivates the optimisation.

isLiftedType_maybe :: HasDebugCallStack => Type -> Maybe Bool

Returns Just True if this type is surely lifted, Just False if it is surely unlifted, Nothing if we can't be sure (i.e., it is levity polymorphic), and panics if the kind does not have the shape TYPE r.

isLiftedRuntimeRep :: Type -> Bool

isLiftedLevity :: Type -> Bool

isLevityVar :: TyVar -> Bool

Is a tyvar of type Levity?

isLevityTy :: Type -> Bool

Is this the type Levity?

isKindLevPoly :: Kind -> Bool

Tests whether the given kind (which should look like TYPE x) is something other than a constructor tree (that is, constructors at every node). E.g. True of TYPE k, TYPE (F Int) False of TYPE 'LiftedRep

isFunTy :: Type -> Bool

Is this a function?

isForAllTy_ty :: Type -> Bool

Like isForAllTy, but returns True only if it is a tyvar binder

isForAllTy_co :: Type -> Bool

Like isForAllTy, but returns True only if it is a covar binder

isForAllTy :: Type -> Bool

Checks whether this is a proper forall (with a named binder)

isFamFreeTy :: Type -> Bool

isDataFamilyAppType :: Type -> Bool

Check whether a type is a data family type

isCoercionTy_maybe :: Type -> Maybe Coercion

isCoVarType :: Type -> Bool

Does this type classify a core (unlifted) Coercion? At either role nominal or representational (t1 ~# t2) or (t1 ~R# t2) See Note [Types for coercions, predicates, and evidence] in GHC.Core.TyCo.Rep

isCharLitTy :: Type -> Maybe Char

Is this a char literal? We also look through type synonyms.

isBoxedTypeKind :: Kind -> Bool

Returns True if the kind classifies types which are allocated on the GC'd heap and False otherwise. Note that this returns False for levity-polymorphic kinds, which may be specialized to a kind that classifies AddrRep or even unboxed kinds.

isBoxedType :: Type -> Bool

See Type for what a boxed type is. Panics on levity polymorphic types; See mightBeUnliftedType for a more approximate predicate that behaves better in the presence of levity polymorphism.

isBoxedRuntimeRep :: Type -> Bool

See isBoxedRuntimeRep_maybe.

isAtomicTy :: Type -> Bool

isAnonTyCoBinder :: TyCoBinder -> Bool

Does this binder bind a variable that is not erased? Returns True for anonymous binders.

isAlgType :: Type -> Bool

See Type for what an algebraic type is. Should only be applied to types, as opposed to e.g. partially saturated type constructors

irrelevantMult :: Scaled a -> a

invisibleTyBndrCount :: Type -> Int

getTyVar_maybe :: Type -> Maybe TyVar

Attempts to obtain the type variable underlying a Type

getTyVar :: String -> Type -> TyVar

Attempts to obtain the type variable underlying a Type, and panics with the given message if this is not a type variable type. See also getTyVar_maybe

getRuntimeRep_maybe :: HasDebugCallStack => Type -> Maybe Type

Extract the RuntimeRep classifier of a type. For instance, getRuntimeRep_maybe Int = LiftedRep. Returns Nothing if this is not possible.

getRuntimeRep :: HasDebugCallStack => Type -> Type

Extract the RuntimeRep classifier of a type. For instance, getRuntimeRep_maybe Int = LiftedRep. Panics if this is not possible.

getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)

If the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind ty

funResultTy :: Type -> Type

Extract the function result type and panic if that is not possible

funArgTy :: Type -> Type

Just like piResultTys but for a single argument Try not to iterate piResultTy, because it's inefficient to substitute one variable at a time; instead use 'piResultTys"

Extract the function argument type and panic if that is not possible

filterOutInvisibleTypes :: TyCon -> [Type] -> [Type]

Given a TyCon and a list of argument types, filter out any invisible (i.e., Inferred or Specified) arguments.

filterOutInferredTypes :: TyCon -> [Type] -> [Type]

Given a TyCon and a list of argument types, filter out any Inferred arguments.

expandTypeSynonyms :: Type -> Type

Expand out all type synonyms. Actually, it'd suffice to expand out just the ones that discard type variables (e.g. type Funny a = Int) But we don't know which those are currently, so we just expand all.

expandTypeSynonyms only expands out type synonyms mentioned in the type, not in the kinds of any TyCon or TyVar mentioned in the type.

Keep this synchronized with synonymTyConsOfType

eqVarBndrs :: RnEnv2 -> [Var] -> [Var] -> Maybe RnEnv2

eqTypes :: [Type] -> [Type] -> Bool

Type equality on lists of types, looking through type synonyms but not newtypes.

eqTypeX :: RnEnv2 -> Type -> Type -> Bool

Compare types with respect to a (presumably) non-empty RnEnv2.

eqType :: Type -> Type -> Bool

Type equality on source types. Does not look through newtypes or PredTypes, but it does look through type synonyms. This first checks that the kinds of the types are equal and then checks whether the types are equal, ignoring casts and coercions. (The kind check is a recursive call, but since all kinds have type Type, there is no need to check the types of kinds.) See also Note [Non-trivial definitional equality] in GHC.Core.TyCo.Rep.

dropRuntimeRepArgs :: [Type] -> [Type]

Drops prefix of RuntimeRep constructors in TyConApps. Useful for e.g. dropping 'LiftedRep arguments of unboxed tuple TyCon applications:

dropRuntimeRepArgs [ 'LiftedRep, 'IntRep , String, Int# ] == [String, Int#]

dropForAlls :: Type -> Type

Drops all ForAllTys

coAxNthLHS :: forall (br :: BranchFlag). CoAxiom br -> Int -> Type

Get the type on the LHS of a coercion induced by a type/data family instance.

classifiesTypeWithValues :: Kind -> Bool

Does this classify a type allowed to have values? Responds True to things like *, #, TYPE Lifted, TYPE v, Constraint.

True of any sub-kind of OpenTypeKind

buildSynTyCon

Arguments

:: Name

-> [KnotTied TyConBinder]

-> Kind

result kind

-> [Role]

-> KnotTied Type

-> TyCon

binderRelevantType_maybe :: TyCoBinder -> Maybe Type

Extract a relevant type, if there is one.

applyTysX :: [TyVar] -> Type -> [Type] -> Type

appTyArgFlags :: Type -> [Type] -> [ArgFlag]

Given a Type and a list of argument types to which the Type is applied, determine each argument's visibility (Inferred, Specified, or Required).

Most of the time, the arguments will be Required, but not always. Consider f :: forall a. a -> Type. In f Type Bool, the first argument (Type) is Specified and the second argument (Bool) is Required. It is precisely this sort of higher-rank situation in which appTyArgFlags comes in handy, since f Type Bool would be represented in Core using AppTys. (See also #15792).

pattern One :: Mult

pattern Many :: Mult

funTyCon :: TyCon

The FUN type constructor.

FUN :: forall (m :: Multiplicity) ->
       forall {rep1 :: RuntimeRep} {rep2 :: RuntimeRep}.
       TYPE rep1 -> TYPE rep2 -> *

The runtime representations quantification is left inferred. This means they cannot be specified with -XTypeApplications.

This is a deliberate choice to allow future extensions to the function arrow. To allow visible application a type synonym can be defined:

type Arr :: forall (rep1 :: RuntimeRep) (rep2 :: RuntimeRep).
            TYPE rep1 -> TYPE rep2 -> Type
type Arr = FUN 'Many

type TvSubstEnv = TyVarEnv Type

A substitution of Types for TyVars and Kinds for KindVars

data TCvSubst

Type & coercion substitution

The following invariants must hold of a TCvSubst:

1. The in-scope set is needed only to guide the generation of fresh uniques
2. In particular, the kind of the type variables in the in-scope set is not relevant
3. The substitution is only applied ONCE! This is because in general such application will not reach a fixed point.

Constructors

TCvSubst InScopeSet TvSubstEnv CvSubstEnv

Instances

Outputable TCvSubst

Defined in GHC.Core.TyCo.Subst

Methods

ppr :: TCvSubst -> SDoc

zipTyEnv :: HasDebugCallStack => [TyVar] -> [Type] -> TvSubstEnv

zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> TCvSubst

Generates the in-scope set for the TCvSubst from the types in the incoming environment. No CoVars, please!

zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> TCvSubst

zipCoEnv :: HasDebugCallStack => [CoVar] -> [Coercion] -> CvSubstEnv

zapTCvSubst :: TCvSubst -> TCvSubst

unionTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst

substVarBndrs :: HasCallStack => TCvSubst -> [TyCoVar] -> (TCvSubst, [TyCoVar])

substVarBndr :: HasCallStack => TCvSubst -> TyCoVar -> (TCvSubst, TyCoVar)

substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]

Type substitution, see zipTvSubst

substTysUnchecked :: TCvSubst -> [Type] -> [Type]

Substitute within several Types disabling the sanity checks. The problems that the sanity checks in substTys catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTysUnchecked to substTys and remove this function. Please don't use in new code.

substTys :: HasCallStack => TCvSubst -> [Type] -> [Type]

Substitute within several Types The substitution has to satisfy the invariants described in Note [The substitution invariant].

substTyWithUnchecked :: [TyVar] -> [Type] -> Type -> Type

Type substitution, see zipTvSubst. Disables sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.

substTyWithCoVars :: [CoVar] -> [Coercion] -> Type -> Type

Substitute covars within a type

substTyWith :: HasCallStack => [TyVar] -> [Type] -> Type -> Type

Type substitution, see zipTvSubst

substTyVars :: TCvSubst -> [TyVar] -> [Type]

substTyVarBndrs :: HasCallStack => TCvSubst -> [TyVar] -> (TCvSubst, [TyVar])

substTyVarBndr :: HasCallStack => TCvSubst -> TyVar -> (TCvSubst, TyVar)

substTyVar :: TCvSubst -> TyVar -> Type

substTyUnchecked :: TCvSubst -> Type -> Type

Substitute within a Type disabling the sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.

substTyCoBndr :: TCvSubst -> TyCoBinder -> (TCvSubst, TyCoBinder)

substTyAddInScope :: TCvSubst -> Type -> Type

Substitute within a Type after adding the free variables of the type to the in-scope set. This is useful for the case when the free variables aren't already in the in-scope set or easily available. See also Note [The substitution invariant].

substTy :: HasCallStack => TCvSubst -> Type -> Type

Substitute within a Type The substitution has to satisfy the invariants described in Note [The substitution invariant].

substThetaUnchecked :: TCvSubst -> ThetaType -> ThetaType

Substitute within a ThetaType disabling the sanity checks. The problems that the sanity checks in substTys catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substThetaUnchecked to substTheta and remove this function. Please don't use in new code.

substTheta :: HasCallStack => TCvSubst -> ThetaType -> ThetaType

Substitute within a ThetaType The substitution has to satisfy the invariants described in Note [The substitution invariant].

substScaledTysUnchecked :: TCvSubst -> [Scaled Type] -> [Scaled Type]

substScaledTys :: HasCallStack => TCvSubst -> [Scaled Type] -> [Scaled Type]

substScaledTyUnchecked :: HasCallStack => TCvSubst -> Scaled Type -> Scaled Type

substScaledTy :: HasCallStack => TCvSubst -> Scaled Type -> Scaled Type

substCoWithUnchecked :: [TyVar] -> [Type] -> Coercion -> Coercion

Coercion substitution, see zipTvSubst. Disables sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.

substCoUnchecked :: TCvSubst -> Coercion -> Coercion

Substitute within a Coercion disabling sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.

setTvSubstEnv :: TCvSubst -> TvSubstEnv -> TCvSubst

notElemTCvSubst :: Var -> TCvSubst -> Bool

mkTvSubstPrs :: [(TyVar, Type)] -> TCvSubst

Generates the in-scope set for the TCvSubst from the types in the incoming environment. No CoVars, please!

mkTvSubst :: InScopeSet -> TvSubstEnv -> TCvSubst

Make a TCvSubst with specified tyvar subst and empty covar subst

mkTCvSubst :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> TCvSubst

mkEmptyTCvSubst :: InScopeSet -> TCvSubst

lookupTyVar :: TCvSubst -> TyVar -> Maybe Type

isInScope :: Var -> TCvSubst -> Bool

isEmptyTCvSubst :: TCvSubst -> Bool

getTvSubstEnv :: TCvSubst -> TvSubstEnv

getTCvSubstRangeFVs :: TCvSubst -> VarSet

Returns the free variables of the types in the range of a substitution as a non-deterministic set.

getTCvInScope :: TCvSubst -> InScopeSet

extendTvSubstWithClone :: TCvSubst -> TyVar -> TyVar -> TCvSubst

extendTvSubstList :: TCvSubst -> [Var] -> [Type] -> TCvSubst

extendTvSubstBinderAndInScope :: TCvSubst -> TyCoBinder -> Type -> TCvSubst

extendTvSubstAndInScope :: TCvSubst -> TyVar -> Type -> TCvSubst

extendTvSubst :: TCvSubst -> TyVar -> Type -> TCvSubst

extendTCvSubstWithClone :: TCvSubst -> TyCoVar -> TyCoVar -> TCvSubst

extendTCvSubstList :: TCvSubst -> [Var] -> [Type] -> TCvSubst

extendTCvSubst :: TCvSubst -> TyCoVar -> Type -> TCvSubst

extendTCvInScopeSet :: TCvSubst -> VarSet -> TCvSubst

extendTCvInScopeList :: TCvSubst -> [Var] -> TCvSubst

extendTCvInScope :: TCvSubst -> Var -> TCvSubst

extendCvSubst :: TCvSubst -> CoVar -> Coercion -> TCvSubst

emptyTvSubstEnv :: TvSubstEnv

emptyTCvSubst :: TCvSubst

composeTCvSubstEnv :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv)

(compose env1 env2)(x) is env1(env2(x)); i.e. apply env2 then env1. It assumes that both are idempotent. Typically, env1 is the refinement to a base substitution env2

composeTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst

Composes two substitutions, applying the second one provided first, like in function composition.

cloneTyVarBndrs :: TCvSubst -> [TyVar] -> UniqSupply -> (TCvSubst, [TyVar])

cloneTyVarBndr :: TCvSubst -> TyVar -> Unique -> (TCvSubst, TyVar)

tidyVarBndrs :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])

This tidies up a type for printing in an error message, or in an interface file.

It doesn't change the uniques at all, just the print names.

tidyVarBndr :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)

tidyTypes :: TidyEnv -> [Type] -> [Type]

Tidy a list of Types

See Note [Strictness in tidyType and friends]

tidyType :: TidyEnv -> Type -> Type

Tidy a Type

See Note [Strictness in tidyType and friends]

tidyTyCoVarOcc :: TidyEnv -> TyCoVar -> TyCoVar

tidyTyCoVarBinders :: TidyEnv -> [VarBndr TyCoVar vis] -> (TidyEnv, [VarBndr TyCoVar vis])

tidyTyCoVarBinder :: TidyEnv -> VarBndr TyCoVar vis -> (TidyEnv, VarBndr TyCoVar vis)

tidyTopType :: Type -> Type

Calls tidyType on a top-level type (i.e. with an empty tidying environment)

tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])

Grabs the free type variables, tidies them and then uses tidyType to work over the type itself

tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)

tidyOpenTyCoVars :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])

tidyOpenTyCoVar :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)

Treat a new TyCoVar as a binder, and give it a fresh tidy name using the environment if one has not already been allocated. See also tidyVarBndr

tidyOpenKind :: TidyEnv -> Kind -> (TidyEnv, Kind)

tidyKind :: TidyEnv -> Kind -> Kind

tidyFreeTyCoVars :: TidyEnv -> [TyCoVar] -> TidyEnv

Add the free TyVars to the env in tidy form, so that we can tidy the type they are free in

tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]

Get the free vars of types in scoped order

tyCoVarsOfTypesList :: [Type] -> [TyCoVar]

Returns free variables of types, including kind variables as a deterministically ordered list. For type synonyms it does not expand the synonym.

tyCoVarsOfTypesDSet :: [Type] -> DTyCoVarSet

Returns free variables of types, including kind variables as a deterministic set. For type synonyms it does not expand the synonym.

tyCoVarsOfTypes :: [Type] -> TyCoVarSet

tyCoVarsOfTypeWellScoped :: Type -> [TyVar]

Get the free vars of a type in scoped order

tyCoVarsOfTypeList :: Type -> [TyCoVar]

tyCoFVsOfType that returns free variables of a type in deterministic order. For explanation of why using VarSet is not deterministic see Note [Deterministic FV] in GHC.Utils.FV.

tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet

tyCoFVsOfType that returns free variables of a type in a deterministic set. For explanation of why using VarSet is not deterministic see Note [Deterministic FV] in GHC.Utils.FV.

tyCoVarsOfType :: Type -> TyCoVarSet

tyCoFVsVarBndrs :: [Var] -> FV -> FV

tyCoFVsVarBndr :: Var -> FV -> FV

tyCoFVsOfTypes :: [Type] -> FV

tyCoFVsOfType :: Type -> FV

The worker for tyCoFVsOfType and tyCoFVsOfTypeList. The previous implementation used unionVarSet which is O(n+m) and can make the function quadratic. It's exported, so that it can be composed with other functions that compute free variables. See Note [FV naming conventions] in GHC.Utils.FV.

Eta-expanded because that makes it run faster (apparently) See Note [FV eta expansion] in GHC.Utils.FV for explanation.

tyCoFVsBndr :: TyCoVarBinder -> FV -> FV

scopedSort :: [TyCoVar] -> [TyCoVar]

Do a topological sort on a list of tyvars, so that binders occur before occurrences E.g. given [ a::k, k::*, b::k ] it'll return a well-scoped list [ k::*, a::k, b::k ]

This is a deterministic sorting operation (that is, doesn't depend on Uniques).

It is also meant to be stable: that is, variables should not be reordered unnecessarily. This is specified in Note [ScopedSort] See also Note [Ordering of implicit variables] in GHC.Rename.HsType

noFreeVarsOfType :: Type -> Bool

coVarsOfTypes :: [Type] -> CoVarSet

coVarsOfType :: Type -> CoVarSet

closeOverKindsList :: [TyVar] -> [TyVar]

Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministically ordered list.

closeOverKindsDSet :: DTyVarSet -> DTyVarSet

Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministic set.

closeOverKinds :: TyCoVarSet -> TyCoVarSet

anyFreeVarsOfTypes :: (TyCoVar -> Bool) -> [Type] -> Bool

anyFreeVarsOfType :: (TyCoVar -> Bool) -> Type -> Bool

data TyCoFolder env a

Constructors

TyCoFolder

Fields

• tcf_view :: Type -> Maybe Type
• tcf_tyvar :: env -> TyVar -> a
• tcf_covar :: env -> CoVar -> a
• tcf_hole :: env -> CoercionHole -> a

  What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.

• tcf_tycobinder :: env -> TyCoVar -> ArgFlag -> env

  The returned env is used in the extended scope

type TyBinder = TyCoBinder

TyBinder is like TyCoBinder, but there can only be TyVarBinder in the Named field.

type MCoercionR = MCoercion

type KnotTied ty = ty

A type labeled KnotTied might have knot-tied tycons in it. See Note [Type checking recursive type and class declarations] in GHC.Tc.TyCl

type KindOrType = Type

The key representation of types within the compiler

type KindCoercion = CoercionN

type CoercionR = Coercion

type CoercionP = Coercion

data CoercionHole

A coercion to be filled in by the type-checker. See Note [Coercion holes]

Constructors

CoercionHole

Fields

• ch_co_var :: CoVar
• ch_ref :: IORef (Maybe Coercion)

Instances

Data CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: CoercionHole -> Constr

dataTypeOf :: CoercionHole -> DataType

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

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

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

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

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

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

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

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

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

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

Uniquable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

getUnique :: CoercionHole -> Unique

Outputable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: CoercionHole -> SDoc

typeSize :: Type -> Int

setCoHoleCoVar :: CoercionHole -> CoVar -> CoercionHole

scaledThing :: Scaled a -> a

scaledMult :: Scaled a -> Mult

provSize :: UnivCoProvenance -> Int

nonDetCmpTyLit :: TyLit -> TyLit -> Ordering

mkVisFunTysMany :: [Type] -> Type -> Type

mkVisFunTys :: [Scaled Type] -> Type -> Type

Make nested arrow types

mkVisFunTyMany :: Type -> Type -> Type infixr 3

Special, common, case: Arrow type with mult Many

mkVisFunTy :: Mult -> Type -> Type -> Type infixr 3

mkTyVarTys :: [TyVar] -> [Type]

mkTyVarTy :: TyVar -> Type

mkTyCoVarTys :: [TyCoVar] -> [Type]

mkTyCoVarTy :: TyCoVar -> Type

mkScaledFunTy :: AnonArgFlag -> Scaled Type -> Type -> Type

mkPiTys :: [TyCoBinder] -> Type -> Type

mkPiTy :: TyCoBinder -> Type -> Type

mkInvisFunTysMany :: [Type] -> Type -> Type

mkInvisFunTyMany :: Type -> Type -> Type infixr 3

mkInvisFunTy :: Mult -> Type -> Type -> Type infixr 3

mkInvisForAllTys :: [InvisTVBinder] -> Type -> Type

Wraps foralls over the type using the provided InvisTVBinders from left to right

mkFunTy :: AnonArgFlag -> Mult -> Type -> Type -> Type infixr 3

mkForAllTys :: [TyCoVarBinder] -> Type -> Type

Wraps foralls over the type using the provided TyCoVars from left to right

mapScaledType :: (Type -> Type) -> Scaled Type -> Scaled Type

Apply a function to both the Mult and the Type in a 'Scaled Type'

isVisibleBinder :: TyCoBinder -> Bool

Does this binder bind a visible argument?

isTyBinder :: TyCoBinder -> Bool

If its a named binder, is the binder a tyvar? Returns True for nondependent binder. This check that we're really returning a *Ty*Binder (as opposed to a coercion binder). That way, if/when we allow coercion quantification in more places, we'll know we missed updating some function.

isNamedBinder :: TyCoBinder -> Bool

isInvisibleBinder :: TyCoBinder -> Bool

Does this binder bind an invisible argument?

foldTyCo :: Monoid a => TyCoFolder env a -> env -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a)

delBinderVar :: VarSet -> TyCoVarBinder -> VarSet

Remove the binder's variable from the set, if the binder has a variable.

coercionSize :: Coercion -> Int

coHoleCoVar :: CoercionHole -> CoVar

cmpTyLit :: TyLit -> TyLit -> Ordering

type TyConTyCoBinder = VarBndr TyCoVar TyConBndrVis

data TyConFlavour

Paints a picture of what a TyCon represents, in broad strokes. This is used towards more informative error messages.

Constructors

ClassFlavour

TupleFlavour Boxity

SumFlavour

DataTypeFlavour

NewtypeFlavour

AbstractTypeFlavour

DataFamilyFlavour (Maybe TyCon)

OpenTypeFamilyFlavour (Maybe TyCon)

ClosedTypeFamilyFlavour

TypeSynonymFlavour

BuiltInTypeFlavour

e.g., the (->) TyCon.

PromotedDataConFlavour

Instances

Outputable TyConFlavour

Defined in GHC.Core.TyCon

Methods

ppr :: TyConFlavour -> SDoc

Eq TyConFlavour

Defined in GHC.Core.TyCon

Methods

(==) :: TyConFlavour -> TyConFlavour -> Bool

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

data TyConBndrVis

Constructors

NamedTCB ArgFlag

AnonTCB AnonArgFlag

Instances

Binary TyConBndrVis

Defined in GHC.Core.TyCon

Methods

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

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

get :: BinHandle -> IO TyConBndrVis

Outputable TyConBndrVis

Defined in GHC.Core.TyCon

Methods

ppr :: TyConBndrVis -> SDoc

OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)

Defined in GHC.Core.TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

type TyConBinder = VarBndr TyVar TyConBndrVis

data RuntimeRepInfo

Some promoted datacons signify extra info relevant to GHC. For example, the IntRep constructor of RuntimeRep corresponds to the IntRep constructor of PrimRep. This data structure allows us to store this information right in the TyCon. The other approach would be to look up things like RuntimeRep's PrimRep by known-key every time. See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType

Constructors

NoRRI

an ordinary promoted data con

RuntimeRep ([Type] -> [PrimRep])

A constructor of RuntimeRep. The argument to the function should be the list of arguments to the promoted datacon.

VecCount Int

A constructor of VecCount

VecElem PrimElemRep

A constructor of VecElem

LiftedInfo

A constructor of Levity

UnliftedInfo

A constructor of Levity

data PrimRep

A PrimRep is an abstraction of a type. It contains information that the code generator needs in order to pass arguments, return results, and store values of this type. See also Note [RuntimeRep and PrimRep] in GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.

Constructors

VoidRep

LiftedRep

UnliftedRep

Unlifted pointer

Int8Rep

Signed, 8-bit value

Int16Rep

Signed, 16-bit value

Int32Rep

Signed, 32-bit value

Int64Rep

Signed, 64 bit value

IntRep

Signed, word-sized value

Word8Rep

Unsigned, 8 bit value

Word16Rep

Unsigned, 16 bit value

Word32Rep

Unsigned, 32 bit value

Word64Rep

Unsigned, 64 bit value

WordRep

Unsigned, word-sized value

AddrRep

A pointer, but not to a Haskell value (use '(Un)liftedRep')

FloatRep

DoubleRep

VecRep Int PrimElemRep

A vector

Instances

Show PrimRep

Defined in GHC.Core.TyCon

Methods

showsPrec :: Int -> PrimRep -> ShowS

show :: PrimRep -> String

showList :: [PrimRep] -> ShowS

Outputable PrimRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimRep -> SDoc

Eq PrimRep

Defined in GHC.Core.TyCon

Methods

(==) :: PrimRep -> PrimRep -> Bool

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

data PrimElemRep

Constructors

Int8ElemRep

Int16ElemRep

Int32ElemRep

Int64ElemRep

Word8ElemRep

Word16ElemRep

Word32ElemRep

Word64ElemRep

FloatElemRep

DoubleElemRep

Instances

Show PrimElemRep

Defined in GHC.Core.TyCon

Methods

showsPrec :: Int -> PrimElemRep -> ShowS

show :: PrimElemRep -> String

showList :: [PrimElemRep] -> ShowS

Outputable PrimElemRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimElemRep -> SDoc

Eq PrimElemRep

Defined in GHC.Core.TyCon

Methods

(==) :: PrimElemRep -> PrimElemRep -> Bool

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

data Injectivity

Constructors

NotInjective

Injective [Bool]

Instances

Binary Injectivity

Defined in GHC.Core.TyCon

Methods

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

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

get :: BinHandle -> IO Injectivity

Eq Injectivity

Defined in GHC.Core.TyCon

Methods

(==) :: Injectivity -> Injectivity -> Bool

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

data FamTyConFlav

Information pertaining to the expansion of a type synonym (type)

Constructors

DataFamilyTyCon TyConRepName

Represents an open type family without a fixed right hand side. Additional instances can appear at any time.

These are introduced by either a top level declaration:

data family T a :: *

Or an associated data type declaration, within a class declaration:

class C a b where
  data T b :: *

OpenSynFamilyTyCon

An open type synonym family e.g. type family F x y :: * -> *

ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))

A closed type synonym family e.g. type family F x where { F Int = Bool }

AbstractClosedSynFamilyTyCon

A closed type synonym family declared in an hs-boot file with type family F a where ..

BuiltInSynFamTyCon BuiltInSynFamily

Built-in type family used by the TypeNats solver

Instances

Outputable FamTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: FamTyConFlav -> SDoc

data AlgTyConRhs

Represents right-hand-sides of TyCons for algebraic types

Constructors

AbstractTyCon

Says that we know nothing about this data type, except that it's represented by a pointer. Used when we export a data type abstractly into an .hi file.

DataTyCon

Information about those TyCons derived from a data declaration. This includes data types with no constructors at all.

Fields

• data_cons :: [DataCon]

  The data type constructors; can be empty if the user declares the type to have no constructors

  INVARIANT: Kept in order of increasing DataCon tag (see the tag assignment in mkTyConTagMap)

• data_cons_size :: Int

  Cached value: length data_cons

• is_enum :: Bool

  Cached value: is this an enumeration type? See Note [Enumeration types]

TupleTyCon

Fields

• data_con :: DataCon

  The unique constructor for the newtype. It has no existentials

• tup_sort :: TupleSort

  Is this a boxed, unboxed or constraint tuple?

SumTyCon

An unboxed sum type.

Fields

• data_cons :: [DataCon]

  The data type constructors; can be empty if the user declares the type to have no constructors

  INVARIANT: Kept in order of increasing DataCon tag (see the tag assignment in mkTyConTagMap)

• data_cons_size :: Int

  Cached value: length data_cons

NewTyCon

Information about those TyCons derived from a newtype declaration

Fields

• data_con :: DataCon

  The unique constructor for the newtype. It has no existentials

• nt_rhs :: Type

  Cached value: the argument type of the constructor, which is just the representation type of the TyCon (remember that newtypes do not exist at runtime so need a different representation type).

  The free TyVars of this type are the tyConTyVars from the corresponding TyCon

• nt_etad_rhs :: ([TyVar], Type)

  Same as the nt_rhs, but this time eta-reduced. Hence the list of TyVars in this field may be shorter than the declared arity of the TyCon.

• nt_co :: CoAxiom Unbranched
• nt_lev_poly :: Bool

data AlgTyConFlav

Constructors

VanillaAlgTyCon TyConRepName

An ordinary type constructor has no parent.

UnboxedAlgTyCon (Maybe TyConRepName)

An unboxed type constructor. The TyConRepName is a Maybe since we currently don't allow unboxed sums to be Typeable since there are too many of them. See #13276.

ClassTyCon Class TyConRepName

Type constructors representing a class dictionary. See Note [ATyCon for classes] in GHC.Core.TyCo.Rep

DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type]

Type constructors representing an *instance* of a *data* family. Parameters:

1) The type family in question

2) Instance types; free variables are the tyConTyVars of the current TyCon (not the family one). INVARIANT: the number of types matches the arity of the family TyCon

3) A CoTyCon identifying the representation type with the type instance family

Instances

Outputable AlgTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: AlgTyConFlav -> SDoc

visibleDataCons :: AlgTyConRhs -> [DataCon]

Both type classes as well as family instances imply implicit type constructors. These implicit type constructors refer to their parent structure (ie, the class or family from which they derive) using a type of the following form.

Extract those DataCons that we are able to learn about. Note that visibility in this sense does not correspond to visibility in the context of any particular user program!

unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)

Take a TyCon apart into the TyVars it scopes over, the Type it expands into, and (possibly) a coercion from the representation type to the newtype. Returns Nothing if this is not possible.

unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)

tyConVisibleTyVars :: TyCon -> [TyVar]

tyConTuple_maybe :: TyCon -> Maybe TupleSort

tyConStupidTheta :: TyCon -> [PredType]

Find the "stupid theta" of the TyCon. A "stupid theta" is the context to the left of an algebraic type declaration, e.g. Eq a in the declaration data Eq a => T a ...

tyConSkolem :: TyCon -> Bool

Returns whether or not this TyCon is definite, or a hole that may be filled in at some later point. See Note [Skolem abstract data]

tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon

If the given TyCon has a single data constructor, i.e. it is a data type with one alternative, a tuple type or a newtype then that constructor is returned. If the TyCon has more than one constructor, or represents a primitive or function type constructor then Nothing is returned.

tyConSingleDataCon :: TyCon -> DataCon

Like tyConSingleDataCon_maybe, but panics if Nothing.

tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon

Like tyConSingleDataCon_maybe, but returns Nothing for newtypes.

tyConRuntimeRepInfo :: TyCon -> RuntimeRepInfo

Extract any RuntimeRepInfo from this TyCon

tyConRoles :: TyCon -> [Role]

Get the list of roles for the type parameters of a TyCon

tyConRepModOcc :: Module -> OccName -> (Module, OccName)

The name (and defining module) for the Typeable representation (TyCon) of a type constructor.

See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.

tyConInvisTVBinders :: [TyConBinder] -> [InvisTVBinder]

tyConInjectivityInfo :: TyCon -> Injectivity

tyConInjectivityInfo tc returns Injective is if tc is an injective tycon (where is states for which tyConBinders tc is injective), or NotInjective otherwise.

tyConFlavourAssoc_maybe :: TyConFlavour -> Maybe TyCon

Get the enclosing class TyCon (if there is one) for the given TyConFlavour

tyConFlavour :: TyCon -> TyConFlavour

tyConFieldLabels :: TyCon -> [FieldLabel]

The labels for the fields of this particular TyCon

tyConFamilySize :: TyCon -> Int

Determine the number of value constructors a TyCon has. Panics if the TyCon is not algebraic or a tuple

tyConFamilyResVar_maybe :: TyCon -> Maybe Name

Extract type variable naming the result of injective type family

tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)

If this TyCon is that of a data family instance, return a TyCon which represents a coercion identifying the representation type with the type instance family. Otherwise, return Nothing

tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])

If this TyCon is that of a data family instance, return the family in question and the instance types. Otherwise, return Nothing

tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)

tyConDataCons_maybe :: TyCon -> Maybe [DataCon]

Determine the DataCons originating from the given TyCon, if the TyCon is the sort that can have any constructors (note: this does not include abstract algebraic types)

tyConDataCons :: TyCon -> [DataCon]

As tyConDataCons_maybe, but returns the empty list of constructors if no constructors could be found

tyConClass_maybe :: TyCon -> Maybe Class

If this TyCon is that for a class instance, return the class it is for. Otherwise returns Nothing

tyConCType_maybe :: TyCon -> Maybe CType

tyConBndrVisArgFlag :: TyConBndrVis -> ArgFlag

tyConBinderArgFlag :: TyConBinder -> ArgFlag

tyConAssoc_maybe :: TyCon -> Maybe TyCon

Get the enclosing class TyCon (if there is one) for the given TyCon.

tyConAlgDataCons_maybe :: TyCon -> Maybe [DataCon]

Returns Just dcs if the given TyCon is a data type, a tuple type or a sum type with data constructors dcs. If the TyCon has more than one constructor, or represents a primitive or function type constructor then Nothing is returned.

Like tyConDataCons_maybe, but returns Nothing for newtypes.

tyConATs :: TyCon -> [TyCon]

Return the associated types of the TyCon, if any

tcFlavourIsOpen :: TyConFlavour -> Bool

Is this flavour of TyCon an open type family or a data family?

synTyConRhs_maybe :: TyCon -> Maybe Type

Extract the information pertaining to the right hand side of a type synonym (type) declaration.

synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)

Extract the TyVars bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

setTcTyConKind :: TyCon -> Kind -> TyCon

primRepsCompatible :: Platform -> [PrimRep] -> [PrimRep] -> Bool

primRepSizeB :: Platform -> PrimRep -> Int

The size of a PrimRep in bytes.

This applies also when used in a constructor, where we allow packing the fields. For instance, in data Foo = Foo Float# Float# the two fields will take only 8 bytes, which for 64-bit arch will be equal to 1 word. See also mkVirtHeapOffsetsWithPadding for details of how data fields are laid out.

primRepIsFloat :: PrimRep -> Maybe Bool

Return if Rep stands for floating type, returns Nothing for vector types.

primRepCompatible :: Platform -> PrimRep -> PrimRep -> Bool

primElemRepSizeB :: PrimElemRep -> Int

pprPromotionQuote :: TyCon -> SDoc

noTcTyConScopedTyVars :: [(Name, TcTyVar)]

No scoped type variables (to be used with mkTcTyCon).

newTyConRhs :: TyCon -> ([TyVar], Type)

Extract the bound type variables and type expansion of a type synonym TyCon. Panics if the TyCon is not a synonym

newTyConEtadRhs :: TyCon -> ([TyVar], Type)

Extract the bound type variables and type expansion of an eta-contracted type synonym TyCon. Panics if the TyCon is not a synonym

newTyConEtadArity :: TyCon -> Int

The number of type parameters that need to be passed to a newtype to resolve it. May be less than in the definition if it can be eta-contracted.

newTyConDataCon_maybe :: TyCon -> Maybe DataCon

newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)

Extracts the newtype coercion from such a TyCon, which can be used to construct something with the newtypes type from its representation type (right hand side). If the supplied TyCon is not a newtype, returns Nothing

newTyConCo :: TyCon -> CoAxiom Unbranched

mustBeSaturated :: TyCon -> Bool

True iff we can decompose (T a b c) into ((T a b) c) I.e. is it injective and generative w.r.t nominal equality? That is, if (T a b) ~N d e f, is it always the case that (T ~N d), (a ~N e) and (b ~N f)? Specifically NOT true of synonyms (open and otherwise)

It'd be unusual to call mustBeSaturated on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable

mkTyConTagMap :: TyCon -> NameEnv ConTag

mkTyConKind :: [TyConBinder] -> Kind -> Kind

mkTupleTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

Result kind of the TyCon

-> Arity

Arity of the tuple TyCon

-> DataCon

-> TupleSort

Whether the tuple is boxed or unboxed

-> AlgTyConFlav

-> TyCon

mkTcTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind only

-> [(Name, TcTyVar)]

Scoped type variables; see Note [How TcTyCons work] in GHC.Tc.TyCl

-> Bool

Is this TcTyCon generalised already?

-> TyConFlavour

What sort of TyCon this represents

-> TyCon

Makes a tycon suitable for use during type-checking. It stores a variety of details about the definition of the TyCon, but no right-hand side. It lives only during the type-checking of a mutually-recursive group of tycons; it is then zonked to a proper TyCon in zonkTcTyCon. See also Note [Kind checking recursive type and class declarations] in GHC.Tc.TyCl.

mkSynonymTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> Type

-> Bool

-> Bool

-> Bool

-> TyCon

Create a type synonym TyCon

mkSumTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

Kind of the resulting TyCon

-> Arity

Arity of the sum

-> [TyVar]

TyVars scoped over: see tyConTyVars

-> [DataCon]

-> AlgTyConFlav

-> TyCon

mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder

Make a Required TyConBinder. It chooses between NamedTCB and AnonTCB based on whether the tv is mentioned in the dependent set

mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConTyCoBinder] -> Kind -> [Role] -> RuntimeRepInfo -> TyCon

Create a promoted data constructor TyCon Somewhat dodgily, we give it the same Name as the data constructor itself; when we pretty-print the TyCon we add a quote; see the Outputable TyCon instance

mkPrimTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind, never levity-polymorphic

-> [Role]

-> TyCon

Create an unlifted primitive TyCon, such as Int#.

mkNamedTyConBinders :: ArgFlag -> [TyVar] -> [TyConBinder]

mkNamedTyConBinder :: ArgFlag -> TyVar -> TyConBinder

mkLiftedPrimTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> TyCon

Create a lifted primitive TyCon such as RealWorld

mkKindTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> Name

-> TyCon

Kind constructors

mkFunTyCon :: Name -> [TyConBinder] -> Name -> TyCon

Given the name of the function type constructor and it's kind, create the corresponding TyCon. It is recommended to use funTyCon if you want this functionality

mkFamilyTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> Maybe Name

-> FamTyConFlav

-> Maybe Class

-> Injectivity

-> TyCon

Create a type family TyCon

mkDataTyConRhs :: [DataCon] -> AlgTyConRhs

mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon

Simpler specialization of mkAlgTyCon for classes

mkAnonTyConBinders :: AnonArgFlag -> [TyVar] -> [TyConBinder]

mkAnonTyConBinder :: AnonArgFlag -> TyVar -> TyConBinder

mkAlgTyCon

Arguments

:: Name

-> [TyConBinder]

Binders of the TyCon

-> Kind

Result kind

-> [Role]

The roles for each TyVar

-> Maybe CType

The C type this type corresponds to when using the CAPI FFI

-> [PredType]

Stupid theta: see algTcStupidTheta

-> AlgTyConRhs

Information about data constructors

-> AlgTyConFlav

What flavour is it? (e.g. vanilla, type family)

-> Bool

Was the TyCon declared with GADT syntax?

-> TyCon

This is the making of an algebraic TyCon.

lookupTyConFieldLabel :: FieldLabelString -> TyCon -> Maybe FieldLabel

Look up a field label belonging to this TyCon

isVoidRep :: PrimRep -> Bool

isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool

isVanillaAlgTyCon :: TyCon -> Bool

Returns True for vanilla AlgTyCons -- that is, those created with a data or newtype declaration.

isUnliftedTyCon :: TyCon -> Bool

Is this TyCon unlifted (i.e. cannot contain bottom)? Note that this can only be true for primitive and unboxed-tuple TyCons

isUnboxedSumTyCon :: TyCon -> Bool

Is this the TyCon for an unboxed sum?

isTypeSynonymTyCon :: TyCon -> Bool

Is this a TyCon representing a regular H98 type synonym (type)?

isTypeFamilyTyCon :: TyCon -> Bool

Is this a synonym TyCon that can have may have further instances appear?

isTyConWithSrcDataCons :: TyCon -> Bool

Check if the tycon actually refers to a proper `data` or `newtype` with user defined constructors rather than one from a class or other construction.

isTyConAssoc :: TyCon -> Bool

Is this TyCon for an associated type?

isTcTyCon :: TyCon -> Bool

Is this a TcTyCon? (That is, one only used during type-checking?)

isTcLevPoly :: TyCon -> Bool

Could this TyCon ever be levity-polymorphic when fully applied? True is safe. False means we're sure. Does only a quick check based on the TyCon's category. Precondition: The fully-applied TyCon has kind (TYPE blah)

isTauTyCon :: TyCon -> Bool

isPromotedTupleTyCon :: TyCon -> Bool

Is this the TyCon for a promoted tuple?

isPromotedDataCon_maybe :: TyCon -> Maybe DataCon

Retrieves the promoted DataCon if this is a PromotedDataCon;

isPromotedDataCon :: TyCon -> Bool

Is this a PromotedDataCon?

isPrimTyCon :: TyCon -> Bool

Does this TyCon represent something that cannot be defined in Haskell?

isOpenTypeFamilyTyCon :: TyCon -> Bool

Is this an open type family TyCon?

isOpenFamilyTyCon :: TyCon -> Bool

Is this a TyCon, synonym or otherwise, that defines a family with instances?

isNoParent :: AlgTyConFlav -> Bool

isNewTyCon :: TyCon -> Bool

Is this TyCon that for a newtype

isNamedTyConBinder :: TyConBinder -> Bool

isLiftedTypeKindTyConName :: Name -> Bool

isLiftedAlgTyCon :: TyCon -> Bool

isKindTyCon :: TyCon -> Bool

Is this tycon really meant for use at the kind level? That is, should it be permitted without -XDataKinds?

isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool

isInjectiveTyCon :: TyCon -> Role -> Bool

isInjectiveTyCon is true of TyCons for which this property holds (where X is the role passed in): If (T a1 b1 c1) ~X (T a2 b2 c2), then (a1 ~X1 a2), (b1 ~X2 b2), and (c1 ~X3 c2) (where X1, X2, and X3, are the roles given by tyConRolesX tc X) See also Note [Decomposing equality] in GHC.Tc.Solver.Canonical

isImplicitTyCon :: TyCon -> Bool

Identifies implicit tycons that, in particular, do not go into interface files (because they are implicitly reconstructed when the interface is read).

Note that:

• Associated families are implicit, as they are re-constructed from the class declaration in which they reside, and
• Family instances are not implicit as they represent the instance body (similar to a dfun does that for a class instance).
• Tuples are implicit iff they have a wired-in name (namely: boxed and unboxed tuples are wired-in and implicit, but constraint tuples are not)

isGenerativeTyCon :: TyCon -> Role -> Bool

isGenerativeTyCon is true of TyCons for which this property holds (where X is the role passed in): If (T tys ~X t), then (t's head ~X T). See also Note [Decomposing equality] in GHC.Tc.Solver.Canonical

isGenInjAlgRhs :: AlgTyConRhs -> Bool

Is this an AlgTyConRhs of a TyCon that is generative and injective with respect to representational equality?

isGcPtrRep :: PrimRep -> Bool

isGadtSyntaxTyCon :: TyCon -> Bool

Is this an algebraic TyCon declared with the GADT syntax?

isForgetfulSynTyCon :: TyCon -> Bool

Is this a forgetful type synonym? If this is a type synonym whose RHS does not mention one (or more) of its bound variables, returns True. Thus, False means that all bound variables appear on the RHS; True may not mean anything, as the test to set this flag is conservative.

isFamilyTyCon :: TyCon -> Bool

Is this a TyCon, synonym or otherwise, that defines a family?

isFamInstTyCon :: TyCon -> Bool

Is this TyCon that for a data family instance?

isFamFreeTyCon :: TyCon -> Bool

Is this tycon neither a type family nor a synonym that expands to a type family?

isEnumerationTyCon :: TyCon -> Bool

Is this an algebraic TyCon which is just an enumeration of values?

isDataTyCon :: TyCon -> Bool

Returns True for data types that are definitely represented by heap-allocated constructors. These are scrutinised by Core-level case expressions, and they get info tables allocated for them.

Generally, the function will be true for all data types and false for newtypes, unboxed tuples, unboxed sums and type family TyCons. But it is not guaranteed to return True in all cases that it could.

NB: for a data type family, only the instance TyCons get an info table. The family declaration TyCon does not

isDataFamilyTyCon :: TyCon -> Bool

Is this a synonym TyCon that can have may have further instances appear?

isConstraintKindCon :: TyCon -> Bool

Returns True for the TyCon of the Constraint kind.

isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)

Is this a non-empty closed type family? Returns Nothing for abstract or empty closed families.

isClassTyCon :: TyCon -> Bool

Is this TyCon that for a class instance?

isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily

isBoxedTupleTyCon :: TyCon -> Bool

Is this the TyCon for a boxed tuple?

isAlgTyCon :: TyCon -> Bool

Returns True if the supplied TyCon resulted from either a data or newtype declaration

isAbstractTyCon :: TyCon -> Bool

Test if the TyCon is algebraic but abstract (invisible data constructors)

famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav

Extract the flavour of a type family (with all the extra information that it carries)

expandSynTyCon_maybe

Arguments

:: TyCon

-> [tyco]

Arguments to TyCon

-> Maybe ([(TyVar, tyco)], Type, [tyco])

Returns a TyVar substitution, the body type of the synonym (not yet substituted) and any arguments remaining from the application ^ Expand a type synonym application Return Nothing if the TyCon is not a synonym, or if not enough arguments are supplied

algTyConRhs :: TyCon -> AlgTyConRhs

Extract an AlgTyConRhs with information about data constructors from an algebraic or tuple TyCon. Panics for any other sort of TyCon

nilDataConKey :: Unique

listTyConKey :: Unique

type DefMethInfo = Maybe (Name, DefMethSpec Type)

type ClassOpItem = (Id, DefMethInfo)

type ClassMinimalDef = BooleanFormula Name

data ClassATItem

Constructors

ATI TyCon (Maybe (Type, ATValidityInfo))

data Class

Instances

Data Class

Defined in GHC.Core.Class

Methods

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

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

toConstr :: Class -> Constr

dataTypeOf :: Class -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing Class

Defined in GHC.Core.Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

Uniquable Class

Defined in GHC.Core.Class

Methods

getUnique :: Class -> Unique

Outputable Class

Defined in GHC.Core.Class

Methods

ppr :: Class -> SDoc

Eq Class

Defined in GHC.Core.Class

Methods

(==) :: Class -> Class -> Bool

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

data ATValidityInfo

Information about an associated type family default implementation. This is used solely for validity checking. See Note [Type-checking default assoc decls] in GHC.Tc.TyCl.

Constructors

NoATVI

ATVI SrcSpan [Type]

pprFundeps :: Outputable a => [FunDep a] -> SDoc

pprFunDep :: Outputable a => FunDep a -> SDoc

pprDefMethInfo :: DefMethInfo -> SDoc

mkClass :: Name -> [TyVar] -> [FunDep TyVar] -> [PredType] -> [Id] -> [ClassATItem] -> [ClassOpItem] -> ClassMinimalDef -> TyCon -> Class

mkAbstractClass :: Name -> [TyVar] -> [FunDep TyVar] -> TyCon -> Class

isAbstractClass :: Class -> Bool

classTvsFds :: Class -> ([TyVar], [FunDep TyVar])

classSCTheta :: Class -> [PredType]

classSCSelIds :: Class -> [Id]

classSCSelId :: Class -> Int -> Id

classOpItems :: Class -> [ClassOpItem]

classMinimalDef :: Class -> ClassMinimalDef

classMethods :: Class -> [Id]

classHasFds :: Class -> Bool

classExtraBigSig :: Class -> ([TyVar], [FunDep TyVar], [PredType], [Id], [ClassATItem], [ClassOpItem])

classBigSig :: Class -> ([TyVar], [PredType], [Id], [ClassOpItem])

classArity :: Class -> Arity

classAllSelIds :: Class -> [Id]

classATs :: Class -> [TyCon]

classATItems :: Class -> [ClassATItem]

data Role

Constructors

Nominal

Representational

Phantom

Instances

Data Role

Defined in GHC.Core.Coercion.Axiom

Methods

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

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

toConstr :: Role -> Constr

dataTypeOf :: Role -> DataType

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

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

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

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

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

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

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

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

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

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

Binary Role

Defined in GHC.Core.Coercion.Axiom

Methods

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

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

get :: BinHandle -> IO Role

Outputable Role

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: Role -> SDoc

Eq Role

Defined in GHC.Core.Coercion.Axiom

Methods

(==) :: Role -> Role -> Bool

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

Ord Role

Defined in GHC.Core.Coercion.Axiom

Methods

compare :: Role -> Role -> Ordering

(<) :: Role -> Role -> Bool

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

(>) :: Role -> Role -> Bool

(>=) :: Role -> Role -> Bool

max :: Role -> Role -> Role

min :: Role -> Role -> Role

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcSpan

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcSpan

data TrailingAnn

Captures the location of punctuation occuring between items, normally in a list. It is captured as a trailing annotation.

Constructors

AddSemiAnn EpaLocation

Trailing ';'

AddCommaAnn EpaLocation

Trailing ','

AddVbarAnn EpaLocation

Trailing '|'

AddRarrowAnn EpaLocation

Trailing ->

AddRarrowAnnU EpaLocation

Trailing ->, unicode variant

AddLollyAnnU EpaLocation

Trailing ⊸

Instances

Data TrailingAnn

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: TrailingAnn -> Constr

dataTypeOf :: TrailingAnn -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable TrailingAnn

Defined in GHC.Parser.Annotation

Methods

ppr :: TrailingAnn -> SDoc

Eq TrailingAnn

Defined in GHC.Parser.Annotation

Methods

(==) :: TrailingAnn -> TrailingAnn -> Bool

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

Ord TrailingAnn

Defined in GHC.Parser.Annotation

Methods

compare :: TrailingAnn -> TrailingAnn -> Ordering

(<) :: TrailingAnn -> TrailingAnn -> Bool

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

(>) :: TrailingAnn -> TrailingAnn -> Bool

(>=) :: TrailingAnn -> TrailingAnn -> Bool

max :: TrailingAnn -> TrailingAnn -> TrailingAnn

min :: TrailingAnn -> TrailingAnn -> TrailingAnn

type SrcSpanAnnP = SrcAnn AnnPragma

type SrcSpanAnnN = SrcAnn NameAnn

type SrcSpanAnnL = SrcAnn AnnList

type SrcSpanAnnC = SrcAnn AnnContext

type SrcSpanAnnA = SrcAnn AnnListItem

data SrcSpanAnn' a

The 'SrcSpanAnn'' type wraps a normal SrcSpan, together with an extra annotation type. This is mapped to a specific GenLocated usage in the AST through the XRec and Anno type families.

Constructors

SrcSpanAnn

Fields

• ann :: !a
• locA :: !SrcSpan

Instances

Data a => Data (SrcSpanAnn' a)

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: SrcSpanAnn' a -> Constr

dataTypeOf :: SrcSpanAnn' a -> DataType

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

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

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

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

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

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

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

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

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

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

Semigroup an => Semigroup (SrcSpanAnn' an)

Defined in GHC.Parser.Annotation

Methods

(<>) :: SrcSpanAnn' an -> SrcSpanAnn' an -> SrcSpanAnn' an

sconcat :: NonEmpty (SrcSpanAnn' an) -> SrcSpanAnn' an

stimes :: Integral b => b -> SrcSpanAnn' an -> SrcSpanAnn' an

Binary a => Binary (LocatedL a)

Defined in GHC.Parser.Annotation

Methods

put_ :: BinHandle -> LocatedL a -> IO ()

put :: BinHandle -> LocatedL a -> IO (Bin (LocatedL a))

get :: BinHandle -> IO (LocatedL a)

Outputable a => Outputable (SrcSpanAnn' a)

Defined in GHC.Parser.Annotation

Methods

ppr :: SrcSpanAnn' a -> SDoc

Eq a => Eq (SrcSpanAnn' a)

Defined in GHC.Parser.Annotation

Methods

(==) :: SrcSpanAnn' a -> SrcSpanAnn' a -> Bool

(/=) :: SrcSpanAnn' a -> SrcSpanAnn' a -> Bool

NamedThing (Located a) => NamedThing (LocatedAn an a)

Defined in GHC.Parser.Annotation

Methods

getOccName :: LocatedAn an a -> OccName

getName :: LocatedAn an a -> Name

(Outputable a, Outputable e) => Outputable (GenLocated (SrcSpanAnn' a) e)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated (SrcSpanAnn' a) e -> SDoc

type Anno (LocatedA (IE (GhcPass p)))

Defined in GHC.Hs.ImpExp

type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno (LocatedN RdrName)

Defined in GHC.Hs.Binds

type Anno (LocatedN RdrName) = SrcSpan

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedA (IE (GhcPass p))]

Defined in GHC.Hs.ImpExp

type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.PostProcess

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.Types

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (ConDeclField (GhcPass _1))]

Defined in GHC.Hs.Decls

type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type Anno [LocatedA (HsType (GhcPass p))]

Defined in GHC.Hs.Type

type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

type Anno [LocatedN RdrName]

Defined in GHC.Hs.Binds

type Anno [LocatedN RdrName] = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type Anno (FamEqn p (LocatedA (HsType p)))

Defined in GHC.Hs.Decls

type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpan

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpan

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpan

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p)))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))

Defined in GHC.Hs.Expr

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

type SrcAnn ann = SrcSpanAnn' (EpAnn ann)

We mostly use 'SrcSpanAnn'' with an 'EpAnn''

data ParenType

Detail of the "brackets" used in an AnnParen exact print annotation.

Constructors

AnnParens

'(', ')'

AnnParensHash

'(#', '#)'

AnnParensSquare

'[', ']'

Instances

Data ParenType

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: ParenType -> Constr

dataTypeOf :: ParenType -> DataType

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

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

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

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

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

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

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

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

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

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

Eq ParenType

Defined in GHC.Parser.Annotation

Methods

(==) :: ParenType -> ParenType -> Bool

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

Ord ParenType

Defined in GHC.Parser.Annotation

Methods

compare :: ParenType -> ParenType -> Ordering

(<) :: ParenType -> ParenType -> Bool

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

(>) :: ParenType -> ParenType -> Bool

(>=) :: ParenType -> ParenType -> Bool

max :: ParenType -> ParenType -> ParenType

min :: ParenType -> ParenType -> ParenType

data NoEpAnns

Constructors

NoEpAnns

Instances

Data NoEpAnns

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: NoEpAnns -> Constr

dataTypeOf :: NoEpAnns -> DataType

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

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

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

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

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

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

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

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

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

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

Eq NoEpAnns

Defined in GHC.Parser.Annotation

Methods

(==) :: NoEpAnns -> NoEpAnns -> Bool

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

Ord NoEpAnns

Defined in GHC.Parser.Annotation

Methods

compare :: NoEpAnns -> NoEpAnns -> Ordering

(<) :: NoEpAnns -> NoEpAnns -> Bool

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

(>) :: NoEpAnns -> NoEpAnns -> Bool

(>=) :: NoEpAnns -> NoEpAnns -> Bool

max :: NoEpAnns -> NoEpAnns -> NoEpAnns

min :: NoEpAnns -> NoEpAnns -> NoEpAnns

data NameAnn

exact print annotations for a RdrName. There are many kinds of adornment that can be attached to a given RdrName. This type captures them, as detailed on the individual constructors.

Constructors

NameAnn

Used for a name with an adornment, so `foo`, (bar)

Fields

• nann_adornment :: NameAdornment
• nann_open :: EpaLocation
• nann_name :: EpaLocation
• nann_close :: EpaLocation
• nann_trailing :: [TrailingAnn]

NameAnnCommas

Used for (,,,), or @()#

Fields

• nann_adornment :: NameAdornment
• nann_open :: EpaLocation
• nann_commas :: [EpaLocation]
• nann_close :: EpaLocation
• nann_trailing :: [TrailingAnn]

NameAnnOnly

Used for (), (##), []

Fields

• nann_adornment :: NameAdornment
• nann_open :: EpaLocation
• nann_close :: EpaLocation
• nann_trailing :: [TrailingAnn]

NameAnnRArrow

Used for ->, as an identifier

Fields

• nann_name :: EpaLocation
• nann_trailing :: [TrailingAnn]

NameAnnQuote

Used for an item with a leading '. The annotation for unquoted item is stored in nann_quoted.

Fields

• nann_quote :: EpaLocation
• nann_quoted :: SrcSpanAnnN
• nann_trailing :: [TrailingAnn]

NameAnnTrailing

Used when adding a TrailingAnn to an existing LocatedN which has no Api Annotation (via the EpAnnNotUsed constructor.

Fields

• nann_trailing :: [TrailingAnn]

Instances

Data NameAnn

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: NameAnn -> Constr

dataTypeOf :: NameAnn -> DataType

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

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

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

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

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

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

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

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

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

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

Monoid NameAnn

Defined in GHC.Parser.Annotation

Methods

mempty :: NameAnn

mappend :: NameAnn -> NameAnn -> NameAnn

mconcat :: [NameAnn] -> NameAnn

Semigroup NameAnn

Defined in GHC.Parser.Annotation

Methods

(<>) :: NameAnn -> NameAnn -> NameAnn

sconcat :: NonEmpty NameAnn -> NameAnn

stimes :: Integral b => b -> NameAnn -> NameAnn

Outputable NameAnn

Defined in GHC.Parser.Annotation

Methods

ppr :: NameAnn -> SDoc

Eq NameAnn

Defined in GHC.Parser.Annotation

Methods

(==) :: NameAnn -> NameAnn -> Bool

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

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno (LocatedN RdrName)

Defined in GHC.Hs.Binds

type Anno (LocatedN RdrName) = SrcSpan

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

type Anno [LocatedN RdrName]

Defined in GHC.Hs.Binds

type Anno [LocatedN RdrName] = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

data NameAdornment

A NameAnn can capture the locations of surrounding adornments, such as parens or backquotes. This data type identifies what particular pair are being used.

Constructors

NameParens

'(' ')'

NameParensHash

'(#' '#)'

NameBackquotes

'`'

NameSquare

'[' ']'

Instances

Data NameAdornment

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: NameAdornment -> Constr

dataTypeOf :: NameAdornment -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable NameAdornment

Defined in GHC.Parser.Annotation

Methods

ppr :: NameAdornment -> SDoc

Eq NameAdornment

Defined in GHC.Parser.Annotation

Methods

(==) :: NameAdornment -> NameAdornment -> Bool

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

Ord NameAdornment

Defined in GHC.Parser.Annotation

Methods

compare :: NameAdornment -> NameAdornment -> Ordering

(<) :: NameAdornment -> NameAdornment -> Bool

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

(>) :: NameAdornment -> NameAdornment -> Bool

(>=) :: NameAdornment -> NameAdornment -> Bool

max :: NameAdornment -> NameAdornment -> NameAdornment

min :: NameAdornment -> NameAdornment -> NameAdornment

type LocatedP = GenLocated SrcSpanAnnP

type LocatedN = GenLocated SrcSpanAnnN

type LocatedL = GenLocated SrcSpanAnnL

type LocatedC = GenLocated SrcSpanAnnC

type LocatedAn an = GenLocated (SrcAnn an)

General representation of a GenLocated type carrying a parameterised annotation type.

type LocatedA = GenLocated SrcSpanAnnA

type LEpaComment = GenLocated Anchor EpaComment

data IsUnicodeSyntax

Certain tokens can have alternate representations when unicode syntax is enabled. This flag is attached to those tokens in the lexer so that the original source representation can be reproduced in the corresponding EpAnnotation

Constructors

UnicodeSyntax

NormalSyntax

Instances

Data IsUnicodeSyntax

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: IsUnicodeSyntax -> Constr

dataTypeOf :: IsUnicodeSyntax -> DataType

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

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

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

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

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

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

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

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

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

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

Show IsUnicodeSyntax

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> IsUnicodeSyntax -> ShowS

show :: IsUnicodeSyntax -> String

showList :: [IsUnicodeSyntax] -> ShowS

Outputable IsUnicodeSyntax

Defined in GHC.Parser.Annotation

Methods

ppr :: IsUnicodeSyntax -> SDoc

Eq IsUnicodeSyntax

Defined in GHC.Parser.Annotation

Methods

(==) :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool

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

Ord IsUnicodeSyntax

Defined in GHC.Parser.Annotation

Methods

compare :: IsUnicodeSyntax -> IsUnicodeSyntax -> Ordering

(<) :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool

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

(>) :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool

(>=) :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool

max :: IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax

min :: IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax

data HasE

Some template haskell tokens have two variants, one with an e the other not:

 [| or [e|
 [|| or [e||

This type indicates whether the e is present or not.

Constructors

HasE

NoE

Instances

Data HasE

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: HasE -> Constr

dataTypeOf :: HasE -> DataType

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

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

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

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

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

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

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

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

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

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

Show HasE

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> HasE -> ShowS

show :: HasE -> String

showList :: [HasE] -> ShowS

Eq HasE

Defined in GHC.Parser.Annotation

Methods

(==) :: HasE -> HasE -> Bool

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

Ord HasE

Defined in GHC.Parser.Annotation

Methods

compare :: HasE -> HasE -> Ordering

(<) :: HasE -> HasE -> Bool

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

(>) :: HasE -> HasE -> Bool

(>=) :: HasE -> HasE -> Bool

max :: HasE -> HasE -> HasE

min :: HasE -> HasE -> HasE

data EpaLocation

The anchor for an AnnKeywordId. The Parser inserts the EpaSpan variant, giving the exact location of the original item in the parsed source. This can be replaced by the EpaDelta version, to provide a position for the item relative to the end of the previous item in the source. This is useful when editing an AST prior to exact printing the changed one. The list of comments in the EpaDelta variant captures any comments between the prior output and the thing being marked here, since we cannot otherwise sort the relative order.

Constructors

EpaSpan !RealSrcSpan

EpaDelta !DeltaPos ![LEpaComment]

Instances

Data EpaLocation

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: EpaLocation -> Constr

dataTypeOf :: EpaLocation -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable EpaLocation

Defined in GHC.Parser.Annotation

Methods

ppr :: EpaLocation -> SDoc

Eq EpaLocation

Defined in GHC.Parser.Annotation

Methods

(==) :: EpaLocation -> EpaLocation -> Bool

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

Ord EpaLocation

Defined in GHC.Parser.Annotation

Methods

compare :: EpaLocation -> EpaLocation -> Ordering

(<) :: EpaLocation -> EpaLocation -> Bool

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

(>) :: EpaLocation -> EpaLocation -> Bool

(>=) :: EpaLocation -> EpaLocation -> Bool

max :: EpaLocation -> EpaLocation -> EpaLocation

min :: EpaLocation -> EpaLocation -> EpaLocation

data EpaCommentTok

Constructors

EpaDocCommentNext String

something beginning '-- |'

EpaDocCommentPrev String

something beginning '-- ^'

EpaDocCommentNamed String

something beginning '-- $'

EpaDocSection Int String

a section heading

EpaDocOptions String

doc options (prune, ignore-exports, etc)

EpaLineComment String

comment starting by "--"

EpaBlockComment String

comment in {- -}

EpaEofComment

empty comment, capturing location of EOF

Instances

Data EpaCommentTok

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: EpaCommentTok -> Constr

dataTypeOf :: EpaCommentTok -> DataType

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

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

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

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

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

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

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

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

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

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

Show EpaCommentTok

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> EpaCommentTok -> ShowS

show :: EpaCommentTok -> String

showList :: [EpaCommentTok] -> ShowS

Eq EpaCommentTok

Defined in GHC.Parser.Annotation

Methods

(==) :: EpaCommentTok -> EpaCommentTok -> Bool

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

Ord EpaCommentTok

Defined in GHC.Parser.Annotation

Methods

compare :: EpaCommentTok -> EpaCommentTok -> Ordering

(<) :: EpaCommentTok -> EpaCommentTok -> Bool

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

(>) :: EpaCommentTok -> EpaCommentTok -> Bool

(>=) :: EpaCommentTok -> EpaCommentTok -> Bool

max :: EpaCommentTok -> EpaCommentTok -> EpaCommentTok

min :: EpaCommentTok -> EpaCommentTok -> EpaCommentTok

data EpaComment

Constructors

EpaComment

Fields

• ac_tok :: EpaCommentTok
• ac_prior_tok :: RealSrcSpan

  The location of the prior token, used in exact printing. The EpaComment appears as an LEpaComment containing its location. The difference between the end of the prior token and the start of this location is used for the spacing when exact printing the comment.

Instances

Data EpaComment

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: EpaComment -> Constr

dataTypeOf :: EpaComment -> DataType

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

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

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

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

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

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

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

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

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

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

Show EpaComment

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> EpaComment -> ShowS

show :: EpaComment -> String

showList :: [EpaComment] -> ShowS

Outputable EpaComment

Defined in GHC.Parser.Annotation

Methods

ppr :: EpaComment -> SDoc

Eq EpaComment

Defined in GHC.Parser.Annotation

Methods

(==) :: EpaComment -> EpaComment -> Bool

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

Ord EpaComment

Defined in GHC.Parser.Annotation

Methods

compare :: EpaComment -> EpaComment -> Ordering

(<) :: EpaComment -> EpaComment -> Bool

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

(>) :: EpaComment -> EpaComment -> Bool

(>=) :: EpaComment -> EpaComment -> Bool

max :: EpaComment -> EpaComment -> EpaComment

min :: EpaComment -> EpaComment -> EpaComment

Outputable (GenLocated Anchor EpaComment)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated Anchor EpaComment -> SDoc

data EpAnnComments

When we are parsing we add comments that belong a particular AST element, and print them together with the element, interleaving them into the output stream. But when editing the AST to move fragments around it is useful to be able to first separate the comments into those occuring before the AST element and those following it. The EpaCommentsBalanced constructor is used to do this. The GHC parser will only insert the EpaComments form.

Constructors

EpaComments

Fields

• priorComments :: ![LEpaComment]

EpaCommentsBalanced

Fields

• priorComments :: ![LEpaComment]
• followingComments :: ![LEpaComment]

Instances

Data EpAnnComments

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: EpAnnComments -> Constr

dataTypeOf :: EpAnnComments -> DataType

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

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

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

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

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

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

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

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

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

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

Semigroup EpAnnComments

Defined in GHC.Parser.Annotation

Methods

(<>) :: EpAnnComments -> EpAnnComments -> EpAnnComments

sconcat :: NonEmpty EpAnnComments -> EpAnnComments

stimes :: Integral b => b -> EpAnnComments -> EpAnnComments

Outputable EpAnnComments

Defined in GHC.Parser.Annotation

Methods

ppr :: EpAnnComments -> SDoc

Eq EpAnnComments

Defined in GHC.Parser.Annotation

Methods

(==) :: EpAnnComments -> EpAnnComments -> Bool

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

type EpAnnCO

Arguments

 = EpAnn NoEpAnns

Api Annotations for comments only

data EpAnn ann

The exact print annotations (EPAs) are kept in the HsSyn AST for the GhcPs phase. We do not always have EPAs though, only for code that has been parsed as they do not exist for generated code. This type captures that they may be missing.

A goal of the annotations is that an AST can be edited, including moving subtrees from one place to another, duplicating them, and so on. This means that each fragment must be self-contained. To this end, each annotated fragment keeps track of the anchor position it was originally captured at, being simply the start span of the topmost element of the ast fragment. This gives us a way to later re-calculate all Located items in this layer of the AST, as well as any annotations captured. The comments associated with the AST fragment are also captured here.

The ann type parameter allows this general structure to be specialised to the specific set of locations of original exact print annotation elements. So for HsLet we have

type instance XLet GhcPs = EpAnn AnnsLet data AnnsLet = AnnsLet { alLet :: EpaLocation, alIn :: EpaLocation } deriving Data

The spacing between the items under the scope of a given EpAnn is normally derived from the original Anchor. But if a sub-element is not in its original position, the required spacing can be directly captured in the anchor_op field of the entry Anchor. This allows us to freely move elements around, and stitch together new AST fragments out of old ones, and have them still printed out in a precise way.

Constructors

EpAnn

Fields

• entry :: !Anchor

  Base location for the start of the syntactic element holding the annotations.

• anns :: !ann

  Annotations added by the Parser

• comments :: !EpAnnComments

  Comments enclosed in the SrcSpan of the element this EpAnn is attached to

EpAnnNotUsed

No Annotation for generated code, e.g. from TH, deriving, etc.

Instances

Functor EpAnn

Defined in GHC.Parser.Annotation

Methods

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

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

Data ann => Data (EpAnn ann)

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: EpAnn ann -> Constr

dataTypeOf :: EpAnn ann -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> EpAnn ann -> EpAnn ann

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

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

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

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

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

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

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

Monoid a => Monoid (EpAnn a)

Defined in GHC.Parser.Annotation

Methods

mempty :: EpAnn a

mappend :: EpAnn a -> EpAnn a -> EpAnn a

mconcat :: [EpAnn a] -> EpAnn a

Semigroup a => Semigroup (EpAnn a)

Defined in GHC.Parser.Annotation

Methods

(<>) :: EpAnn a -> EpAnn a -> EpAnn a

sconcat :: NonEmpty (EpAnn a) -> EpAnn a

stimes :: Integral b => b -> EpAnn a -> EpAnn a

Binary a => Binary (LocatedL a)

Defined in GHC.Parser.Annotation

Methods

put_ :: BinHandle -> LocatedL a -> IO ()

put :: BinHandle -> LocatedL a -> IO (Bin (LocatedL a))

get :: BinHandle -> IO (LocatedL a)

Outputable a => Outputable (EpAnn a)

Defined in GHC.Parser.Annotation

Methods

ppr :: EpAnn a -> SDoc

Eq ann => Eq (EpAnn ann)

Defined in GHC.Parser.Annotation

Methods

(==) :: EpAnn ann -> EpAnn ann -> Bool

(/=) :: EpAnn ann -> EpAnn ann -> Bool

NamedThing (Located a) => NamedThing (LocatedAn an a)

Defined in GHC.Parser.Annotation

Methods

getOccName :: LocatedAn an a -> OccName

getName :: LocatedAn an a -> Name

type Anno (LocatedA (IE (GhcPass p)))

Defined in GHC.Hs.ImpExp

type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno (LocatedN RdrName)

Defined in GHC.Hs.Binds

type Anno (LocatedN RdrName) = SrcSpan

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedA (IE (GhcPass p))]

Defined in GHC.Hs.ImpExp

type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.PostProcess

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.Types

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (ConDeclField (GhcPass _1))]

Defined in GHC.Hs.Decls

type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type Anno [LocatedA (HsType (GhcPass p))]

Defined in GHC.Hs.Type

type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

type Anno [LocatedN RdrName]

Defined in GHC.Hs.Binds

type Anno [LocatedN RdrName] = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type Anno (FamEqn p (LocatedA (HsType p)))

Defined in GHC.Hs.Decls

type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpan

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpan

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpan

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p)))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))

Defined in GHC.Hs.Expr

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

data DeltaPos

Spacing between output items when exact printing. It captures the spacing from the current print position on the page to the position required for the thing about to be printed. This is either on the same line in which case is is simply the number of spaces to emit, or it is some number of lines down, with a given column offset. The exact printing algorithm keeps track of the column offset pertaining to the current anchor position, so the deltaColumn is the additional spaces to add in this case. See https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations for details.

Constructors

SameLine

Fields

• deltaColumn :: !Int

DifferentLine

Fields

• deltaLine :: !Int

  deltaLine should always be > 0

• deltaColumn :: !Int

Instances

Data DeltaPos

Defined in GHC.Parser.Annotation

Methods

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

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

toConstr :: DeltaPos -> Constr

dataTypeOf :: DeltaPos -> DataType

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

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

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

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

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

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

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

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

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

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

Show DeltaPos

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> DeltaPos -> ShowS

show :: DeltaPos -> String

showList :: [DeltaPos] -> ShowS

Outputable DeltaPos

Defined in GHC.Parser.Annotation

Methods

ppr :: DeltaPos -> SDoc

Eq DeltaPos

Defined in GHC.Parser.Annotation

Methods

(==) :: DeltaPos -> DeltaPos -> Bool

(/=) :: DeltaPos -> DeltaPos -> Bool

Ord DeltaPos

Defined in GHC.Parser.Annotation

Methods

compare :: DeltaPos -> DeltaPos -> Ordering

(<) :: DeltaPos -> DeltaPos -> Bool

(<=) :: DeltaPos -> DeltaPos -> Bool

(>) :: DeltaPos -> DeltaPos -> Bool

(>=) :: DeltaPos -> DeltaPos -> Bool

max :: DeltaPos -> DeltaPos -> DeltaPos

min :: DeltaPos -> DeltaPos -> DeltaPos

data AnnSortKey

Captures the sort order of sub elements. This is needed when the sub-elements have been split (as in a HsLocalBind which holds separate binds and sigs) or for infix patterns where the order has been re-arranged. It is captured explicitly so that after the Delta phase a SrcSpan is used purely as an index into the annotations, allowing transformations of the AST including the introduction of new Located items or re-arranging existing ones.

Constructors

NoAnnSortKey

AnnSortKey [RealSrcSpan]

Instances

Data AnnSortKey

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnSortKey -> c AnnSortKey

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnSortKey

toConstr :: AnnSortKey -> Constr

dataTypeOf :: AnnSortKey -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnSortKey)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnSortKey)

gmapT :: (forall b. Data b => b -> b) -> AnnSortKey -> AnnSortKey

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnSortKey -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnSortKey -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnSortKey -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnSortKey -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnSortKey -> m AnnSortKey

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnSortKey -> m AnnSortKey

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnSortKey -> m AnnSortKey

Monoid AnnSortKey

Defined in GHC.Parser.Annotation

Methods

mempty :: AnnSortKey

mappend :: AnnSortKey -> AnnSortKey -> AnnSortKey

mconcat :: [AnnSortKey] -> AnnSortKey

Semigroup AnnSortKey

Defined in GHC.Parser.Annotation

Methods

(<>) :: AnnSortKey -> AnnSortKey -> AnnSortKey

sconcat :: NonEmpty AnnSortKey -> AnnSortKey

stimes :: Integral b => b -> AnnSortKey -> AnnSortKey

Outputable AnnSortKey

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnSortKey -> SDoc

Eq AnnSortKey

Defined in GHC.Parser.Annotation

Methods

(==) :: AnnSortKey -> AnnSortKey -> Bool

(/=) :: AnnSortKey -> AnnSortKey -> Bool

data AnnPragma

exact print annotation used for capturing the locations of annotations in pragmas.

Constructors

AnnPragma

Fields

• apr_open :: AddEpAnn
• apr_close :: AddEpAnn
• apr_rest :: [AddEpAnn]

Instances

Data AnnPragma

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnPragma -> c AnnPragma

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnPragma

toConstr :: AnnPragma -> Constr

dataTypeOf :: AnnPragma -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnPragma)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnPragma)

gmapT :: (forall b. Data b => b -> b) -> AnnPragma -> AnnPragma

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnPragma -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnPragma -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma

Outputable AnnPragma

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnPragma -> SDoc

Eq AnnPragma

Defined in GHC.Parser.Annotation

Methods

(==) :: AnnPragma -> AnnPragma -> Bool

(/=) :: AnnPragma -> AnnPragma -> Bool

data AnnParen

exact print annotation for an item having surrounding "brackets", such as tuples or lists

Constructors

AnnParen

Fields

• ap_adornment :: ParenType
• ap_open :: EpaLocation
• ap_close :: EpaLocation

Instances

Data AnnParen

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnParen -> c AnnParen

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnParen

toConstr :: AnnParen -> Constr

dataTypeOf :: AnnParen -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnParen)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnParen)

gmapT :: (forall b. Data b => b -> b) -> AnnParen -> AnnParen

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnParen -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnParen -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnParen -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnParen -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen

data AnnListItem

Annotation for items appearing in a list. They can have one or more trailing punctuations items, such as commas or semicolons.

Constructors

AnnListItem

Fields

• lann_trailing :: [TrailingAnn]

Instances

Data AnnListItem

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnListItem -> c AnnListItem

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnListItem

toConstr :: AnnListItem -> Constr

dataTypeOf :: AnnListItem -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnListItem)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnListItem)

gmapT :: (forall b. Data b => b -> b) -> AnnListItem -> AnnListItem

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnListItem -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnListItem -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem

Monoid AnnListItem

Defined in GHC.Parser.Annotation

Methods

mempty :: AnnListItem

mappend :: AnnListItem -> AnnListItem -> AnnListItem

mconcat :: [AnnListItem] -> AnnListItem

Semigroup AnnListItem

Defined in GHC.Parser.Annotation

Methods

(<>) :: AnnListItem -> AnnListItem -> AnnListItem

sconcat :: NonEmpty AnnListItem -> AnnListItem

stimes :: Integral b => b -> AnnListItem -> AnnListItem

Outputable AnnListItem

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnListItem -> SDoc

Eq AnnListItem

Defined in GHC.Parser.Annotation

Methods

(==) :: AnnListItem -> AnnListItem -> Bool

(/=) :: AnnListItem -> AnnListItem -> Bool

type Anno (LocatedA (IE (GhcPass p)))

Defined in GHC.Hs.ImpExp

type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA

type Anno [LocatedA (IE (GhcPass p))]

Defined in GHC.Hs.ImpExp

type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.PostProcess

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.Types

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (ConDeclField (GhcPass _1))]

Defined in GHC.Hs.Decls

type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type Anno [LocatedA (HsType (GhcPass p))]

Defined in GHC.Hs.Type

type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC

type Anno (FamEqn p (LocatedA (HsType p)))

Defined in GHC.Hs.Decls

type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpan

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpan

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpan

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p)))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))

Defined in GHC.Hs.Expr

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

data AnnList

Annotation for the "container" of a list. This captures surrounding items such as braces if present, and introductory keywords such as 'where'.

Constructors

AnnList

Fields

• al_anchor :: Maybe Anchor

  start point of a list having layout

• al_open :: Maybe AddEpAnn
• al_close :: Maybe AddEpAnn
• al_rest :: [AddEpAnn]

  context, such as 'where' keyword

• al_trailing :: [TrailingAnn]

  items appearing after the list, such as '=>' for a context

Instances

Data AnnList

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnList -> c AnnList

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnList

toConstr :: AnnList -> Constr

dataTypeOf :: AnnList -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnList)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnList)

gmapT :: (forall b. Data b => b -> b) -> AnnList -> AnnList

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnList -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnList -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnList -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnList -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnList -> m AnnList

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnList -> m AnnList

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnList -> m AnnList

Monoid AnnList

Defined in GHC.Parser.Annotation

Methods

mempty :: AnnList

mappend :: AnnList -> AnnList -> AnnList

mconcat :: [AnnList] -> AnnList

Semigroup AnnList

Defined in GHC.Parser.Annotation

Methods

(<>) :: AnnList -> AnnList -> AnnList

sconcat :: NonEmpty AnnList -> AnnList

stimes :: Integral b => b -> AnnList -> AnnList

Outputable AnnList

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnList -> SDoc

Eq AnnList

Defined in GHC.Parser.Annotation

Methods

(==) :: AnnList -> AnnList -> Bool

(/=) :: AnnList -> AnnList -> Bool

Binary a => Binary (LocatedL a)

Defined in GHC.Parser.Annotation

Methods

put_ :: BinHandle -> LocatedL a -> IO ()

put :: BinHandle -> LocatedL a -> IO (Bin (LocatedL a))

get :: BinHandle -> IO (LocatedL a)

data AnnKeywordId

Exact print annotations exist so that tools can perform source to source conversions of Haskell code. They are used to keep track of the various syntactic keywords that are not otherwise captured in the AST.

The wiki page describing this feature is https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations https://gitlab.haskell.org/ghc/ghc/-/wikis/implementing-trees-that-grow/in-tree-api-annotations

Note: in general the names of these are taken from the corresponding token, unless otherwise noted See note [exact print annotations] above for details of the usage

Constructors

AnnAnyclass

AnnAs

AnnAt

AnnBang

!

AnnBackquote

'`'

AnnBy

AnnCase

case or lambda case

AnnClass

AnnClose

'#)' or '#-}' etc

AnnCloseB

'|)'

AnnCloseBU

'|)', unicode variant

AnnCloseC

'}'

AnnCloseQ

'|]'

AnnCloseQU

'|]', unicode variant

AnnCloseP

')'

AnnClosePH

'#)'

AnnCloseS

']'

AnnColon

AnnComma

as a list separator

AnnCommaTuple

in a RdrName for a tuple

AnnDarrow

'=>'

AnnDarrowU

'=>', unicode variant

AnnData

AnnDcolon

'::'

AnnDcolonU

'::', unicode variant

AnnDefault

AnnDeriving

AnnDo

AnnDot

.

AnnDotdot

'..'

AnnElse

AnnEqual

AnnExport

AnnFamily

AnnForall

AnnForallU

Unicode variant

AnnForeign

AnnFunId

for function name in matches where there are multiple equations for the function.

AnnGroup

AnnHeader

for CType

AnnHiding

AnnIf

AnnImport

AnnIn

AnnInfix

'infix' or 'infixl' or 'infixr'

AnnInstance

AnnLam

AnnLarrow

'<-'

AnnLarrowU

'<-', unicode variant

AnnLet

AnnLollyU

The ⊸ unicode arrow

AnnMdo

AnnMinus

-

AnnModule

AnnNewtype

AnnName

where a name loses its location in the AST, this carries it

AnnOf

AnnOpen

'{-# DEPRECATED' etc. Opening of pragmas where the capitalisation of the string can be changed by the user. The actual text used is stored in a SourceText on the relevant pragma item.

AnnOpenB

'(|'

AnnOpenBU

'(|', unicode variant

AnnOpenC

'{'

AnnOpenE

'[e|' or '[e||'

AnnOpenEQ

'[|'

AnnOpenEQU

'[|', unicode variant

AnnOpenP

'('

AnnOpenS

'['

AnnOpenPH

'(#'

AnnDollar

prefix $ -- TemplateHaskell

AnnDollarDollar

prefix $$ -- TemplateHaskell

AnnPackageName

AnnPattern

AnnPercent

% -- for HsExplicitMult

AnnPercentOne

'%1' -- for HsLinearArrow

AnnProc

AnnQualified

AnnRarrow

->

AnnRarrowU

->, unicode variant

AnnRec

AnnRole

AnnSafe

AnnSemi

';'

AnnSimpleQuote

'''

AnnSignature

AnnStatic

static

AnnStock

AnnThen

AnnThTyQuote

double '''

AnnTilde

~

AnnType

AnnUnit

() for types

AnnUsing

AnnVal

e.g. INTEGER

AnnValStr

String value, will need quotes when output

AnnVbar

'|'

AnnVia

via

AnnWhere

Annlarrowtail

-<

AnnlarrowtailU

-<, unicode variant

Annrarrowtail

->

AnnrarrowtailU

->, unicode variant

AnnLarrowtail

-<<

AnnLarrowtailU

-<<, unicode variant

AnnRarrowtail

>>-

AnnRarrowtailU

>>-, unicode variant

Instances

Data AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnKeywordId -> c AnnKeywordId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnKeywordId

toConstr :: AnnKeywordId -> Constr

dataTypeOf :: AnnKeywordId -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnKeywordId)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnKeywordId)

gmapT :: (forall b. Data b => b -> b) -> AnnKeywordId -> AnnKeywordId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnKeywordId -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnKeywordId -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnKeywordId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnKeywordId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

Show AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> AnnKeywordId -> ShowS

show :: AnnKeywordId -> String

showList :: [AnnKeywordId] -> ShowS

Outputable AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnKeywordId -> SDoc

Eq AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

(==) :: AnnKeywordId -> AnnKeywordId -> Bool

(/=) :: AnnKeywordId -> AnnKeywordId -> Bool

Ord AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

compare :: AnnKeywordId -> AnnKeywordId -> Ordering

(<) :: AnnKeywordId -> AnnKeywordId -> Bool

(<=) :: AnnKeywordId -> AnnKeywordId -> Bool

(>) :: AnnKeywordId -> AnnKeywordId -> Bool

(>=) :: AnnKeywordId -> AnnKeywordId -> Bool

max :: AnnKeywordId -> AnnKeywordId -> AnnKeywordId

min :: AnnKeywordId -> AnnKeywordId -> AnnKeywordId

data AnnContext

Exact print annotation for the Context data type.

Constructors

AnnContext

Fields

• ac_darrow :: Maybe (IsUnicodeSyntax, EpaLocation)

  location and encoding of the '=>', if present.

• ac_open :: [EpaLocation]

  zero or more opening parentheses.

• ac_close :: [EpaLocation]

  zero or more closing parentheses.

Instances

Data AnnContext

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnContext -> c AnnContext

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnContext

toConstr :: AnnContext -> Constr

dataTypeOf :: AnnContext -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnContext)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnContext)

gmapT :: (forall b. Data b => b -> b) -> AnnContext -> AnnContext

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnContext -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnContext -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnContext -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnContext -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext

Outputable AnnContext

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnContext -> SDoc

data AnchorOperation

If tools modify the parsed source, the MovedAnchor variant can directly provide the spacing for this item relative to the previous one when printing. This allows AST fragments with a particular anchor to be freely moved, without worrying about recalculating the appropriate anchor span.

Constructors

UnchangedAnchor

MovedAnchor DeltaPos

Instances

Data AnchorOperation

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnchorOperation -> c AnchorOperation

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnchorOperation

toConstr :: AnchorOperation -> Constr

dataTypeOf :: AnchorOperation -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnchorOperation)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnchorOperation)

gmapT :: (forall b. Data b => b -> b) -> AnchorOperation -> AnchorOperation

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnchorOperation -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnchorOperation -> r

gmapQ :: (forall d. Data d => d -> u) -> AnchorOperation -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnchorOperation -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnchorOperation -> m AnchorOperation

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnchorOperation -> m AnchorOperation

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnchorOperation -> m AnchorOperation

Show AnchorOperation

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> AnchorOperation -> ShowS

show :: AnchorOperation -> String

showList :: [AnchorOperation] -> ShowS

Outputable AnchorOperation

Defined in GHC.Parser.Annotation

Methods

ppr :: AnchorOperation -> SDoc

Eq AnchorOperation

Defined in GHC.Parser.Annotation

Methods

(==) :: AnchorOperation -> AnchorOperation -> Bool

(/=) :: AnchorOperation -> AnchorOperation -> Bool

data Anchor

An Anchor records the base location for the start of the syntactic element holding the annotations, and is used as the point of reference for calculating delta positions for contained annotations. It is also normally used as the reference point for the spacing of the element relative to its container. If it is moved, that relationship is tracked in the anchor_op instead.

Constructors

Anchor

Fields

• anchor :: RealSrcSpan

  Base location for the start of the syntactic element holding the annotations.

• anchor_op :: AnchorOperation

Instances

Data Anchor

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Anchor -> c Anchor

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Anchor

toConstr :: Anchor -> Constr

dataTypeOf :: Anchor -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Anchor)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Anchor)

gmapT :: (forall b. Data b => b -> b) -> Anchor -> Anchor

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Anchor -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Anchor -> r

gmapQ :: (forall d. Data d => d -> u) -> Anchor -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Anchor -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Anchor -> m Anchor

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Anchor -> m Anchor

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Anchor -> m Anchor

Semigroup Anchor

Defined in GHC.Parser.Annotation

Methods

(<>) :: Anchor -> Anchor -> Anchor

sconcat :: NonEmpty Anchor -> Anchor

stimes :: Integral b => b -> Anchor -> Anchor

Show Anchor

Defined in GHC.Parser.Annotation

Methods

showsPrec :: Int -> Anchor -> ShowS

show :: Anchor -> String

showList :: [Anchor] -> ShowS

Outputable Anchor

Defined in GHC.Parser.Annotation

Methods

ppr :: Anchor -> SDoc

Eq Anchor

Defined in GHC.Parser.Annotation

Methods

(==) :: Anchor -> Anchor -> Bool

(/=) :: Anchor -> Anchor -> Bool

Ord Anchor

Defined in GHC.Parser.Annotation

Methods

compare :: Anchor -> Anchor -> Ordering

(<) :: Anchor -> Anchor -> Bool

(<=) :: Anchor -> Anchor -> Bool

(>) :: Anchor -> Anchor -> Bool

(>=) :: Anchor -> Anchor -> Bool

max :: Anchor -> Anchor -> Anchor

min :: Anchor -> Anchor -> Anchor

Outputable (GenLocated Anchor EpaComment)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated Anchor EpaComment -> SDoc

data AddEpAnn

Captures an annotation, storing the AnnKeywordId and its location. The parser only ever inserts EpaLocation fields with a RealSrcSpan being the original location of the annotation in the source file. The EpaLocation can also store a delta position if the AST has been modified and needs to be pretty printed again. The usual way an AddEpAnn is created is using the mj ("make jump") function, and then it can be inserted into the appropriate annotation.

Constructors

AddEpAnn AnnKeywordId EpaLocation

Instances

Data AddEpAnn

Defined in GHC.Parser.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AddEpAnn -> c AddEpAnn

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AddEpAnn

toConstr :: AddEpAnn -> Constr

dataTypeOf :: AddEpAnn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AddEpAnn)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AddEpAnn)

gmapT :: (forall b. Data b => b -> b) -> AddEpAnn -> AddEpAnn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AddEpAnn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AddEpAnn -> r

gmapQ :: (forall d. Data d => d -> u) -> AddEpAnn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AddEpAnn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AddEpAnn -> m AddEpAnn

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AddEpAnn -> m AddEpAnn

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AddEpAnn -> m AddEpAnn

Outputable AddEpAnn

Defined in GHC.Parser.Annotation

Methods

ppr :: AddEpAnn -> SDoc

Eq AddEpAnn

Defined in GHC.Parser.Annotation

Methods

(==) :: AddEpAnn -> AddEpAnn -> Bool

(/=) :: AddEpAnn -> AddEpAnn -> Bool

Ord AddEpAnn

Defined in GHC.Parser.Annotation

Methods

compare :: AddEpAnn -> AddEpAnn -> Ordering

(<) :: AddEpAnn -> AddEpAnn -> Bool

(<=) :: AddEpAnn -> AddEpAnn -> Bool

(>) :: AddEpAnn -> AddEpAnn -> Bool

(>=) :: AddEpAnn -> AddEpAnn -> Bool

max :: AddEpAnn -> AddEpAnn -> AddEpAnn

min :: AddEpAnn -> AddEpAnn -> AddEpAnn

widenSpan :: SrcSpan -> [AddEpAnn] -> SrcSpan

The annotations need to all come after the anchor. Make sure this is the case.

widenLocatedAn :: SrcSpanAnn' an -> [AddEpAnn] -> SrcSpanAnn' an

widenAnchorR :: Anchor -> RealSrcSpan -> Anchor

widenAnchor :: Anchor -> [AddEpAnn] -> Anchor

unicodeAnn :: AnnKeywordId -> AnnKeywordId

Convert a normal annotation into its unicode equivalent one

transferAnnsA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA)

Transfer comments and trailing items from the annotations in the first SrcSpanAnnA argument to those in the second.

spanAsAnchor :: SrcSpan -> Anchor

sortLocatedA :: [GenLocated (SrcSpanAnn' a) e] -> [GenLocated (SrcSpanAnn' a) e]

setPriorComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments

setFollowingComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments

setCommentsSrcAnn :: Monoid ann => SrcAnn ann -> EpAnnComments -> SrcAnn ann

Replace any existing comments on a SrcAnn, used for manipulating the AST prior to exact printing the changed one.

setCommentsEpAnn :: Monoid a => SrcSpan -> EpAnn a -> EpAnnComments -> EpAnn a

Replace any existing comments, used for manipulating the AST prior to exact printing the changed one.

removeCommentsA :: SrcAnn ann -> SrcAnn ann

Remove the comments, leaving the exact print annotations payload

realSrcSpan :: SrcSpan -> RealSrcSpan

realSpanAsAnchor :: RealSrcSpan -> Anchor

reLocN :: LocatedN a -> Located a

reLocL :: LocatedN e -> LocatedA e

reLocC :: LocatedN e -> LocatedC e

reLocA :: Located e -> LocatedAn ann e

reLoc :: LocatedAn a e -> Located e

reAnnL :: ann -> EpAnnComments -> Located e -> GenLocated (SrcAnn ann) e

reAnnC :: AnnContext -> EpAnnComments -> Located a -> LocatedC a

reAnn :: [TrailingAnn] -> EpAnnComments -> Located a -> LocatedA a

placeholderRealSpan :: RealSrcSpan

parenTypeKws :: ParenType -> (AnnKeywordId, AnnKeywordId)

Maps the ParenType to the related opening and closing AnnKeywordId. Used when actually printing the item.

noSrcSpanA :: SrcAnn ann

noLocA :: a -> LocatedAn an a

noComments :: EpAnnCO

noAnnSrcSpan :: SrcSpan -> SrcAnn ann

noAnn :: EpAnn a

Short form for EpAnnNotUsed

na2la :: SrcSpanAnn' a -> SrcAnn ann

Helper function (temporary) during transition of names Discards any annotations

n2l :: LocatedN a -> LocatedA a

mapLocA :: (a -> b) -> GenLocated SrcSpan a -> GenLocated (SrcAnn ann) b

la2r :: SrcSpanAnn' a -> RealSrcSpan

la2na :: SrcSpanAnn' a -> SrcSpanAnnN

Helper function (temporary) during transition of names Discards any annotations

la2la :: LocatedAn ann1 a2 -> LocatedAn ann2 a2

Helper function (temporary) during transition of names Discards any annotations

l2n :: LocatedAn a1 a2 -> LocatedN a2

Helper function (temporary) during transition of names Discards any annotations

l2l :: SrcSpanAnn' a -> SrcAnn ann

getLocAnn :: Located a -> SrcSpanAnnA

getLocA :: GenLocated (SrcSpanAnn' a) e -> SrcSpan

getFollowingComments :: EpAnnComments -> [LEpaComment]

getDeltaLine :: DeltaPos -> Int

extraToAnnList :: AnnList -> [AddEpAnn] -> AnnList

epaLocationRealSrcSpan :: EpaLocation -> RealSrcSpan

Used in the parser only, extract the SrcSpan from an EpaLocation. The parser will never insert a DeltaPos, so the partial function is safe.

epaLocationFromSrcAnn :: SrcAnn ann -> EpaLocation

epAnnComments :: EpAnn an -> EpAnnComments

epAnnAnnsL :: EpAnn a -> [a]

epAnnAnns :: EpAnn [AddEpAnn] -> [AddEpAnn]

emptyComments :: EpAnnComments

deltaPos :: Int -> Int -> DeltaPos

Smart constructor for a DeltaPos. It preserves the invariant that for the DifferentLine constructor deltaLine is always > 0.

commentsOnlyA :: Monoid ann => SrcAnn ann -> SrcAnn ann

Remove the exact print annotations payload, leaving only the anchor and comments.

comment :: RealSrcSpan -> EpAnnComments -> EpAnnCO

combineSrcSpansA :: Semigroup a => SrcAnn a -> SrcAnn a -> SrcAnn a

combineLocsA :: Semigroup a => GenLocated (SrcAnn a) e1 -> GenLocated (SrcAnn a) e2 -> SrcAnn a

annParen2AddEpAnn :: EpAnn AnnParen -> [AddEpAnn]

addTrailingCommaToN :: SrcSpan -> EpAnn NameAnn -> EpaLocation -> EpAnn NameAnn

Helper function used in the parser to add a comma location to an existing annotation.

addTrailingAnnToL :: SrcSpan -> TrailingAnn -> EpAnnComments -> EpAnn AnnList -> EpAnn AnnList

Helper function used in the parser to add a TrailingAnn items to an existing annotation.

addTrailingAnnToA :: SrcSpan -> TrailingAnn -> EpAnnComments -> EpAnn AnnListItem -> EpAnn AnnListItem

Helper function used in the parser to add a TrailingAnn items to an existing annotation.

addCommentsToSrcAnn :: Monoid ann => SrcAnn ann -> EpAnnComments -> SrcAnn ann

Add additional comments to a SrcAnn, used for manipulating the AST prior to exact printing the changed one.

addCommentsToEpAnn :: Monoid a => SrcSpan -> EpAnn a -> EpAnnComments -> EpAnn a

Add additional comments, used for manipulating the AST prior to exact printing the changed one.

addCLocAA :: GenLocated (SrcSpanAnn' a1) e1 -> GenLocated (SrcSpanAnn' a2) e2 -> e3 -> GenLocated (SrcAnn ann) e3

addCLocA :: GenLocated (SrcSpanAnn' a) e1 -> GenLocated SrcSpan e2 -> e3 -> GenLocated (SrcAnn ann) e3

Combine locations from two Located things and add them to a third thing

addAnnsA :: SrcSpanAnnA -> [TrailingAnn] -> EpAnnComments -> SrcSpanAnnA

addAnns :: EpAnn [AddEpAnn] -> [AddEpAnn] -> EpAnnComments -> EpAnn [AddEpAnn]

type NameEnv a = UniqFM Name a

Name Environment

type DNameEnv a = UniqDFM Name a

Deterministic Name Environment

See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why we need DNameEnv.

unitNameEnv :: Name -> a -> NameEnv a

plusNameEnv_CD2 :: (Maybe a -> Maybe a -> a) -> NameEnv a -> NameEnv a -> NameEnv a

plusNameEnv_CD :: (a -> a -> a) -> NameEnv a -> a -> NameEnv a -> a -> NameEnv a

plusNameEnv_C :: (a -> a -> a) -> NameEnv a -> NameEnv a -> NameEnv a

plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a

nameEnvElts :: NameEnv a -> [a]

mkNameEnvWith :: (a -> Name) -> [a] -> NameEnv a

mkNameEnv :: [(Name, a)] -> NameEnv a

mapNameEnv :: (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2

mapDNameEnv :: (a -> b) -> DNameEnv a -> DNameEnv b

lookupNameEnv_NF :: NameEnv a -> Name -> a

lookupNameEnv :: NameEnv a -> Name -> Maybe a

lookupDNameEnv :: DNameEnv a -> Name -> Maybe a

isEmptyNameEnv :: NameEnv a -> Bool

filterNameEnv :: (elt -> Bool) -> NameEnv elt -> NameEnv elt

filterDNameEnv :: (a -> Bool) -> DNameEnv a -> DNameEnv a

extendNameEnv_C :: (a -> a -> a) -> NameEnv a -> Name -> a -> NameEnv a

extendNameEnv_Acc :: (a -> b -> b) -> (a -> b) -> NameEnv b -> Name -> a -> NameEnv b

extendNameEnvList_C :: (a -> a -> a) -> NameEnv a -> [(Name, a)] -> NameEnv a

extendNameEnvList :: NameEnv a -> [(Name, a)] -> NameEnv a

extendNameEnv :: NameEnv a -> Name -> a -> NameEnv a

extendDNameEnv :: DNameEnv a -> Name -> a -> DNameEnv a

emptyNameEnv :: NameEnv a

emptyDNameEnv :: DNameEnv a

elemNameEnv :: Name -> NameEnv a -> Bool

disjointNameEnv :: NameEnv a -> NameEnv a -> Bool

depAnal :: (node -> [Name]) -> (node -> [Name]) -> [node] -> [SCC node]

delListFromNameEnv :: NameEnv a -> [Name] -> NameEnv a

delFromNameEnv :: NameEnv a -> Name -> NameEnv a

delFromDNameEnv :: DNameEnv a -> Name -> DNameEnv a

anyNameEnv :: (elt -> Bool) -> NameEnv elt -> Bool

alterNameEnv :: (Maybe a -> Maybe a) -> NameEnv a -> Name -> NameEnv a

alterDNameEnv :: (Maybe a -> Maybe a) -> DNameEnv a -> Name -> DNameEnv a

adjustDNameEnv :: (a -> a) -> DNameEnv a -> Name -> DNameEnv a

data BuiltInSyntax

BuiltInSyntax is for things like (:), [] and tuples, which have special syntactic forms. They aren't in scope as such.

Constructors

BuiltInSyntax

UserSyntax

wiredInNameTyThing_maybe :: Name -> Maybe TyThing

stableNameCmp :: Name -> Name -> Ordering

Compare Names lexicographically This only works for Names that originate in the source code or have been tidied.

setNameLoc :: Name -> SrcSpan -> Name

pprPrefixName :: NamedThing a => a -> SDoc

pprNameUnqualified :: Name -> SDoc

Print the string of Name unqualifiedly directly.

pprNameDefnLoc :: Name -> SDoc

pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc

pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc

pprDefinedAt :: Name -> SDoc

nameStableString :: Name -> String

Get a string representation of a Name that's unique and stable across recompilations. Used for deterministic generation of binds for derived instances. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"

nameSrcSpan :: Name -> SrcSpan

nameSrcLoc :: Name -> SrcLoc

nameNameSpace :: Name -> NameSpace

nameModule_maybe :: Name -> Maybe Module

nameModule :: HasDebugCallStack => Name -> Module

nameIsLocalOrFrom :: Module -> Name -> Bool

Returns True if the name is (a) Internal (b) External but from the specified module (c) External but from the interactive package

The key idea is that False means: the entity is defined in some other module you can find the details (type, fixity, instances) in some interface file those details will be stored in the EPT or HPT

True means: the entity is defined in this module or earlier in the GHCi session you can find details (type, fixity, instances) in the TcGblEnv or TcLclEnv

The isInteractiveModule part is because successive interactions of a GHCi session each give rise to a fresh module (Ghci1, Ghci2, etc), but they all come from the magic interactive package; and all the details are kept in the TcLclEnv, TcGblEnv, NOT in the HPT or EPT. See Note [The interactive package] in GHC.Runtime.Context

nameIsHomePackageImport :: Module -> Name -> Bool

nameIsHomePackage :: Module -> Name -> Bool

nameIsFromExternalPackage :: HomeUnit -> Name -> Bool

Returns True if the Name comes from some other package: neither this package nor the interactive package.

mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name

Create a name which is actually defined by the compiler itself

mkSystemVarName :: Unique -> FastString -> Name

mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name

mkSystemName :: Unique -> OccName -> Name

Create a name brought into being by the compiler

mkSysTvName :: Unique -> FastString -> Name

mkInternalName :: Unique -> OccName -> SrcSpan -> Name

Create a name which is (for now at least) local to the current module and hence does not need a Module to disambiguate it from other Names

mkFCallName :: Unique -> String -> Name

Make a name for a foreign call

mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name

Create a name which definitely originates in the given module

mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name

mkClonedInternalName :: Unique -> Name -> Name

localiseName :: Name -> Name

Make the Name into an internal name, regardless of what it was to begin with

isWiredInName :: Name -> Bool

isWiredIn :: NamedThing thing => thing -> Bool

isVarName :: Name -> Bool

isValName :: Name -> Bool

isTyVarName :: Name -> Bool

isTyConName :: Name -> Bool

isSystemName :: Name -> Bool

isInternalName :: Name -> Bool

isHoleName :: Name -> Bool

isExternalName :: Name -> Bool

isDynLinkName :: Platform -> Module -> Name -> Bool

Will the Name come from a dynamically linked package?

isDataConName :: Name -> Bool

isBuiltInSyntax :: Name -> Bool

getSrcSpan :: NamedThing a => a -> SrcSpan

getSrcLoc :: NamedThing a => a -> SrcLoc

getOccString :: NamedThing a => a -> String

getOccFS :: NamedThing a => a -> FastString

type TidyOccEnv = UniqFM FastString Int

type OccSet = UniqSet OccName

data OccEnv a

Instances

Data a => Data (OccEnv a)

Defined in GHC.Types.Name.Occurrence

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccEnv a -> c (OccEnv a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OccEnv a)

toConstr :: OccEnv a -> Constr

dataTypeOf :: OccEnv a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (OccEnv a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OccEnv a))

gmapT :: (forall b. Data b => b -> b) -> OccEnv a -> OccEnv a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r

gmapQ :: (forall d. Data d => d -> u) -> OccEnv a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OccEnv a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a)

Outputable a => Outputable (OccEnv a)

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccEnv a -> SDoc

data NameSpace

Instances

Binary NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

put_ :: BinHandle -> NameSpace -> IO ()

put :: BinHandle -> NameSpace -> IO (Bin NameSpace)

get :: BinHandle -> IO NameSpace

Eq NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

(==) :: NameSpace -> NameSpace -> Bool

(/=) :: NameSpace -> NameSpace -> Bool

Ord NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

compare :: NameSpace -> NameSpace -> Ordering

(<) :: NameSpace -> NameSpace -> Bool

(<=) :: NameSpace -> NameSpace -> Bool

(>) :: NameSpace -> NameSpace -> Bool

(>=) :: NameSpace -> NameSpace -> Bool

max :: NameSpace -> NameSpace -> NameSpace

min :: NameSpace -> NameSpace -> NameSpace

varName :: NameSpace

unitOccSet :: OccName -> OccSet

unitOccEnv :: OccName -> a -> OccEnv a

unionOccSets :: OccSet -> OccSet -> OccSet

unionManyOccSets :: [OccSet] -> OccSet

tvName :: NameSpace

tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)

tcName :: NameSpace

tcClsName :: NameSpace

startsWithUnderscore :: OccName -> Bool

Haskell 98 encourages compilers to suppress warnings about unused names in a pattern if they start with _: this implements that test

srcDataName :: NameSpace

setOccNameSpace :: NameSpace -> OccName -> OccName

promoteOccName :: OccName -> Maybe OccName

pprOccName :: OccName -> SDoc

pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc

pprNonVarNameSpace :: NameSpace -> SDoc

pprNameSpaceBrief :: NameSpace -> SDoc

pprNameSpace :: NameSpace -> SDoc

plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a

plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a

parenSymOcc :: OccName -> SDoc -> SDoc

Wrap parens around an operator

occEnvElts :: OccEnv a -> [a]

nameSpacesRelated :: NameSpace -> NameSpace -> Bool

mkWorkerOcc :: OccName -> OccName

mkVarOcc :: String -> OccName

mkTyVarOccFS :: FastString -> OccName

mkTyVarOcc :: String -> OccName

mkTyConRepOcc :: OccName -> OccName

mkTcOccFS :: FastString -> OccName

mkTcOcc :: String -> OccName

mkTag2ConOcc :: OccName -> OccName

mkSuperDictSelOcc

Arguments

:: Int

Index of superclass, e.g. 3

-> OccName

Class, e.g. Ord

-> OccName

Derived Occname, e.g. $p3Ord

mkSuperDictAuxOcc :: Int -> OccName -> OccName

mkSpecOcc :: OccName -> OccName

mkRepEqOcc :: OccName -> OccName

mkOccSet :: [OccName] -> OccSet

mkOccNameFS :: NameSpace -> FastString -> OccName

mkOccName :: NameSpace -> String -> OccName

mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a

mkOccEnv :: [(OccName, a)] -> OccEnv a

mkNewTyCoOcc :: OccName -> OccName

mkMethodOcc :: OccName -> OccName

mkMaxTagOcc :: OccName -> OccName

mkMatcherOcc :: OccName -> OccName

mkLocalOcc

Arguments

:: Unique

Unique to combine with the OccName

-> OccName

Local name, e.g. sat

-> OccName

Nice unique version, e.g. $L23sat

mkInstTyTcOcc

Arguments

:: String

Family name, e.g. Map

-> OccSet

avoid these Occs

-> OccName

R:Map

Derive a name for the representation type constructor of a data/newtype instance.

mkInstTyCoOcc :: OccName -> OccName

mkIPOcc :: OccName -> OccName

mkGenR :: OccName -> OccName

mkGen1R :: OccName -> OccName

mkForeignExportOcc :: OccName -> OccName

mkEqPredCoOcc :: OccName -> OccName

mkDictOcc :: OccName -> OccName

mkDefaultMethodOcc :: OccName -> OccName

mkDataTOcc :: OccName -> OccName

mkDataOccFS :: FastString -> OccName

mkDataOcc :: String -> OccName

mkDataConWrapperOcc :: OccName -> OccName

mkDataConWorkerOcc :: OccName -> OccName

mkDataCOcc :: OccName -> OccName

mkDFunOcc

Arguments

:: String

Typically the class and type glommed together e.g. OrdMaybe. Only used in debug mode, for extra clarity

-> Bool

Is this a hs-boot instance DFun?

-> OccSet

avoid these Occs

-> OccName

E.g. $f3OrdMaybe

mkCon2TagOcc :: OccName -> OccName

mkClsOccFS :: FastString -> OccName

mkClsOcc :: String -> OccName

mkClassOpAuxOcc :: OccName -> OccName

mkClassDataConOcc :: OccName -> OccName

mkBuilderOcc :: OccName -> OccName

minusOccSet :: OccSet -> OccSet -> OccSet

mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b

lookupOccEnv :: OccEnv a -> OccName -> Maybe a

isVarOcc :: OccName -> Bool

isVarNameSpace :: NameSpace -> Bool

isValOcc :: OccName -> Bool

Value OccNamess are those that are either in the variable or data constructor namespaces

isValNameSpace :: NameSpace -> Bool

isTypeableBindOcc :: OccName -> Bool

Is an OccName one of a Typeable TyCon or Module binding? This is needed as these bindings are renamed differently. See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.

isTvOcc :: OccName -> Bool

isTvNameSpace :: NameSpace -> Bool

isTcOcc :: OccName -> Bool

isTcClsNameSpace :: NameSpace -> Bool

isSymOcc :: OccName -> Bool

Test if the OccName is that for any operator (whether it is a data constructor or variable or whatever)

isEmptyOccSet :: OccSet -> Bool

isDerivedOccName :: OccName -> Bool

Test for definitions internally generated by GHC. This predicate is used to suppress printing of internal definitions in some debug prints

isDefaultMethodOcc :: OccName -> Bool

isDataSymOcc :: OccName -> Bool

Test if the OccName is a data constructor that starts with a symbol (e.g. :, or [])

isDataOcc :: OccName -> Bool

isDataConNameSpace :: NameSpace -> Bool

intersectOccSet :: OccSet -> OccSet -> OccSet

initTidyOccEnv :: [OccName] -> TidyOccEnv

foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b

filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet

filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt

extendOccSetList :: OccSet -> [OccName] -> OccSet

extendOccSet :: OccSet -> OccName -> OccSet

extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a

extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b

extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a

extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a

emptyTidyOccEnv :: TidyOccEnv

emptyOccSet :: OccSet

emptyOccEnv :: OccEnv a

elemOccSet :: OccName -> OccSet -> Bool

elemOccEnv :: OccName -> OccEnv a -> Bool

demoteOccName :: OccName -> Maybe OccName

delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv

delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a

delFromOccEnv :: OccEnv a -> OccName -> OccEnv a

dataName :: NameSpace

clsName :: NameSpace

avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv

alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt

type TyVarBinder = VarBndr TyVar ArgFlag

type TyCoVarBinder = VarBndr TyCoVar ArgFlag

Variable Binder

A TyCoVarBinder is the binder of a ForAllTy It's convenient to define this synonym here rather its natural home in GHC.Core.TyCo.Rep, because it's used in GHC.Core.DataCon.hs-boot

A TyVarBinder is a binder with only TyVar

type OutVar = Var

type OutId = Id

type JoinId = Id

type InVar = Var

type InId = Id

type DFunId = Id

Dictionary Function Identifier

updateIdTypeButNotMult :: (Type -> Type) -> Id -> Id

updateIdTypeAndMultM :: Monad m => (Type -> m Type) -> Id -> m Id

updateIdTypeAndMult :: (Type -> Type) -> Id -> Id

tyVarSpecToBinders :: [VarBndr a Specificity] -> [VarBndr a ArgFlag]

tyVarKind :: TyVar -> Kind

setIdMult :: Id -> Mult -> Id

sameVis :: ArgFlag -> ArgFlag -> Bool

Do these denote the same level of visibility? Required arguments are visible, others are not. So this function equates Specified and Inferred. Used for printing.

mkTyVarBinders :: vis -> [TyVar] -> [VarBndr TyVar vis]

Make many named binders Input vars should be type variables

mkTyVarBinder :: vis -> TyVar -> VarBndr TyVar vis

Make a named binder var should be a type variable

mkTyCoVarBinders :: vis -> [TyCoVar] -> [VarBndr TyCoVar vis]

Make many named binders

mkTyCoVarBinder :: vis -> TyCoVar -> VarBndr TyCoVar vis

Make a named binder

isVisibleArgFlag :: ArgFlag -> Bool

Does this ArgFlag classify an argument that is written in Haskell?

isTyVar :: Var -> Bool

Is this a type-level (i.e., computationally irrelevant, thus erasable) variable? Satisfies isTyVar = not . isId.

isLocalId :: Var -> Bool

isInvisibleArgFlag :: ArgFlag -> Bool

Does this ArgFlag classify an argument that is not written in Haskell?

isId :: Var -> Bool

Is this a value-level (i.e., computationally relevant) Varentifier? Satisfies isId = not . isTyVar.

isGlobalId :: Var -> Bool

isExportedId :: Var -> Bool

isExportedIdVar means "don't throw this away"

idInfo :: HasDebugCallStack => Id -> IdInfo

idDetails :: Id -> IdDetails

globaliseId :: Id -> Id

If it's a local, make it global

binderVars :: [VarBndr tv argf] -> [tv]

binderVar :: VarBndr tv argf -> tv

binderType :: VarBndr TyCoVar argf -> Type

binderArgFlag :: VarBndr tv argf -> argf

wordRepDataConTy :: Type

word8RepDataConTy :: Type

word8ElemRepDataConTy :: Type

word64RepDataConTy :: Type

word64ElemRepDataConTy :: Type

word32RepDataConTy :: Type

word32ElemRepDataConTy :: Type

word16RepDataConTy :: Type

word16ElemRepDataConTy :: Type

vecRepDataConTyCon :: TyCon

vecElemTyCon :: TyCon

vecCountTyCon :: TyCon

vec8DataConTy :: Type

vec64DataConTy :: Type

vec4DataConTy :: Type

vec32DataConTy :: Type

vec2DataConTy :: Type

vec16DataConTy :: Type

unrestrictedFunTyCon :: TyCon

unliftedTypeKindTyCon :: TyCon

type UnliftedType = TYPE ('BoxedRep 'Unlifted)

unliftedTypeKind :: Kind

unliftedRepTyCon :: TyCon

type UnliftedRep = 'BoxedRep 'Unlifted

unliftedRepTy :: Type

unliftedDataConTy :: Type

unitTy :: Type

unboxedTupleKind :: [Type] -> Kind

Specialization of unboxedTupleSumKind for tuples

typeSymbolKind :: Kind

tupleTyConName :: TupleSort -> Arity -> Name

tupleTyCon :: Boxity -> Arity -> TyCon

tupleRepDataConTyCon :: TyCon

tupleDataCon :: Boxity -> Arity -> DataCon

sumTyCon :: Arity -> TyCon

Type constructor for n-ary unboxed sum.

sumDataCon :: ConTag -> Arity -> DataCon

Data constructor for i-th alternative of a n-ary unboxed sum.

runtimeRepTyCon :: TyCon

runtimeRepTy :: Type

promotedTupleDataCon :: Boxity -> Arity -> TyCon

oneDataConTyCon :: TyCon

oneDataConTy :: Type

naturalTy :: Type

multiplicityTyCon :: TyCon

multiplicityTy :: Type

multMulTyCon :: TyCon

mkPromotedListTy

Arguments

:: Kind

of the elements of the list

-> [Type]

elements

-> Type

Make a *promoted* list.

mkBoxedTupleTy :: [Type] -> Type

Build the type of a small tuple that holds the specified type of thing Flattens 1-tuples. See Note [One-tuples].

manyDataConTyCon :: TyCon

manyDataConTy :: Type

listTyCon :: TyCon

liftedTypeKindTyCon :: TyCon

liftedTypeKind :: Kind

liftedRepTyCon :: TyCon

type LiftedRep = 'BoxedRep 'Lifted

liftedRepTy :: Type

liftedDataConTyCon :: TyCon

liftedDataConTy :: Type

levityTyCon :: TyCon

integerTy :: Type

intRepDataConTy :: Type

int8RepDataConTy :: Type

int8ElemRepDataConTy :: Type

int64RepDataConTy :: Type

int64ElemRepDataConTy :: Type

int32RepDataConTy :: Type

int32ElemRepDataConTy :: Type

int16RepDataConTy :: Type

int16ElemRepDataConTy :: Type

heqTyCon :: TyCon

floatRepDataConTy :: Type

floatElemRepDataConTy :: Type

doubleRepDataConTy :: Type

doubleElemRepDataConTy :: Type

constraintKind :: Kind

coercibleTyCon :: TyCon

charTy :: Type

cTupleTyConName :: Arity -> Name

cTupleSelIdName :: ConTag -> Arity -> Name

cTupleDataConName :: Arity -> Name

cTupleDataCon :: Arity -> DataCon

boxedRepDataConTyCon :: TyCon

anyTypeOfKind :: Kind -> Type

addrRepDataConTy :: Type

pprType :: Type -> SDoc

pprKind :: Kind -> SDoc

tyConAppTyCon_maybe :: Type -> Maybe TyCon

The same as fst . splitTyConApp

tcView :: Type -> Maybe Type

Gives the typechecker view of a type. This unwraps synonyms but leaves Constraint alone. c.f. coreView, which turns Constraint into Type. Returns Nothing if no unwrapping happens. See also Note [coreView vs tcView]

tYPE :: Type -> Type

Given a RuntimeRep, applies TYPE to it. See Note [TYPE and RuntimeRep] in GHC.Builtin.Types.Prim.

splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])

Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor

piResultTy :: HasDebugCallStack => Type -> Type -> Type

partitionInvisibleTypes :: TyCon -> [Type] -> ([Type], [Type])

Given a TyCon and a list of argument types, partition the arguments into:

1. Inferred or Specified (i.e., invisible) arguments and
2. Required (i.e., visible) arguments

mkTyConTy :: TyCon -> Type

Create the plain type constructor type which has been applied to no type arguments at all.

mkTyConApp :: TyCon -> [Type] -> Type

A key function: builds a TyConApp or FunTy as appropriate to its arguments. Applies its arguments to the constructor from left to right.

mkCastTy :: Type -> Coercion -> Type

Make a CastTy. The Coercion must be nominal. Checks the Coercion for reflexivity, dropping it if it's reflexive. See Note [Respecting definitional equality] in GHC.Core.TyCo.Rep

mkAppTy :: Type -> Type -> Type

Applies a type to another, as in e.g. k a

isRuntimeRepTy :: Type -> Bool

Is this the type RuntimeRep?

isPredTy :: HasDebugCallStack => Type -> Bool

isMultiplicityTy :: Type -> Bool

Is this the type Multiplicity?

isLiftedTypeKind :: Kind -> Bool

This version considers Constraint to be the same as *. Returns True if the argument is equivalent to Type/Constraint and False otherwise. See Note [Kind Constraint and kind Type]

isCoercionTy :: Type -> Bool

coreView :: Type -> Maybe Type

This function strips off the top layer only of a type synonym application (if any) its underlying representation type. Returns Nothing if there is nothing to look through. This function considers Constraint to be a synonym of Type.

By being non-recursive and inlined, this case analysis gets efficiently joined onto the case analysis that the caller is already doing

data UnivCoProvenance

For simplicity, we have just one UnivCo that represents a coercion from some type to some other type, with (in general) no restrictions on the type. The UnivCoProvenance specifies more exactly what the coercion really is and why a program should (or shouldn't!) trust the coercion. It is reasonable to consider each constructor of UnivCoProvenance as a totally independent coercion form; their only commonality is that they don't tell you what types they coercion between. (That info is in the UnivCo constructor of Coercion.

Constructors

PhantomProv KindCoercion

See Note [Phantom coercions]. Only in Phantom roled coercions

ProofIrrelProv KindCoercion

From the fact that any two coercions are considered equivalent. See Note [ProofIrrelProv]. Can be used in Nominal or Representational coercions

PluginProv String

From a plugin, which asserts that this coercion is sound. The string is for the use of the plugin.

CorePrepProv Bool

Instances

Data UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnivCoProvenance -> c UnivCoProvenance

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnivCoProvenance

toConstr :: UnivCoProvenance -> Constr

dataTypeOf :: UnivCoProvenance -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnivCoProvenance)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnivCoProvenance)

gmapT :: (forall b. Data b => b -> b) -> UnivCoProvenance -> UnivCoProvenance

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnivCoProvenance -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnivCoProvenance -> r

gmapQ :: (forall d. Data d => d -> u) -> UnivCoProvenance -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnivCoProvenance -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance

Outputable UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: UnivCoProvenance -> SDoc

data Type

Constructors

TyVarTy Var

Vanilla type or kind variable (*never* a coercion variable)

AppTy Type Type

Type application to something other than a TyCon. Parameters:

1) Function: must not be a TyConApp or CastTy, must be another AppTy, or TyVarTy See Note [Respecting definitional equality] (EQ1) about the no CastTy requirement

2) Argument type

TyConApp TyCon [KindOrType]

Application of a TyCon, including newtypes and synonyms. Invariant: saturated applications of FunTyCon must use FunTy and saturated synonyms must use their own constructors. However, unsaturated FunTyCons do appear as TyConApps. Parameters:

1) Type constructor being applied to.

2) Type arguments. Might not have enough type arguments here to saturate the constructor. Even type synonyms are not necessarily saturated; for example unsaturated type synonyms can appear as the right hand side of a type synonym.

ForAllTy !TyCoVarBinder Type

A Π type. INVARIANT: If the binder is a coercion variable, it must be mentioned in the Type. See Note [Unused coercion variable in ForAllTy]

FunTy

FUN m t1 t2 Very common, so an important special case See Note [Function types]

Fields

• ft_af :: AnonArgFlag
• ft_mult :: Mult
• ft_arg :: Type
• ft_res :: Type

LitTy TyLit

Type literals are similar to type constructors.

CastTy Type KindCoercion

A kind cast. The coercion is always nominal. INVARIANT: The cast is never reflexive (EQ2) INVARIANT: The Type is not a CastTy (use TransCo instead) (EQ3) INVARIANT: The Type is not a ForAllTy over a tyvar (EQ4) See Note [Respecting definitional equality]

CoercionTy Coercion

Injection of a Coercion into a type This should only ever be used in the RHS of an AppTy, in the list of a TyConApp, when applying a promoted GADT data constructor

Instances

Data Type

Defined in GHC.Core.TyCo.Rep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type

toConstr :: Type -> Constr

dataTypeOf :: Type -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)

gmapT :: (forall b. Data b => b -> b) -> Type -> Type

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r

gmapQ :: (forall d. Data d => d -> u) -> Type -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type

Outputable Type

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Type -> SDoc

Eq (DeBruijn Type)

Defined in GHC.Core.Map.Type

Methods

(==) :: DeBruijn Type -> DeBruijn Type -> Bool

(/=) :: DeBruijn Type -> DeBruijn Type -> Bool

data TyLit

Constructors

NumTyLit Integer

StrTyLit FastString

CharTyLit Char

Instances

Data TyLit

Defined in GHC.Core.TyCo.Rep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit

toConstr :: TyLit -> Constr

dataTypeOf :: TyLit -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyLit)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)

gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r

gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

Outputable TyLit

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: TyLit -> SDoc

Eq TyLit

Defined in GHC.Core.TyCo.Rep

Methods

(==) :: TyLit -> TyLit -> Bool

(/=) :: TyLit -> TyLit -> Bool

data TyCoBinder

A TyCoBinder represents an argument to a function. TyCoBinders can be dependent (Named) or nondependent (Anon). They may also be visible or not. See Note [TyCoBinders]

Constructors

Named TyCoVarBinder

Anon AnonArgFlag (Scaled Type)

Instances

Data TyCoBinder

Defined in GHC.Core.TyCo.Rep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCoBinder -> c TyCoBinder

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCoBinder

toConstr :: TyCoBinder -> Constr

dataTypeOf :: TyCoBinder -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCoBinder)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCoBinder)

gmapT :: (forall b. Data b => b -> b) -> TyCoBinder -> TyCoBinder

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCoBinder -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCoBinder -> r

gmapQ :: (forall d. Data d => d -> u) -> TyCoBinder -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCoBinder -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder

Outputable TyCoBinder

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: TyCoBinder -> SDoc

type ThetaType = [PredType]

A collection of PredTypes

data Scaled a

A shorthand for data with an attached Mult element (the multiplicity).

Constructors

Scaled !Mult a

Instances

Data a => Data (Scaled a)

Defined in GHC.Core.TyCo.Rep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scaled a -> c (Scaled a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Scaled a)

toConstr :: Scaled a -> Constr

dataTypeOf :: Scaled a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Scaled a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Scaled a))

gmapT :: (forall b. Data b => b -> b) -> Scaled a -> Scaled a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scaled a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scaled a -> r

gmapQ :: (forall d. Data d => d -> u) -> Scaled a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Scaled a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scaled a -> m (Scaled a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scaled a -> m (Scaled a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scaled a -> m (Scaled a)

Outputable a => Outputable (Scaled a)

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Scaled a -> SDoc

type PredType = Type

A type of the form p of constraint kind represents a value whose type is the Haskell predicate p, where a predicate is what occurs before the => in a Haskell type.

We use PredType as documentation to mark those types that we guarantee to have this kind.

It can be expanded into its representation, but:

• The type checker must treat it as opaque
• The rest of the compiler treats it as transparent

Consider these examples:

f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}

Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"

type Mult = Type

Mult is a type alias for Type.

Mult must contain Type because multiplicity variables are mere type variables (of kind Multiplicity) in Haskell. So the simplest implementation is to make Mult be Type.

Multiplicities can be formed with: - One: GHC.Types.One (= oneDataCon) - Many: GHC.Types.Many (= manyDataCon) - Multiplication: GHC.Types.MultMul (= multMulTyCon)

So that Mult feels a bit more structured, we provide pattern synonyms and smart constructors for these.

type MCoercionN = MCoercion

data MCoercion

A semantically more meaningful type to represent what may or may not be a useful Coercion.

Constructors

MRefl

MCo Coercion

Instances

Data MCoercion

Defined in GHC.Core.TyCo.Rep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MCoercion -> c MCoercion

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MCoercion

toConstr :: MCoercion -> Constr

dataTypeOf :: MCoercion -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MCoercion)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MCoercion)

gmapT :: (forall b. Data b => b -> b) -> MCoercion -> MCoercion

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MCoercion -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MCoercion -> r

gmapQ :: (forall d. Data d => d -> u) -> MCoercion -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MCoercion -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MCoercion -> m MCoercion

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MCoercion -> m MCoercion

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MCoercion -> m MCoercion

Outputable MCoercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: MCoercion -> SDoc

type Kind = Type

The key type representing kinds in the compiler.

type CoercionN = Coercion

data Coercion

A Coercion is concrete evidence of the equality/convertibility of two types.

Constructors

Refl Type

GRefl Role Type MCoercionN

TyConAppCo Role TyCon [Coercion]

AppCo Coercion CoercionN

ForAllCo TyCoVar KindCoercion Coercion

FunCo Role CoercionN Coercion Coercion

CoVarCo CoVar

AxiomInstCo (CoAxiom Branched) BranchIndex [Coercion]

AxiomRuleCo CoAxiomRule [Coercion]

UnivCo UnivCoProvenance Role Type Type

SymCo Coercion

TransCo Coercion Coercion

NthCo Role Int Coercion

LRCo LeftOrRight CoercionN

InstCo Coercion CoercionN

KindCo Coercion

SubCo CoercionN

HoleCo CoercionHole

See Note [Coercion holes] Only present during typechecking

Instances

Data Coercion

Defined in GHC.Core.TyCo.Rep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Coercion -> c Coercion

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Coercion

toConstr :: Coercion -> Constr

dataTypeOf :: Coercion -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Coercion)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Coercion)

gmapT :: (forall b. Data b => b -> b) -> Coercion -> Coercion

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion -> r

gmapQ :: (forall d. Data d => d -> u) -> Coercion -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion

Outputable Coercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Coercion -> SDoc

Eq (DeBruijn Coercion)

Defined in GHC.Core.Map.Type

Methods

(==) :: DeBruijn Coercion -> DeBruijn Coercion -> Bool

(/=) :: DeBruijn Coercion -> DeBruijn Coercion -> Bool

mkTyConTy_ :: TyCon -> Type

Create a nullary TyConApp. In general you should rather use mkTyConTy. This merely exists to break the import cycle between TyCon and this module.

mkFunTyMany :: AnonArgFlag -> Type -> Type -> Type

mkForAllTy :: TyCoVar -> ArgFlag -> Type -> Type

Like mkTyCoForAllTy, but does not check the occurrence of the binder See Note [Unused coercion variable in ForAllTy]

type TyConRepName = Name

data TyCon

TyCons represent type constructors. Type constructors are introduced by things such as:

1) Data declarations: data Foo = ... creates the Foo type constructor of kind *

2) Type synonyms: type Foo = ... creates the Foo type constructor

3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind * -> *

4) Class declarations: class Foo where creates the Foo type constructor of kind *

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

Instances

Data TyCon

Defined in GHC.Core.TyCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCon -> c TyCon

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCon

toConstr :: TyCon -> Constr

dataTypeOf :: TyCon -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCon)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCon)

gmapT :: (forall b. Data b => b -> b) -> TyCon -> TyCon

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r

gmapQ :: (forall d. Data d => d -> u) -> TyCon -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCon -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon

NamedThing TyCon

Defined in GHC.Core.TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

Uniquable TyCon

Defined in GHC.Core.TyCon

Methods

getUnique :: TyCon -> Unique

Outputable TyCon

Defined in GHC.Core.TyCon

Methods

ppr :: TyCon -> SDoc

Eq TyCon

Defined in GHC.Core.TyCon

Methods

(==) :: TyCon -> TyCon -> Bool

(/=) :: TyCon -> TyCon -> Bool

tyConRepName_maybe :: TyCon -> Maybe TyConRepName

mkPrelTyConRepName :: Name -> TyConRepName

Make a Name for the Typeable representation of the given wired-in type

isUnboxedTupleTyCon :: TyCon -> Bool

Is this the TyCon for an unboxed tuple?

isTupleTyCon :: TyCon -> Bool

Does this TyCon represent a tuple?

NB: when compiling Data.Tuple, the tycons won't reply True to isTupleTyCon, because they are built as AlgTyCons. However they get spat into the interface file as tuple tycons, so I don't think it matters.

isFunTyCon :: TyCon -> Bool

data Bag a

Instances

Foldable Bag

Defined in GHC.Data.Bag

Methods

fold :: Monoid m => Bag m -> m

foldMap :: Monoid m => (a -> m) -> Bag a -> m

foldMap' :: Monoid m => (a -> m) -> Bag a -> m

foldr :: (a -> b -> b) -> b -> Bag a -> b

foldr' :: (a -> b -> b) -> b -> Bag a -> b

foldl :: (b -> a -> b) -> b -> Bag a -> b

foldl' :: (b -> a -> b) -> b -> Bag a -> b

foldr1 :: (a -> a -> a) -> Bag a -> a

foldl1 :: (a -> a -> a) -> Bag a -> a

toList :: Bag a -> [a]

null :: Bag a -> Bool

length :: Bag a -> Int

elem :: Eq a => a -> Bag a -> Bool

maximum :: Ord a => Bag a -> a

minimum :: Ord a => Bag a -> a

sum :: Num a => Bag a -> a

product :: Num a => Bag a -> a

Traversable Bag

Defined in GHC.Data.Bag

Methods

traverse :: Applicative f => (a -> f b) -> Bag a -> f (Bag b)

sequenceA :: Applicative f => Bag (f a) -> f (Bag a)

mapM :: Monad m => (a -> m b) -> Bag a -> m (Bag b)

sequence :: Monad m => Bag (m a) -> m (Bag a)

Functor Bag

Defined in GHC.Data.Bag

Methods

fmap :: (a -> b) -> Bag a -> Bag b

(<$) :: a -> Bag b -> Bag a

Data a => Data (Bag a)

Defined in GHC.Data.Bag

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bag a -> c (Bag a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bag a)

toConstr :: Bag a -> Constr

dataTypeOf :: Bag a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bag a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bag a))

gmapT :: (forall b. Data b => b -> b) -> Bag a -> Bag a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bag a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bag a -> r

gmapQ :: (forall d. Data d => d -> u) -> Bag a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bag a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bag a -> m (Bag a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bag a -> m (Bag a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bag a -> m (Bag a)

IsList (Bag a)

Defined in GHC.Data.Bag

Associated Types

type Item (Bag a)

Methods

fromList :: [Item (Bag a)] -> Bag a

fromListN :: Int -> [Item (Bag a)] -> Bag a

toList :: Bag a -> [Item (Bag a)]

Outputable a => Outputable (Bag a)

Defined in GHC.Data.Bag

Methods

ppr :: Bag a -> SDoc

type Item (Bag a)

Defined in GHC.Data.Bag

type Item (Bag a) = a

unitBag :: a -> Bag a

unionManyBags :: [Bag a] -> Bag a

unionBags :: Bag a -> Bag a -> Bag a

snocBag :: Bag a -> a -> Bag a infixl 3

partitionBagWith :: (a -> Either b c) -> Bag a -> (Bag b, Bag c)

partitionBag :: (a -> Bool) -> Bag a -> (Bag a, Bag a)

nonEmptyToBag :: NonEmpty a -> Bag a

mapMaybeBag :: (a -> Maybe b) -> Bag a -> Bag b

mapBagM_ :: Monad m => (a -> m b) -> Bag a -> m ()

mapBagM :: Monad m => (a -> m b) -> Bag a -> m (Bag b)

mapBag :: (a -> b) -> Bag a -> Bag b

mapAndUnzipBagM :: Monad m => (a -> m (b, c)) -> Bag a -> m (Bag b, Bag c)

mapAccumBagLM

Arguments

:: Monad m

=> (acc -> x -> m (acc, y))

combining function

-> acc

initial state

-> Bag x

inputs

-> m (acc, Bag y)

final state, outputs

mapAccumBagL

Arguments

:: (acc -> x -> (acc, y))

combining function

-> acc

initial state

-> Bag x

inputs

-> (acc, Bag y)

final state, outputs

listToBag :: [a] -> Bag a

lengthBag :: Bag a -> Int

isSingletonBag :: Bag a -> Bool

isEmptyBag :: Bag a -> Bool

foldBag :: (r -> r -> r) -> (a -> r) -> r -> Bag a -> r

flatMapBagPairM :: Monad m => (a -> m (Bag b, Bag c)) -> Bag a -> m (Bag b, Bag c)

flatMapBagM :: Monad m => (a -> m (Bag b)) -> Bag a -> m (Bag b)

filterBagM :: Monad m => (a -> m Bool) -> Bag a -> m (Bag a)

filterBag :: (a -> Bool) -> Bag a -> Bag a

emptyBag :: Bag a

elemBag :: Eq a => a -> Bag a -> Bool

consBag :: a -> Bag a -> Bag a infixr 3

concatMapBagPair :: (a -> (Bag b, Bag c)) -> Bag a -> (Bag b, Bag c)

concatMapBag :: (a -> Bag b) -> Bag a -> Bag b

concatBag :: Bag (Bag a) -> Bag a

catBagMaybes :: Bag (Maybe a) -> Bag a

bagToList :: Bag a -> [a]

anyBagM :: Monad m => (a -> m Bool) -> Bag a -> m Bool

anyBag :: (a -> Bool) -> Bag a -> Bool

allBag :: (a -> Bool) -> Bag a -> Bool

data TcTyVarDetails

Constructors

SkolemTv TcLevel Bool

RuntimeUnk

MetaTv

Fields

• mtv_info :: MetaInfo
• mtv_ref :: IORef MetaDetails
• mtv_tclvl :: TcLevel

Instances

Outputable TcTyVarDetails

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: TcTyVarDetails -> SDoc

data MetaDetails

Constructors

Flexi

Indirect TcType

Instances

Outputable MetaDetails

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: MetaDetails -> SDoc

vanillaSkolemTv :: TcTyVarDetails

pprTcTyVarDetails :: TcTyVarDetails -> SDoc

isTyConableTyVar :: TcTyVar -> Bool

isMetaTyVar :: TcTyVar -> Bool

data TypeOrKind

Flag to see whether we're type-checking terms or kind-checking types

Constructors

TypeLevel

KindLevel

Instances

Outputable TypeOrKind

Defined in GHC.Types.Basic

Methods

ppr :: TypeOrKind -> SDoc

Eq TypeOrKind

Defined in GHC.Types.Basic

Methods

(==) :: TypeOrKind -> TypeOrKind -> Bool

(/=) :: TypeOrKind -> TypeOrKind -> Bool

data TupleSort

Constructors

BoxedTuple

UnboxedTuple

ConstraintTuple

Instances

Data TupleSort

Defined in GHC.Types.Basic

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 :: forall r r'. (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

Binary TupleSort

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> TupleSort -> IO ()

put :: BinHandle -> TupleSort -> IO (Bin TupleSort)

get :: BinHandle -> IO TupleSort

Outputable TupleSort

Defined in GHC.Types.Basic

Methods

ppr :: TupleSort -> SDoc

Eq TupleSort

Defined in GHC.Types.Basic

Methods

(==) :: TupleSort -> TupleSort -> Bool

(/=) :: TupleSort -> TupleSort -> Bool

data TopLevelFlag

Constructors

TopLevel

NotTopLevel

Instances

Data TopLevelFlag

Defined in GHC.Types.Basic

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TopLevelFlag -> c TopLevelFlag

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TopLevelFlag

toConstr :: TopLevelFlag -> Constr

dataTypeOf :: TopLevelFlag -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TopLevelFlag)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TopLevelFlag)

gmapT :: (forall b. Data b => b -> b) -> TopLevelFlag -> TopLevelFlag

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TopLevelFlag -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TopLevelFlag -> r

gmapQ :: (forall d. Data d => d -> u) -> TopLevelFlag -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TopLevelFlag -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TopLevelFlag -> m TopLevelFlag

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TopLevelFlag -> m TopLevelFlag

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TopLevelFlag -> m TopLevelFlag

Outputable TopLevelFlag

Defined in GHC.Types.Basic

Methods

ppr :: TopLevelFlag -> SDoc

data TailCallInfo

Constructors

AlwaysTailCalled JoinArity

NoTailCallInfo

Instances

Outputable TailCallInfo

Defined in GHC.Types.Basic

Methods

ppr :: TailCallInfo -> SDoc

Eq TailCallInfo

Defined in GHC.Types.Basic

Methods

(==) :: TailCallInfo -> TailCallInfo -> Bool

(/=) :: TailCallInfo -> TailCallInfo -> Bool

data SwapFlag

Constructors

NotSwapped

IsSwapped

Instances

Outputable SwapFlag

Defined in GHC.Types.Basic

Methods

ppr :: SwapFlag -> SDoc

data SuccessFlag

Constructors

Succeeded

Failed

Instances

Outputable SuccessFlag

Defined in GHC.Types.Basic

Methods

ppr :: SuccessFlag -> SDoc

data SpliceExplicitFlag

Constructors

ExplicitSplice

= $(f x y)

ImplicitSplice

= f x y, i.e. a naked top level expression

Instances

Data SpliceExplicitFlag

Defined in GHC.Types.Basic

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 :: forall r r'. (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

type RuleName = FastString

data RuleMatchInfo

Rule Match Information

Constructors

ConLike

FunLike

Instances

Data RuleMatchInfo

Defined in GHC.Types.Basic

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 :: forall r r'. (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 GHC.Types.Basic

Methods

showsPrec :: Int -> RuleMatchInfo -> ShowS

show :: RuleMatchInfo -> String

showList :: [RuleMatchInfo] -> ShowS

Binary RuleMatchInfo

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> RuleMatchInfo -> IO ()

put :: BinHandle -> RuleMatchInfo -> IO (Bin RuleMatchInfo)

get :: BinHandle -> IO RuleMatchInfo

Outputable RuleMatchInfo

Defined in GHC.Types.Basic

Methods

ppr :: RuleMatchInfo -> SDoc

Eq RuleMatchInfo

Defined in GHC.Types.Basic

Methods

(==) :: RuleMatchInfo -> RuleMatchInfo -> Bool

(/=) :: RuleMatchInfo -> RuleMatchInfo -> Bool

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 (# x, y #) -> fib (x + y) has representation arity 2

data RecFlag

Recursivity Flag

Constructors

Recursive

NonRecursive

Instances

Data RecFlag

Defined in GHC.Types.Basic

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 :: forall r r'. (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

Binary RecFlag

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> RecFlag -> IO ()

put :: BinHandle -> RecFlag -> IO (Bin RecFlag)

get :: BinHandle -> IO RecFlag

Outputable RecFlag

Defined in GHC.Types.Basic

Methods

ppr :: RecFlag -> SDoc

Eq RecFlag

Defined in GHC.Types.Basic

Methods

(==) :: RecFlag -> RecFlag -> Bool

(/=) :: RecFlag -> RecFlag -> Bool

data PromotionFlag

Is a TyCon a promoted data constructor or just a normal type constructor?

Constructors

NotPromoted

IsPromoted

Instances

Data PromotionFlag

Defined in GHC.Types.Basic

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 :: forall r r'. (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 GHC.Types.Basic

Methods

put_ :: BinHandle -> PromotionFlag -> IO ()

put :: BinHandle -> PromotionFlag -> IO (Bin PromotionFlag)

get :: BinHandle -> IO PromotionFlag

Outputable PromotionFlag

Defined in GHC.Types.Basic

Methods

ppr :: PromotionFlag -> SDoc

Eq PromotionFlag

Defined in GHC.Types.Basic

Methods

(==) :: PromotionFlag -> PromotionFlag -> Bool

(/=) :: PromotionFlag -> PromotionFlag -> Bool

newtype PprPrec

A general-purpose pretty-printing precedence type.

Constructors

PprPrec Int

Instances

Show PprPrec

Defined in GHC.Types.Basic

Methods

showsPrec :: Int -> PprPrec -> ShowS

show :: PprPrec -> String

showList :: [PprPrec] -> ShowS

Eq PprPrec

Defined in GHC.Types.Basic

Methods

(==) :: PprPrec -> PprPrec -> Bool

(/=) :: PprPrec -> PprPrec -> Bool

Ord PprPrec

Defined in GHC.Types.Basic

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

type PhaseNum = Int

Phase Number

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 {-# OVERLAPPABLE #-} 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 {-# OVERLAPPING #-} 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 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 GHC.Core.InstEnv

Instances

Data OverlapMode

Defined in GHC.Types.Basic

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 :: forall r r'. (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

Binary OverlapMode

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> OverlapMode -> IO ()

put :: BinHandle -> OverlapMode -> IO (Bin OverlapMode)

get :: BinHandle -> IO OverlapMode

Outputable OverlapMode

Defined in GHC.Types.Basic

Methods

ppr :: OverlapMode -> SDoc

Eq OverlapMode

Defined in GHC.Types.Basic

Methods

(==) :: OverlapMode -> OverlapMode -> Bool

(/=) :: OverlapMode -> OverlapMode -> Bool

type Anno OverlapMode

Defined in GHC.Hs.Decls

type Anno OverlapMode = SrcSpanAnnP

type Anno OverlapMode

Defined in GHC.Hs.Decls

type Anno OverlapMode = SrcSpanAnnP

data OverlapFlag

The semantics allowed for overlapping instances for a particular instance. See Note [Safe Haskell isSafeOverlap] (in GHC.Core.InstEnv) 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

Data OverlapFlag

Defined in GHC.Types.Basic

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 :: forall r r'. (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

Binary OverlapFlag

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> OverlapFlag -> IO ()

put :: BinHandle -> OverlapFlag -> IO (Bin OverlapFlag)

get :: BinHandle -> IO OverlapFlag

Outputable OverlapFlag

Defined in GHC.Types.Basic

Methods

ppr :: OverlapFlag -> SDoc

Eq OverlapFlag

Defined in GHC.Types.Basic

Methods

(==) :: OverlapFlag -> OverlapFlag -> Bool

(/=) :: OverlapFlag -> OverlapFlag -> Bool

data Origin

Constructors

FromSource

Generated

Instances

Data Origin

Defined in GHC.Types.Basic

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 :: forall r r'. (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 GHC.Types.Basic

Methods

ppr :: Origin -> SDoc

Eq Origin

Defined in GHC.Types.Basic

Methods

(==) :: Origin -> Origin -> Bool

(/=) :: Origin -> Origin -> Bool

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.

See also Note [OneShotInfo overview] above.

Constructors

NoOneShotInfo

No information

OneShotLam

The lambda is applied at most once.

Instances

Outputable OneShotInfo

Defined in GHC.Types.Basic

Methods

ppr :: OneShotInfo -> SDoc

Eq OneShotInfo

Defined in GHC.Types.Basic

Methods

(==) :: OneShotInfo -> OneShotInfo -> Bool

(/=) :: OneShotInfo -> OneShotInfo -> Bool

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_n_br :: !BranchCount
• 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

Outputable OccInfo

Defined in GHC.Types.Basic

Methods

ppr :: OccInfo -> SDoc

Eq OccInfo

Defined in GHC.Types.Basic

Methods

(==) :: OccInfo -> OccInfo -> Bool

(/=) :: OccInfo -> OccInfo -> Bool

data LeftOrRight

Constructors

CLeft

CRight

Instances

Data LeftOrRight

Defined in GHC.Types.Basic

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 :: forall r r'. (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

Binary LeftOrRight

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> LeftOrRight -> IO ()

put :: BinHandle -> LeftOrRight -> IO (Bin LeftOrRight)

get :: BinHandle -> IO LeftOrRight

Outputable LeftOrRight

Defined in GHC.Types.Basic

Methods

ppr :: LeftOrRight -> SDoc

Eq LeftOrRight

Defined in GHC.Types.Basic

Methods

(==) :: LeftOrRight -> LeftOrRight -> Bool

(/=) :: LeftOrRight -> LeftOrRight -> Bool

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 InterestingCxt

Interesting Context

Constructors

IsInteresting

Function: is applied Data value: scrutinised by a case with at least one non-DEFAULT branch

NotInteresting

Instances

Monoid InterestingCxt

Defined in GHC.Types.Basic

Methods

mempty :: InterestingCxt

mappend :: InterestingCxt -> InterestingCxt -> InterestingCxt

mconcat :: [InterestingCxt] -> InterestingCxt

Semigroup InterestingCxt

If there is any interesting identifier occurrence, then the aggregated occurrence info of that identifier is considered interesting.

Defined in GHC.Types.Basic

Methods

(<>) :: InterestingCxt -> InterestingCxt -> InterestingCxt

sconcat :: NonEmpty InterestingCxt -> InterestingCxt

stimes :: Integral b => b -> InterestingCxt -> InterestingCxt

Eq InterestingCxt

Defined in GHC.Types.Basic

Methods

(==) :: InterestingCxt -> InterestingCxt -> Bool

(/=) :: InterestingCxt -> InterestingCxt -> Bool

data IntWithInf

An integer or infinity

Instances

Num IntWithInf

Defined in GHC.Types.Basic

Methods

(+) :: IntWithInf -> IntWithInf -> IntWithInf

(-) :: IntWithInf -> IntWithInf -> IntWithInf

(*) :: IntWithInf -> IntWithInf -> IntWithInf

negate :: IntWithInf -> IntWithInf

abs :: IntWithInf -> IntWithInf

signum :: IntWithInf -> IntWithInf

fromInteger :: Integer -> IntWithInf

Outputable IntWithInf

Defined in GHC.Types.Basic

Methods

ppr :: IntWithInf -> SDoc

Eq IntWithInf

Defined in GHC.Types.Basic

Methods

(==) :: IntWithInf -> IntWithInf -> Bool

(/=) :: IntWithInf -> IntWithInf -> Bool

Ord IntWithInf

Defined in GHC.Types.Basic

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

data InsideLam

Inside Lambda

Constructors

IsInsideLam

Occurs inside a non-linear lambda Substituting a redex for this occurrence is dangerous because it might duplicate work.

NotInsideLam

Instances

Monoid InsideLam

Defined in GHC.Types.Basic

Methods

mempty :: InsideLam

mappend :: InsideLam -> InsideLam -> InsideLam

mconcat :: [InsideLam] -> InsideLam

Semigroup InsideLam

If any occurrence of an identifier is inside a lambda, then the occurrence info of that identifier marks it as occurring inside a lambda

Defined in GHC.Types.Basic

Methods

(<>) :: InsideLam -> InsideLam -> InsideLam

sconcat :: NonEmpty InsideLam -> InsideLam

stimes :: Integral b => b -> InsideLam -> InsideLam

Eq InsideLam

Defined in GHC.Types.Basic

Methods

(==) :: InsideLam -> InsideLam -> Bool

(/=) :: InsideLam -> InsideLam -> Bool

data InlineSpec

Inline Specification

Constructors

Inline

Inlinable

NoInline

NoUserInlinePrag

Instances

Data InlineSpec

Defined in GHC.Types.Basic

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 :: forall r r'. (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 GHC.Types.Basic

Methods

showsPrec :: Int -> InlineSpec -> ShowS

show :: InlineSpec -> String

showList :: [InlineSpec] -> ShowS

Binary InlineSpec

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> InlineSpec -> IO ()

put :: BinHandle -> InlineSpec -> IO (Bin InlineSpec)

get :: BinHandle -> IO InlineSpec

Outputable InlineSpec

Defined in GHC.Types.Basic

Methods

ppr :: InlineSpec -> SDoc

Eq InlineSpec

Defined in GHC.Types.Basic

Methods

(==) :: InlineSpec -> InlineSpec -> Bool

(/=) :: InlineSpec -> InlineSpec -> Bool

data InlinePragma

Constructors

InlinePragma

Fields

• inl_src :: SourceText
• inl_inline :: InlineSpec
• inl_sat :: Maybe Arity
• inl_act :: Activation
• inl_rule :: RuleMatchInfo

Instances

Data InlinePragma

Defined in GHC.Types.Basic

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 :: forall r r'. (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

Binary InlinePragma

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> InlinePragma -> IO ()

put :: BinHandle -> InlinePragma -> IO (Bin InlinePragma)

get :: BinHandle -> IO InlinePragma

Outputable InlinePragma

Defined in GHC.Types.Basic

Methods

ppr :: InlinePragma -> SDoc

Eq InlinePragma

Defined in GHC.Types.Basic

Methods

(==) :: InlinePragma -> InlinePragma -> Bool

(/=) :: InlinePragma -> InlinePragma -> Bool

data FunctionOrData

Constructors

IsFunction

IsData

Instances

Data FunctionOrData

Defined in GHC.Types.Basic

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 :: forall r r'. (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

Binary FunctionOrData

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> FunctionOrData -> IO ()

put :: BinHandle -> FunctionOrData -> IO (Bin FunctionOrData)

get :: BinHandle -> IO FunctionOrData

Outputable FunctionOrData

Defined in GHC.Types.Basic

Methods

ppr :: FunctionOrData -> SDoc

Eq FunctionOrData

Defined in GHC.Types.Basic

Methods

(==) :: FunctionOrData -> FunctionOrData -> Bool

(/=) :: FunctionOrData -> FunctionOrData -> Bool

Ord FunctionOrData

Defined in GHC.Types.Basic

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

type FullArgCount = Int

FullArgCount is the number of type or value arguments in an application, or the number of type or value binders in a lambda. Note: it includes both type and value arguments!

data EP a

Embedding Projection pair

Constructors

EP

Fields

• fromEP :: a
• toEP :: a

data DefMethSpec ty

Default Method Specification

Constructors

VanillaDM

GenericDM ty

Instances

Binary (DefMethSpec IfaceType)

Defined in GHC.Iface.Type

Methods

put_ :: BinHandle -> DefMethSpec IfaceType -> IO ()

put :: BinHandle -> DefMethSpec IfaceType -> IO (Bin (DefMethSpec IfaceType))

get :: BinHandle -> IO (DefMethSpec IfaceType)

Outputable (DefMethSpec ty)

Defined in GHC.Types.Basic

Methods

ppr :: DefMethSpec ty -> SDoc

type ConTagZ = Int

A *zero-indexed* constructor tag

type ConTag = Int

A *one-index* constructor tag

Type of the tags associated with each constructor possibility or superclass selector

data CompilerPhase

Constructors

InitialPhase

Phase PhaseNum

FinalPhase

Instances

Outputable CompilerPhase

Defined in GHC.Types.Basic

Methods

ppr :: CompilerPhase -> SDoc

Eq CompilerPhase

Defined in GHC.Types.Basic

Methods

(==) :: CompilerPhase -> CompilerPhase -> Bool

(/=) :: CompilerPhase -> CompilerPhase -> Bool

type BranchCount = Int

data Boxity

Constructors

Boxed

Unboxed

Instances

Data Boxity

Defined in GHC.Types.Basic

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 :: forall r r'. (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 GHC.Types.Basic

Methods

ppr :: Boxity -> SDoc

Eq Boxity

Defined in GHC.Types.Basic

Methods

(==) :: Boxity -> Boxity -> Bool

(/=) :: Boxity -> Boxity -> Bool

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 GHC.Core.Opt.Arity

data Alignment

A power-of-two alignment

Instances

Outputable Alignment

Defined in GHC.Types.Basic

Methods

ppr :: Alignment -> SDoc

Eq Alignment

Defined in GHC.Types.Basic

Methods

(==) :: Alignment -> Alignment -> Bool

(/=) :: Alignment -> Alignment -> Bool

Ord Alignment

Defined in GHC.Types.Basic

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

OutputableP env Alignment

Defined in GHC.Types.Basic

Methods

pdoc :: env -> Alignment -> SDoc

data Activation

Constructors

AlwaysActive

ActiveBefore SourceText PhaseNum

ActiveAfter SourceText PhaseNum

FinalActive

NeverActive

Instances

Data Activation

Defined in GHC.Types.Basic

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 :: forall r r'. (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

Binary Activation

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> Activation -> IO ()

put :: BinHandle -> Activation -> IO (Bin Activation)

get :: BinHandle -> IO Activation

Outputable Activation

Defined in GHC.Types.Basic

Methods

ppr :: Activation -> SDoc

Eq Activation

Defined in GHC.Types.Basic

Methods

(==) :: Activation -> Activation -> Bool

(/=) :: Activation -> Activation -> Bool

zapOccTailCallInfo :: OccInfo -> OccInfo

zapFragileOcc :: OccInfo -> OccInfo

worstOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo

weakLoopBreaker :: OccInfo

unSwap :: SwapFlag -> (a -> a -> b) -> a -> a -> b

tupleSortBoxity :: TupleSort -> Boxity

tupleParens :: TupleSort -> SDoc -> SDoc

treatZeroAsInf :: Int -> IntWithInf

Turn a positive number into an IntWithInf, where 0 represents infinity

topPrec :: PprPrec

tailCallInfo :: OccInfo -> TailCallInfo

sumParens :: SDoc -> SDoc

successIf :: Bool -> SuccessFlag

succeeded :: SuccessFlag -> Bool

strongLoopBreaker :: OccInfo

starPrec :: PprPrec

sigPrec :: PprPrec

setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag

setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma

setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma

seqOccInfo :: OccInfo -> ()

pprRuleName :: RuleName -> SDoc

pprInlineDebug :: InlinePragma -> SDoc

pprInline :: InlinePragma -> 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 | |".

pickLR :: LeftOrRight -> (a, a) -> a

opPrec :: PprPrec

oneBranch :: BranchCount

noUserInlineSpec :: InlineSpec -> Bool

noOneShotInfo :: OneShotInfo

It is always safe to assume that an Id has no lambda-bound variable information

noOccInfo :: OccInfo

neverInlinePragma :: InlinePragma

mkIntWithInf :: Int -> IntWithInf

Inject any integer into an IntWithInf

mkAlignment :: Int -> Alignment

maybeParen :: PprPrec -> PprPrec -> SDoc -> SDoc

isWeakLoopBreaker :: OccInfo -> Bool

isTypeLevel :: TypeOrKind -> Bool

isTopLevel :: TopLevelFlag -> Bool

isSwapped :: SwapFlag -> Bool

isStrongLoopBreaker :: OccInfo -> Bool

isRec :: RecFlag -> Bool

isPromoted :: PromotionFlag -> Bool

isOneShotInfo :: OneShotInfo -> Bool

isOneOcc :: OccInfo -> Bool

isNotTopLevel :: TopLevelFlag -> Bool

isNonRec :: RecFlag -> Bool

isNoOccInfo :: OccInfo -> Bool

isNeverActive :: Activation -> Bool

isManyOccs :: OccInfo -> Bool

isKindLevel :: TypeOrKind -> Bool

isInlinePragma :: InlinePragma -> Bool

isInlinablePragma :: InlinePragma -> Bool

isGenerated :: Origin -> Bool

isFunLike :: RuleMatchInfo -> Bool

isDefaultInlinePragma :: InlinePragma -> Bool

isDeadOcc :: OccInfo -> Bool

isConLike :: RuleMatchInfo -> Bool

isBoxed :: Boxity -> Bool

isAnyInlinePragma :: InlinePragma -> Bool

isAlwaysTailCalled :: OccInfo -> Bool

isAlwaysActive :: Activation -> Bool

isActive :: CompilerPhase -> Activation -> Bool

intGtLimit :: Int -> IntWithInf -> Bool

inlinePragmaSpec :: InlinePragma -> InlineSpec

inlinePragmaSat :: InlinePragma -> Maybe Arity

inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo

inlinePragmaActivation :: InlinePragma -> Activation

infinity :: IntWithInf

A representation of infinity

hasOverlappingFlag :: OverlapMode -> Bool

hasOverlappableFlag :: OverlapMode -> Bool

hasNoOneShotInfo :: OneShotInfo -> Bool

hasIncoherentFlag :: OverlapMode -> Bool

funPrec :: PprPrec

flipSwap :: SwapFlag -> SwapFlag

failed :: SuccessFlag -> Bool

fIRST_TAG :: ConTag

Tags are allocated from here for real constructors or for superclass selectors

dfunInlinePragma :: InlinePragma

defaultInlinePragma :: InlinePragma

competesWith :: Activation -> Activation -> Bool

boxityTupleSort :: Boxity -> TupleSort

boolToRecFlag :: Bool -> RecFlag

bestOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo

appPrec :: PprPrec

alwaysInlinePragma :: InlinePragma

alignmentOf :: Int -> Alignment

activeInFinalPhase :: Activation -> Bool

activateDuringFinal :: Activation

activateAfterInitial :: Activation

idName :: Id -> Name

data Var

Variable

Essentially a typed Name, that may also contain some additional information about the Var and its use sites.

Instances

Data Var

Defined in GHC.Types.Var

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Var -> c Var

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Var

toConstr :: Var -> Constr

dataTypeOf :: Var -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Var)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)

gmapT :: (forall b. Data b => b -> b) -> Var -> Var

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r

gmapQ :: (forall d. Data d => d -> u) -> Var -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Var -> m Var

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var

NamedThing Var

Defined in GHC.Types.Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

HasOccName Var

Defined in GHC.Types.Var

Methods

occName :: Var -> OccName

Uniquable Var

Defined in GHC.Types.Var

Methods

getUnique :: Var -> Unique

Outputable Var

Defined in GHC.Types.Var

Methods

ppr :: Var -> SDoc

Eq Var

Defined in GHC.Types.Var

Methods

(==) :: Var -> Var -> Bool

(/=) :: Var -> Var -> Bool

Ord Var

Defined in GHC.Types.Var

Methods

compare :: Var -> Var -> Ordering

(<) :: Var -> Var -> Bool

(<=) :: Var -> Var -> Bool

(>) :: Var -> Var -> Bool

(>=) :: Var -> Var -> Bool

max :: Var -> Var -> Var

min :: Var -> Var -> Var

type Anno Id

Defined in GHC.Hs.Extension

type Anno Id = SrcSpanAnnN

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type TyVar = Var

Type or kind Variable

type TyCoVar = Id

Type or Coercion Variable

type TcTyVar = Var

Type variable that might be a metavariable

data Specificity

Whether an Invisible argument may appear in source Haskell.

Constructors

InferredSpec

the argument may not appear in source Haskell, it is only inferred.

SpecifiedSpec

the argument may appear in source Haskell, but isn't required.

Instances

Data Specificity

Defined in GHC.Types.Var

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Specificity -> c Specificity

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Specificity

toConstr :: Specificity -> Constr

dataTypeOf :: Specificity -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Specificity)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Specificity)

gmapT :: (forall b. Data b => b -> b) -> Specificity -> Specificity

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r

gmapQ :: (forall d. Data d => d -> u) -> Specificity -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Specificity -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity

Binary Specificity

Defined in GHC.Types.Var

Methods

put_ :: BinHandle -> Specificity -> IO ()

put :: BinHandle -> Specificity -> IO (Bin Specificity)

get :: BinHandle -> IO Specificity

Eq Specificity

Defined in GHC.Types.Var

Methods

(==) :: Specificity -> Specificity -> Bool

(/=) :: Specificity -> Specificity -> Bool

Ord Specificity

Defined in GHC.Types.Var

Methods

compare :: Specificity -> Specificity -> Ordering

(<) :: Specificity -> Specificity -> Bool

(<=) :: Specificity -> Specificity -> Bool

(>) :: Specificity -> Specificity -> Bool

(>=) :: Specificity -> Specificity -> Bool

max :: Specificity -> Specificity -> Specificity

min :: Specificity -> Specificity -> Specificity

OutputableBndrFlag Specificity p

Defined in GHC.Hs.Type

Methods

pprTyVarBndr :: HsTyVarBndr Specificity (GhcPass p) -> SDoc

Outputable tv => Outputable (VarBndr tv Specificity)

Defined in GHC.Types.Var

Methods

ppr :: VarBndr tv Specificity -> SDoc

type Id = Var

Identifier

data ArgFlag

Argument Flag

Is something required to appear in source Haskell (Required), permitted by request (Specified) (visible type application), or prohibited entirely from appearing in source Haskell (Inferred)? See Note [VarBndrs, TyCoVarBinders, TyConBinders, and visibility] in GHC.Core.TyCo.Rep

Constructors

Invisible Specificity

Required

Bundled Patterns

pattern Specified :: ArgFlag

pattern Inferred :: ArgFlag

Instances

Data ArgFlag

Defined in GHC.Types.Var

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArgFlag -> c ArgFlag

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArgFlag

toConstr :: ArgFlag -> Constr

dataTypeOf :: ArgFlag -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArgFlag)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArgFlag)

gmapT :: (forall b. Data b => b -> b) -> ArgFlag -> ArgFlag

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r

gmapQ :: (forall d. Data d => d -> u) -> ArgFlag -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ArgFlag -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

Binary ArgFlag

Defined in GHC.Types.Var

Methods

put_ :: BinHandle -> ArgFlag -> IO ()

put :: BinHandle -> ArgFlag -> IO (Bin ArgFlag)

get :: BinHandle -> IO ArgFlag

Outputable ArgFlag

Defined in GHC.Types.Var

Methods

ppr :: ArgFlag -> SDoc

Eq ArgFlag

Defined in GHC.Types.Var

Methods

(==) :: ArgFlag -> ArgFlag -> Bool

(/=) :: ArgFlag -> ArgFlag -> Bool

Ord ArgFlag

Defined in GHC.Types.Var

Methods

compare :: ArgFlag -> ArgFlag -> Ordering

(<) :: ArgFlag -> ArgFlag -> Bool

(<=) :: ArgFlag -> ArgFlag -> Bool

(>) :: ArgFlag -> ArgFlag -> Bool

(>=) :: ArgFlag -> ArgFlag -> Bool

max :: ArgFlag -> ArgFlag -> ArgFlag

min :: ArgFlag -> ArgFlag -> ArgFlag

Outputable tv => Outputable (VarBndr tv ArgFlag)

Defined in GHC.Types.Var

Methods

ppr :: VarBndr tv ArgFlag -> SDoc

data AnonArgFlag

The non-dependent version of ArgFlag. See Note [AnonArgFlag] Appears here partly so that it's together with its friends ArgFlag and ForallVisFlag, but also because it is used in IfaceType, rather early in the compilation chain

Constructors

VisArg

Used for (->): an ordinary non-dependent arrow. The argument is visible in source code.

InvisArg

Used for (=>): a non-dependent predicate arrow. The argument is invisible in source code.

Instances

Data AnonArgFlag

Defined in GHC.Types.Var

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnonArgFlag -> c AnonArgFlag

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnonArgFlag

toConstr :: AnonArgFlag -> Constr

dataTypeOf :: AnonArgFlag -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnonArgFlag)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnonArgFlag)

gmapT :: (forall b. Data b => b -> b) -> AnonArgFlag -> AnonArgFlag

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnonArgFlag -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnonArgFlag -> r

gmapQ :: (forall d. Data d => d -> u) -> AnonArgFlag -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnonArgFlag -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnonArgFlag -> m AnonArgFlag

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnonArgFlag -> m AnonArgFlag

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnonArgFlag -> m AnonArgFlag

Binary AnonArgFlag

Defined in GHC.Types.Var

Methods

put_ :: BinHandle -> AnonArgFlag -> IO ()

put :: BinHandle -> AnonArgFlag -> IO (Bin AnonArgFlag)

get :: BinHandle -> IO AnonArgFlag

Outputable AnonArgFlag

Defined in GHC.Types.Var

Methods

ppr :: AnonArgFlag -> SDoc

Eq AnonArgFlag

Defined in GHC.Types.Var

Methods

(==) :: AnonArgFlag -> AnonArgFlag -> Bool

(/=) :: AnonArgFlag -> AnonArgFlag -> Bool

Ord AnonArgFlag

Defined in GHC.Types.Var

Methods

compare :: AnonArgFlag -> AnonArgFlag -> Ordering

(<) :: AnonArgFlag -> AnonArgFlag -> Bool

(<=) :: AnonArgFlag -> AnonArgFlag -> Bool

(>) :: AnonArgFlag -> AnonArgFlag -> Bool

(>=) :: AnonArgFlag -> AnonArgFlag -> Bool

max :: AnonArgFlag -> AnonArgFlag -> AnonArgFlag

min :: AnonArgFlag -> AnonArgFlag -> AnonArgFlag

stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering

Compares module names lexically, rather than by their Uniques

pprModuleName :: ModuleName -> SDoc

parseModuleName :: ReadP ModuleName

moduleNameString :: ModuleName -> String

moduleNameSlashes :: ModuleName -> String

Returns the string version of the module name, with dots replaced by slashes.

moduleNameFS :: ModuleName -> FastString

moduleNameColons :: ModuleName -> String

Returns the string version of the module name, with dots replaced by colons.

mkModuleNameFS :: FastString -> ModuleName

mkModuleName :: String -> ModuleName

class NamedThing a where

A class allowing convenient access to the Name of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName

getName :: a -> Name

Instances

NamedThing Class

Defined in GHC.Core.Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

NamedThing ConLike

Defined in GHC.Core.ConLike

Methods

getOccName :: ConLike -> OccName

getName :: ConLike -> Name

NamedThing DataCon

Defined in GHC.Core.DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

NamedThing FamInst

Defined in GHC.Core.FamInstEnv

Methods

getOccName :: FamInst -> OccName

getName :: FamInst -> Name

NamedThing ClsInst

Defined in GHC.Core.InstEnv

Methods

getOccName :: ClsInst -> OccName

getName :: ClsInst -> Name

NamedThing PatSyn

Defined in GHC.Core.PatSyn

Methods

getOccName :: PatSyn -> OccName

getName :: PatSyn -> Name

NamedThing TyCon

Defined in GHC.Core.TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

NamedThing IfaceClassOp

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceClassOp -> OccName

getName :: IfaceClassOp -> Name

NamedThing IfaceConDecl

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceConDecl -> OccName

getName :: IfaceConDecl -> Name

NamedThing IfaceDecl

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceDecl -> OccName

getName :: IfaceDecl -> Name

NamedThing HoleFitCandidate

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

getOccName :: HoleFitCandidate -> OccName

getName :: HoleFitCandidate -> Name

NamedThing Name

Defined in GHC.Types.Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

NamedThing TyThing

Defined in GHC.Types.TyThing

Methods

getOccName :: TyThing -> OccName

getName :: TyThing -> Name

NamedThing Var

Defined in GHC.Types.Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

NamedThing (CoAxiom br)

Defined in GHC.Core.Coercion.Axiom

Methods

getOccName :: CoAxiom br -> OccName

getName :: CoAxiom br -> Name

NamedThing e => NamedThing (Located e)

Defined in GHC.Types.Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

NamedThing (Located a) => NamedThing (LocatedAn an a)

Defined in GHC.Parser.Annotation

Methods

getOccName :: LocatedAn an a -> OccName

getName :: LocatedAn an a -> Name

NamedThing tv => NamedThing (VarBndr tv flag)

Defined in GHC.Types.Var

Methods

getOccName :: VarBndr tv flag -> OccName

getName :: VarBndr tv flag -> Name

data Name

A unique, unambiguous name for something, containing information about where that thing originated.

Instances

Data Name

Defined in GHC.Types.Name

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name

toConstr :: Name -> Constr

dataTypeOf :: Name -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)

gmapT :: (forall b. Data b => b -> b) -> Name -> Name

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name

NFData Name

Defined in GHC.Types.Name

Methods

rnf :: Name -> ()

NamedThing Name

Defined in GHC.Types.Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

HasOccName Name

Defined in GHC.Types.Name

Methods

occName :: Name -> OccName

Uniquable Name

Defined in GHC.Types.Name

Methods

getUnique :: Name -> Unique

Binary Name

Assumes that the Name is a non-binding one. See putIfaceTopBndr and getIfaceTopBndr for serializing binding Names. See UserData for the rationale for this distinction.

Defined in GHC.Types.Name

Methods

put_ :: BinHandle -> Name -> IO ()

put :: BinHandle -> Name -> IO (Bin Name)

get :: BinHandle -> IO Name

Outputable Name

Defined in GHC.Types.Name

Methods

ppr :: Name -> SDoc

OutputableBndr Name

Defined in GHC.Types.Name

Methods

pprBndr :: BindingSite -> Name -> SDoc

pprPrefixOcc :: Name -> SDoc

pprInfixOcc :: Name -> SDoc

bndrIsJoin_maybe :: Name -> Maybe Int

Eq Name

The same comments as for Name's Ord instance apply.

Defined in GHC.Types.Name

Methods

(==) :: Name -> Name -> Bool

(/=) :: Name -> Name -> Bool

Ord Name

Caution: This instance is implemented via nonDetCmpUnique, which means that the ordering is not stable across deserialization or rebuilds.

See nonDetCmpUnique for further information, and trac #15240 for a bug caused by improper use of this instance.

Defined in GHC.Types.Name

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

type Anno Name

Defined in GHC.Hs.Extension

type Anno Name = SrcSpanAnnN

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

tidyNameOcc :: Name -> OccName -> Name

setNameUnique :: Name -> Unique -> Name

nameUnique :: Name -> Unique

nameOccName :: Name -> OccName

data UnhelpfulSpanReason

Constructors

UnhelpfulNoLocationInfo

UnhelpfulWiredIn

UnhelpfulInteractive

UnhelpfulGenerated

UnhelpfulOther !FastString

Instances

Show UnhelpfulSpanReason

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> UnhelpfulSpanReason -> ShowS

show :: UnhelpfulSpanReason -> String

showList :: [UnhelpfulSpanReason] -> ShowS

Outputable UnhelpfulSpanReason

Defined in GHC.Types.SrcLoc

Methods

ppr :: UnhelpfulSpanReason -> SDoc

Eq UnhelpfulSpanReason

Defined in GHC.Types.SrcLoc

Methods

(==) :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool

(/=) :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool

data SrcSpan

Source Span

A SrcSpan identifies either a specific portion of a text file or a human-readable description of a location.

Constructors

RealSrcSpan !RealSrcSpan !(Maybe BufSpan)

UnhelpfulSpan !UnhelpfulSpanReason

Instances

Data SrcSpan

Defined in GHC.Types.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpan

toConstr :: SrcSpan -> Constr

dataTypeOf :: SrcSpan -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpan)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan)

gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r

gmapQ :: (forall d. Data d => d -> u) -> SrcSpan -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpan -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan

Show SrcSpan

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> SrcSpan -> ShowS

show :: SrcSpan -> String

showList :: [SrcSpan] -> ShowS

NFData SrcSpan

Defined in GHC.Types.SrcLoc

Methods

rnf :: SrcSpan -> ()

ToJson SrcSpan

Defined in GHC.Types.SrcLoc

Methods

json :: SrcSpan -> JsonDoc

Outputable SrcSpan

Defined in GHC.Types.SrcLoc

Methods

ppr :: SrcSpan -> SDoc

Eq SrcSpan

Defined in GHC.Types.SrcLoc

Methods

(==) :: SrcSpan -> SrcSpan -> Bool

(/=) :: SrcSpan -> SrcSpan -> Bool

NamedThing e => NamedThing (Located e)

Defined in GHC.Types.Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

Outputable e => Outputable (Located e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: Located e -> SDoc

OutputableBndr (GenLocated SrcSpan (FieldOcc pass))

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprPrefixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprInfixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

bndrIsJoin_maybe :: GenLocated SrcSpan (FieldOcc pass) -> Maybe Int

data SrcLoc

Source Location

Constructors

RealSrcLoc !RealSrcLoc !(Maybe BufPos)

UnhelpfulLoc FastString

Instances

Show SrcLoc

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> SrcLoc -> ShowS

show :: SrcLoc -> String

showList :: [SrcLoc] -> ShowS

Outputable SrcLoc

Defined in GHC.Types.SrcLoc

Methods

ppr :: SrcLoc -> SDoc

Eq SrcLoc

Defined in GHC.Types.SrcLoc

Methods

(==) :: SrcLoc -> SrcLoc -> Bool

(/=) :: SrcLoc -> SrcLoc -> Bool

data RealSrcSpan

A SrcSpan delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.

The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.

Real Source Span

Instances

Data RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RealSrcSpan -> c RealSrcSpan

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RealSrcSpan

toConstr :: RealSrcSpan -> Constr

dataTypeOf :: RealSrcSpan -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RealSrcSpan)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RealSrcSpan)

gmapT :: (forall b. Data b => b -> b) -> RealSrcSpan -> RealSrcSpan

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r

gmapQ :: (forall d. Data d => d -> u) -> RealSrcSpan -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RealSrcSpan -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan

Show RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> RealSrcSpan -> ShowS

show :: RealSrcSpan -> String

showList :: [RealSrcSpan] -> ShowS

ToJson RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

json :: RealSrcSpan -> JsonDoc

Outputable RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

ppr :: RealSrcSpan -> SDoc

Eq RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

(==) :: RealSrcSpan -> RealSrcSpan -> Bool

(/=) :: RealSrcSpan -> RealSrcSpan -> Bool

Ord RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

compare :: RealSrcSpan -> RealSrcSpan -> Ordering

(<) :: RealSrcSpan -> RealSrcSpan -> Bool

(<=) :: RealSrcSpan -> RealSrcSpan -> Bool

(>) :: RealSrcSpan -> RealSrcSpan -> Bool

(>=) :: RealSrcSpan -> RealSrcSpan -> Bool

max :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan

min :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan

Outputable e => Outputable (GenLocated RealSrcSpan e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: GenLocated RealSrcSpan e -> SDoc

data RealSrcLoc

Real Source Location

Represents a single point within a file

Instances

Show RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> RealSrcLoc -> ShowS

show :: RealSrcLoc -> String

showList :: [RealSrcLoc] -> ShowS

Outputable RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

ppr :: RealSrcLoc -> SDoc

Eq RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

(==) :: RealSrcLoc -> RealSrcLoc -> Bool

(/=) :: RealSrcLoc -> RealSrcLoc -> Bool

Ord RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

compare :: RealSrcLoc -> RealSrcLoc -> Ordering

(<) :: RealSrcLoc -> RealSrcLoc -> Bool

(<=) :: RealSrcLoc -> RealSrcLoc -> Bool

(>) :: RealSrcLoc -> RealSrcLoc -> Bool

(>=) :: RealSrcLoc -> RealSrcLoc -> Bool

max :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc

min :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc

type RealLocated = GenLocated RealSrcSpan

data PsSpan

Constructors

PsSpan

Fields

• psRealSpan :: !RealSrcSpan
• psBufSpan :: !BufSpan

Instances

Show PsSpan

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> PsSpan -> ShowS

show :: PsSpan -> String

showList :: [PsSpan] -> ShowS

Eq PsSpan

Defined in GHC.Types.SrcLoc

Methods

(==) :: PsSpan -> PsSpan -> Bool

(/=) :: PsSpan -> PsSpan -> Bool

Ord PsSpan

Defined in GHC.Types.SrcLoc

Methods

compare :: PsSpan -> PsSpan -> Ordering

(<) :: PsSpan -> PsSpan -> Bool

(<=) :: PsSpan -> PsSpan -> Bool

(>) :: PsSpan -> PsSpan -> Bool

(>=) :: PsSpan -> PsSpan -> Bool

max :: PsSpan -> PsSpan -> PsSpan

min :: PsSpan -> PsSpan -> PsSpan

type PsLocated = GenLocated PsSpan

data PsLoc

A location as produced by the parser. Consists of two components:

• The location in the file, adjusted for #line and {-# LINE ... #-} pragmas (RealSrcLoc)
• The location in the string buffer (BufPos) with monotonicity guarantees (see #17632)

Constructors

PsLoc

Fields

• psRealLoc :: !RealSrcLoc
• psBufPos :: !BufPos

Instances

Show PsLoc

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> PsLoc -> ShowS

show :: PsLoc -> String

showList :: [PsLoc] -> ShowS

Eq PsLoc

Defined in GHC.Types.SrcLoc

Methods

(==) :: PsLoc -> PsLoc -> Bool

(/=) :: PsLoc -> PsLoc -> Bool

Ord PsLoc

Defined in GHC.Types.SrcLoc

Methods

compare :: PsLoc -> PsLoc -> Ordering

(<) :: PsLoc -> PsLoc -> Bool

(<=) :: PsLoc -> PsLoc -> Bool

(>) :: PsLoc -> PsLoc -> Bool

(>=) :: PsLoc -> PsLoc -> Bool

max :: PsLoc -> PsLoc -> PsLoc

min :: PsLoc -> PsLoc -> PsLoc

type Located = GenLocated SrcSpan

data LayoutInfo

Layout information for declarations.

Constructors

ExplicitBraces

Explicit braces written by the user.

class C a where { foo :: a; bar :: a }

VirtualBraces

Virtual braces inserted by the layout algorithm.

class C a where
  foo :: a
  bar :: a

Fields

• !Int

  Layout column (indentation level, begins at 1)

NoLayoutInfo

Empty or compiler-generated blocks do not have layout information associated with them.

Instances

Data LayoutInfo

Defined in GHC.Types.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LayoutInfo -> c LayoutInfo

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LayoutInfo

toConstr :: LayoutInfo -> Constr

dataTypeOf :: LayoutInfo -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LayoutInfo)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LayoutInfo)

gmapT :: (forall b. Data b => b -> b) -> LayoutInfo -> LayoutInfo

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LayoutInfo -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LayoutInfo -> r

gmapQ :: (forall d. Data d => d -> u) -> LayoutInfo -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LayoutInfo -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LayoutInfo -> m LayoutInfo

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LayoutInfo -> m LayoutInfo

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LayoutInfo -> m LayoutInfo

Show LayoutInfo

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> LayoutInfo -> ShowS

show :: LayoutInfo -> String

showList :: [LayoutInfo] -> ShowS

Eq LayoutInfo

Defined in GHC.Types.SrcLoc

Methods

(==) :: LayoutInfo -> LayoutInfo -> Bool

(/=) :: LayoutInfo -> LayoutInfo -> Bool

Ord LayoutInfo

Defined in GHC.Types.SrcLoc

Methods

compare :: LayoutInfo -> LayoutInfo -> Ordering

(<) :: LayoutInfo -> LayoutInfo -> Bool

(<=) :: LayoutInfo -> LayoutInfo -> Bool

(>) :: LayoutInfo -> LayoutInfo -> Bool

(>=) :: LayoutInfo -> LayoutInfo -> Bool

max :: LayoutInfo -> LayoutInfo -> LayoutInfo

min :: LayoutInfo -> LayoutInfo -> LayoutInfo

data GenLocated l e

We attach SrcSpans to lots of things, so let's have a datatype for it.

Constructors

L l e

Instances

Foldable (GenLocated l)

Defined in GHC.Types.SrcLoc

Methods

fold :: Monoid m => GenLocated l m -> m

foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m

foldMap' :: Monoid m => (a -> m) -> GenLocated l a -> m

foldr :: (a -> b -> b) -> b -> GenLocated l a -> b

foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b

foldl :: (b -> a -> b) -> b -> GenLocated l a -> b

foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b

foldr1 :: (a -> a -> a) -> GenLocated l a -> a

foldl1 :: (a -> a -> a) -> GenLocated l a -> a

toList :: GenLocated l a -> [a]

null :: GenLocated l a -> Bool

length :: GenLocated l a -> Int

elem :: Eq a => a -> GenLocated l a -> Bool

maximum :: Ord a => GenLocated l a -> a

minimum :: Ord a => GenLocated l a -> a

sum :: Num a => GenLocated l a -> a

product :: Num a => GenLocated l a -> a

Traversable (GenLocated l)

Defined in GHC.Types.SrcLoc

Methods

traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b)

sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a)

mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b)

sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a)

Functor (GenLocated l)

Defined in GHC.Types.SrcLoc

Methods

fmap :: (a -> b) -> GenLocated l a -> GenLocated l b

(<$) :: a -> GenLocated l b -> GenLocated l a

NamedThing e => NamedThing (Located e)

Defined in GHC.Types.Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

Binary a => Binary (LocatedL a)

Defined in GHC.Parser.Annotation

Methods

put_ :: BinHandle -> LocatedL a -> IO ()

put :: BinHandle -> LocatedL a -> IO (Bin (LocatedL a))

get :: BinHandle -> IO (LocatedL a)

Outputable e => Outputable (Located e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: Located e -> SDoc

(Data l, Data e) => Data (GenLocated l e)

Defined in GHC.Types.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e)

toConstr :: GenLocated l e -> Constr

dataTypeOf :: GenLocated l e -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e))

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (GenLocated l e))

gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r

gmapQ :: (forall d. Data d => d -> u) -> GenLocated l e -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e)

NamedThing (Located a) => NamedThing (LocatedAn an a)

Defined in GHC.Parser.Annotation

Methods

getOccName :: LocatedAn an a -> OccName

getName :: LocatedAn an a -> Name

Outputable (GenLocated Anchor EpaComment)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated Anchor EpaComment -> SDoc

(Outputable a, Outputable e) => Outputable (GenLocated (SrcSpanAnn' a) e)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated (SrcSpanAnn' a) e -> SDoc

Outputable e => Outputable (GenLocated RealSrcSpan e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: GenLocated RealSrcSpan e -> SDoc

OutputableBndr (GenLocated SrcSpan (FieldOcc pass))

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprPrefixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprInfixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

bndrIsJoin_maybe :: GenLocated SrcSpan (FieldOcc pass) -> Maybe Int

(Eq l, Eq e) => Eq (GenLocated l e)

Defined in GHC.Types.SrcLoc

Methods

(==) :: GenLocated l e -> GenLocated l e -> Bool

(/=) :: GenLocated l e -> GenLocated l e -> Bool

(Ord l, Ord e) => Ord (GenLocated l e)

Defined in GHC.Types.SrcLoc

Methods

compare :: GenLocated l e -> GenLocated l e -> Ordering

(<) :: GenLocated l e -> GenLocated l e -> Bool

(<=) :: GenLocated l e -> GenLocated l e -> Bool

(>) :: GenLocated l e -> GenLocated l e -> Bool

(>=) :: GenLocated l e -> GenLocated l e -> Bool

max :: GenLocated l e -> GenLocated l e -> GenLocated l e

min :: GenLocated l e -> GenLocated l e -> GenLocated l e

type Anno (LocatedA (IE (GhcPass p)))

Defined in GHC.Hs.ImpExp

type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno (LocatedN RdrName)

Defined in GHC.Hs.Binds

type Anno (LocatedN RdrName) = SrcSpan

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedA (IE (GhcPass p))]

Defined in GHC.Hs.ImpExp

type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.PostProcess

type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]

Defined in GHC.Hs.Expr

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]

Defined in GHC.Parser.Types

type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL

type Anno [LocatedA (ConDeclField (GhcPass _1))]

Defined in GHC.Hs.Decls

type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type Anno [LocatedA (HsType (GhcPass p))]

Defined in GHC.Hs.Type

type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

type Anno [LocatedN RdrName]

Defined in GHC.Hs.Binds

type Anno [LocatedN RdrName] = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type Anno (FamEqn p (LocatedA (HsType p)))

Defined in GHC.Hs.Decls

type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpan

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpan

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpan

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Expr

type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p))))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p)))

Defined in GHC.Hs.Pat

type Anno (HsRecField' (AmbiguousFieldOcc p) (LocatedA (HsExpr p))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))

Defined in GHC.Hs.Expr

type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr)))) = SrcSpanAnnA

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))

Defined in GHC.Parser.PostProcess

type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))

Defined in GHC.Hs.Expr

type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

data BufSpan

StringBuffer Source Span

Constructors

BufSpan

Fields

• bufSpanStart :: !BufPos
• bufSpanEnd :: !BufPos

Instances

Semigroup BufSpan

Defined in GHC.Types.SrcLoc

Methods

(<>) :: BufSpan -> BufSpan -> BufSpan

sconcat :: NonEmpty BufSpan -> BufSpan

stimes :: Integral b => b -> BufSpan -> BufSpan

Show BufSpan

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> BufSpan -> ShowS

show :: BufSpan -> String

showList :: [BufSpan] -> ShowS

Eq BufSpan

Defined in GHC.Types.SrcLoc

Methods

(==) :: BufSpan -> BufSpan -> Bool

(/=) :: BufSpan -> BufSpan -> Bool

Ord BufSpan

Defined in GHC.Types.SrcLoc

Methods

compare :: BufSpan -> BufSpan -> Ordering

(<) :: BufSpan -> BufSpan -> Bool

(<=) :: BufSpan -> BufSpan -> Bool

(>) :: BufSpan -> BufSpan -> Bool

(>=) :: BufSpan -> BufSpan -> Bool

max :: BufSpan -> BufSpan -> BufSpan

min :: BufSpan -> BufSpan -> BufSpan

newtype BufPos

0-based offset identifying the raw location in the StringBuffer.

The lexer increments the BufPos every time a character (UTF-8 code point) is read from the input buffer. As UTF-8 is a variable-length encoding and StringBuffer needs a byte offset for indexing, a BufPos cannot be used for indexing.

The parser guarantees that BufPos are monotonic. See #17632. This means that syntactic constructs that appear later in the StringBuffer are guaranteed to have a higher BufPos. Constrast that with SrcLoc, which does *not* make the analogous guarantee about higher line/column numbers.

This is due to #line and {-# LINE ... #-} pragmas that can arbitrarily modify SrcLoc. Notice how setSrcLoc and resetAlrLastLoc in GHC.Parser.Lexer update PsLoc, modifying SrcLoc but preserving BufPos.

Monotonicity makes BufPos useful to determine the order in which syntactic elements appear in the source. Consider this example (haddockA041 in the test suite):

haddockA041.hs {-# LANGUAGE CPP #-} -- | Module header documentation module Comments_and_CPP_include where #include "IncludeMe.hs"

IncludeMe.hs: -- | Comment on T data T = MkT -- ^ Comment on MkT

After the C preprocessor runs, the StringBuffer will contain a program that looks like this (unimportant lines at the beginning removed):

# 1 "haddockA041.hs" {-# LANGUAGE CPP #-} -- | Module header documentation module Comments_and_CPP_include where # 1 "IncludeMe.hs" 1 -- | Comment on T data T = MkT -- ^ Comment on MkT # 7 "haddockA041.hs" 2

The line pragmas inserted by CPP make the error messages more informative. The downside is that we can't use RealSrcLoc to determine the ordering of syntactic elements.

With RealSrcLoc, we have the following location information recorded in the AST: * The module name is located at haddockA041.hs:3:8-31 * The Haddock comment "Comment on T" is located at IncludeMe:1:1-17 * The data declaration is located at IncludeMe.hs:2:1-32

Is the Haddock comment located between the module name and the data declaration? This is impossible to tell because the locations are not comparable; they even refer to different files.

On the other hand, with BufPos, we have the following location information: * The module name is located at 846-870 * The Haddock comment "Comment on T" is located at 898-915 * The data declaration is located at 916-928

Aside: if you're wondering why the numbers are so high, try running ghc -E haddockA041.hs and see the extra fluff that CPP inserts at the start of the file.

For error messages, BufPos is not useful at all. On the other hand, this is exactly what we need to determine the order of syntactic elements: 870 < 898, therefore the Haddock comment appears *after* the module name. 915 < 916, therefore the Haddock comment appears *before* the data declaration.

We use BufPos in in GHC.Parser.PostProcess.Haddock to associate Haddock comments with parts of the AST using location information (#17544).

Constructors

BufPos

Fields

• bufPos :: Int

Instances

Show BufPos

Defined in GHC.Types.SrcLoc

Methods

showsPrec :: Int -> BufPos -> ShowS

show :: BufPos -> String

showList :: [BufPos] -> ShowS

Eq BufPos

Defined in GHC.Types.SrcLoc

Methods

(==) :: BufPos -> BufPos -> Bool

(/=) :: BufPos -> BufPos -> Bool

Ord BufPos

Defined in GHC.Types.SrcLoc

Methods

compare :: BufPos -> BufPos -> Ordering

(<) :: BufPos -> BufPos -> Bool

(<=) :: BufPos -> BufPos -> Bool

(>) :: BufPos -> BufPos -> Bool

(>=) :: BufPos -> BufPos -> Bool

max :: BufPos -> BufPos -> BufPos

min :: BufPos -> BufPos -> BufPos

wiredInSrcSpan :: SrcSpan

Built-in "bad" SrcSpans for common sources of location uncertainty

unhelpfulSpanFS :: UnhelpfulSpanReason -> FastString

unRealSrcSpan :: RealLocated a -> a

unLoc :: GenLocated l e -> e

srcSpanToRealSrcSpan :: SrcSpan -> Maybe RealSrcSpan

srcSpanStartLine :: RealSrcSpan -> Int

srcSpanStartCol :: RealSrcSpan -> Int

srcSpanStart :: SrcSpan -> SrcLoc

Returns the location at the start of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanFirstCharacter :: SrcSpan -> SrcSpan

Convert a SrcSpan into one that represents only its first character

srcSpanFileName_maybe :: SrcSpan -> Maybe FastString

Obtains the filename for a SrcSpan if it is "good"

srcSpanEndLine :: RealSrcSpan -> Int

srcSpanEndCol :: RealSrcSpan -> Int

srcSpanEnd :: SrcSpan -> SrcLoc

Returns the location at the end of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcLocSpan :: SrcLoc -> SrcSpan

Create a SrcSpan corresponding to a single point

srcLocLine :: RealSrcLoc -> Int

Raises an error when used on a "bad" SrcLoc

srcLocFile :: RealSrcLoc -> FastString

Gives the filename of the SrcLoc

srcLocCol :: RealSrcLoc -> Int

Raises an error when used on a "bad" SrcLoc

spans :: SrcSpan -> (Int, Int) -> Bool

Determines whether a span encloses a given line and column index

sortRealLocated :: [RealLocated a] -> [RealLocated a]

sortLocated :: [Located a] -> [Located a]

rightmost_smallest :: SrcSpan -> SrcSpan -> Ordering

Strategies for ordering SrcSpans

realSrcSpanStart :: RealSrcSpan -> RealSrcLoc

realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc

realSrcLocSpan :: RealSrcLoc -> RealSrcSpan

psSpanStart :: PsSpan -> PsLoc

psSpanEnd :: PsSpan -> PsLoc

pprUserSpan :: Bool -> SrcSpan -> SDoc

pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc

pprUnhelpfulSpanReason :: UnhelpfulSpanReason -> SDoc

pprLocated :: (Outputable l, Outputable e) => GenLocated l e -> SDoc

noSrcSpan :: SrcSpan

Built-in "bad" SrcSpans for common sources of location uncertainty

noSrcLoc :: SrcLoc

Built-in "bad" SrcLoc values for particular locations

noLoc :: e -> Located e

mkSrcSpanPs :: PsSpan -> SrcSpan

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan

Create a SrcSpan between two points in a file

mkSrcLoc :: FastString -> Int -> Int -> SrcLoc

mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan

Create a SrcSpan between two points in a file

mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc

mkPsSpan :: PsLoc -> PsLoc -> PsSpan

mkGeneralSrcSpan :: FastString -> SrcSpan

Create a "bad" SrcSpan that has not location information

mkGeneralSrcLoc :: FastString -> SrcLoc

Creates a "bad" SrcLoc that has no detailed information about its location

mkGeneralLocated :: String -> e -> Located e

mapLoc :: (a -> b) -> GenLocated l a -> GenLocated l b

lookupSrcSpan :: SrcSpan -> Map RealSrcSpan a -> Maybe a

lookupSrcLoc :: SrcLoc -> Map RealSrcLoc a -> Maybe a

liftL :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b)

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering

Strategies for ordering SrcSpans

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering

Strategies for ordering SrcSpans

leftmostColumn :: Int

Indentation level is 1-indexed, so the leftmost column is 1.

isZeroWidthSpan :: SrcSpan -> Bool

True if the span has a width of zero, as returned for "virtual" semicolons in the lexer. For "bad" SrcSpan, it returns False

isSubspanOf

Arguments

:: SrcSpan

The span that may be enclosed by the other

-> SrcSpan

The span it may be enclosed by

-> Bool

Determines whether a span is enclosed by another one

isRealSubspanOf

Arguments

:: RealSrcSpan

The span that may be enclosed by the other

-> RealSrcSpan

The span it may be enclosed by

-> Bool

Determines whether a span is enclosed by another one

isOneLineSpan :: SrcSpan -> Bool

True if the span is known to straddle only one line. For "bad" SrcSpan, it returns False

isGoodSrcSpan :: SrcSpan -> Bool

Test if a SrcSpan is "good", i.e. has precise location information

isGeneratedSrcSpan :: SrcSpan -> Bool

interactiveSrcSpan :: SrcSpan

Built-in "bad" SrcSpans for common sources of location uncertainty

interactiveSrcLoc :: SrcLoc

Built-in "bad" SrcLoc values for particular locations

getRealSrcSpan :: RealLocated a -> RealSrcSpan

getLoc :: GenLocated l e -> l

getBufSpan :: SrcSpan -> Maybe BufSpan

getBufPos :: SrcLoc -> Maybe BufPos

generatedSrcSpan :: SrcSpan

Built-in "bad" SrcSpans for common sources of location uncertainty

generatedSrcLoc :: SrcLoc

Built-in "bad" SrcLoc values for particular locations

eqLocated :: Eq a => GenLocated l a -> GenLocated l a -> Bool

Tests whether the two located things are equal

containsSpan :: RealSrcSpan -> RealSrcSpan -> Bool

Tests whether the first span "contains" the other span, meaning that it covers at least as much source code. True where spans are equal.

combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan

Combines two SrcSpan into one that spans at least all the characters within both spans. Returns UnhelpfulSpan if the files differ.

combineRealSrcSpans :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan

Combines two SrcSpan into one that spans at least all the characters within both spans. Assumes the "file" part is the same in both inputs

combineLocs :: Located a -> Located b -> SrcSpan

cmpLocated :: Ord a => GenLocated l a -> GenLocated l a -> Ordering

Tests the ordering of the two located things

cmpBufSpan :: HasDebugCallStack => Located a -> Located a -> Ordering

Compare the BufSpan of two located things.

Precondition: both operands have an associated BufSpan.

advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc

Move the SrcLoc down by one line if the character is a newline, to the next 8-char tabstop if it is a tab, and across by one character in any other case

advancePsLoc :: PsLoc -> Char -> PsLoc

advanceBufPos :: BufPos -> BufPos

addCLoc :: Located a -> Located b -> c -> Located c

Combine locations from two Located things and add them to a third thing

type FastStringEnv a = UniqFM FastString a

A non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DFastStringEnv if the set eventually gets converted into a list or folded over in a way where the order changes the generated code.

mkFsEnv :: [(FastString, a)] -> FastStringEnv a

lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a

extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a

emptyFsEnv :: FastStringEnv a

data UniqSet a

Instances

Data a => Data (UniqSet a)

Defined in GHC.Types.Unique.Set

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UniqSet a -> c (UniqSet a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UniqSet a)

toConstr :: UniqSet a -> Constr

dataTypeOf :: UniqSet a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UniqSet a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UniqSet a))

gmapT :: (forall b. Data b => b -> b) -> UniqSet a -> UniqSet a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UniqSet a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UniqSet a -> r

gmapQ :: (forall d. Data d => d -> u) -> UniqSet a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> UniqSet a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UniqSet a -> m (UniqSet a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqSet a -> m (UniqSet a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqSet a -> m (UniqSet a)

Monoid (UniqSet a)

Defined in GHC.Types.Unique.Set

Methods

mempty :: UniqSet a

mappend :: UniqSet a -> UniqSet a -> UniqSet a

mconcat :: [UniqSet a] -> UniqSet a

Semigroup (UniqSet a)

Defined in GHC.Types.Unique.Set

Methods

(<>) :: UniqSet a -> UniqSet a -> UniqSet a

sconcat :: NonEmpty (UniqSet a) -> UniqSet a

stimes :: Integral b => b -> UniqSet a -> UniqSet a

Outputable a => Outputable (UniqSet a)

Defined in GHC.Types.Unique.Set

Methods

ppr :: UniqSet a -> SDoc

Eq (UniqSet a)

Defined in GHC.Types.Unique.Set

Methods

(==) :: UniqSet a -> UniqSet a -> Bool

(/=) :: UniqSet a -> UniqSet a -> Bool

unsafeUFMToUniqSet :: UniqFM a a -> UniqSet a

unsafeUFMToUniqSet converts a UniqFM a into a UniqSet a assuming, without checking, that it maps each Unique to a value that has that Unique. See Note [UniqSet invariant].

unitUniqSet :: Uniquable a => a -> UniqSet a

uniqSetMinusUFM :: UniqSet key -> UniqFM key b -> UniqSet key

uniqSetMinusUDFM :: UniqSet key -> UniqDFM key b -> UniqSet key

uniqSetAny :: (a -> Bool) -> UniqSet a -> Bool

uniqSetAll :: (a -> Bool) -> UniqSet a -> Bool

unionUniqSets :: UniqSet a -> UniqSet a -> UniqSet a

unionManyUniqSets :: [UniqSet a] -> UniqSet a

sizeUniqSet :: UniqSet a -> Int

restrictUniqSetToUFM :: UniqSet key -> UniqFM key b -> UniqSet key

pprUniqSet :: (a -> SDoc) -> UniqSet a -> SDoc

partitionUniqSet :: (a -> Bool) -> UniqSet a -> (UniqSet a, UniqSet a)

nonDetStrictFoldUniqSet :: (elt -> a -> a) -> a -> UniqSet elt -> a

nonDetKeysUniqSet :: UniqSet elt -> [Unique]

nonDetEltsUniqSet :: UniqSet elt -> [elt]

mkUniqSet :: Uniquable a => [a] -> UniqSet a

minusUniqSet :: UniqSet a -> UniqSet a -> UniqSet a

mapUniqSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b

lookupUniqSet_Directly :: UniqSet a -> Unique -> Maybe a

lookupUniqSet :: Uniquable key => UniqSet key -> key -> Maybe key

What's the point you might ask? We might have changed an object without it's key changing. In which case this lookup makes sense.

isEmptyUniqSet :: UniqSet a -> Bool

intersectUniqSets :: UniqSet a -> UniqSet a -> UniqSet a

getUniqSet :: UniqSet a -> UniqFM a a

filterUniqSet_Directly :: (Unique -> elt -> Bool) -> UniqSet elt -> UniqSet elt

filterUniqSet :: (a -> Bool) -> UniqSet a -> UniqSet a

emptyUniqSet :: UniqSet a

elementOfUniqSet :: Uniquable a => a -> UniqSet a -> Bool

elemUniqSet_Directly :: Unique -> UniqSet a -> Bool

disjointUniqSets :: UniqSet a -> UniqSet a -> Bool

delOneFromUniqSet_Directly :: UniqSet a -> Unique -> UniqSet a

delOneFromUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a

delListFromUniqSet_Directly :: UniqSet a -> [Unique] -> UniqSet a

delListFromUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a

addOneToUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a

addListToUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a

type QueryQualifyPackage = Unit -> Bool

For a given package, we need to know whether to print it with the component id to disambiguate it.

type QueryQualifyName = Module -> OccName -> QualifyName

Given a Name's Module and OccName, decide whether and how to qualify it.

type QueryQualifyModule = Module -> Bool

For a given module, we need to know whether to print it with a package name to disambiguate it.

data QualifyName

Constructors

NameUnqual

NameQual ModuleName

NameNotInScope1

NameNotInScope2

Instances

Outputable QualifyName

Defined in GHC.Utils.Outputable

Methods

ppr :: QualifyName -> SDoc

data PrintUnqualified

When printing code that contains original names, we need to map the original names back to something the user understands. This is the purpose of the triple of functions that gets passed around when rendering SDoc.

Constructors

QueryQualify

Fields

• queryQualifyName :: QueryQualifyName
• queryQualifyModule :: QueryQualifyModule
• queryQualifyPackage :: QueryQualifyPackage

newtype PDoc a

Wrapper for types having a Outputable instance when an OutputableP instance is required.

Constructors

PDoc a

Instances

Outputable a => OutputableP env (PDoc a)

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> PDoc a -> SDoc

class OutputableP env a where

Outputable class with an additional environment value

See Note [The OutputableP class]

Methods

pdoc :: env -> a -> SDoc

Instances

OutputableP env Label

Defined in GHC.Cmm.Dataflow.Label

Methods

pdoc :: env -> Label -> SDoc

OutputableP env Alignment

Defined in GHC.Types.Basic

Methods

pdoc :: env -> Alignment -> SDoc

OutputableP env SDoc

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> SDoc -> SDoc

OutputableP env a => OutputableP env (SCC a)

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> SCC a -> SDoc

OutputableP env a => OutputableP env (Set a)

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> Set a -> SDoc

OutputableP env a => OutputableP env (LabelMap a)

Defined in GHC.Cmm.Dataflow.Label

Methods

pdoc :: env -> LabelMap a -> SDoc

Outputable a => OutputableP env (PDoc a)

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> PDoc a -> SDoc

OutputableP env a => OutputableP env (Maybe a)

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> Maybe a -> SDoc

OutputableP env a => OutputableP env [a]

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> [a] -> SDoc

(OutputableP env key, OutputableP env elt) => OutputableP env (Map key elt)

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> Map key elt -> SDoc

(OutputableP env a, OutputableP env b) => OutputableP env (a, b)

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> (a, b) -> SDoc

(OutputableP env a, OutputableP env b, OutputableP env c) => OutputableP env (a, b, c)

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> (a, b, c) -> SDoc

class Outputable a => OutputableBndr a where

When we print a binder, we often want to print its type too. The OutputableBndr class encapsulates this idea.

Minimal complete definition

pprPrefixOcc, pprInfixOcc

Methods

pprBndr :: BindingSite -> a -> SDoc

pprPrefixOcc :: a -> SDoc

pprInfixOcc :: a -> SDoc

bndrIsJoin_maybe :: a -> Maybe Int

Instances

OutputableBndr ConLike

Defined in GHC.Core.ConLike

Methods

pprBndr :: BindingSite -> ConLike -> SDoc

pprPrefixOcc :: ConLike -> SDoc

pprInfixOcc :: ConLike -> SDoc

bndrIsJoin_maybe :: ConLike -> Maybe Int

OutputableBndr DataCon

Defined in GHC.Core.DataCon

Methods

pprBndr :: BindingSite -> DataCon -> SDoc

pprPrefixOcc :: DataCon -> SDoc

pprInfixOcc :: DataCon -> SDoc

bndrIsJoin_maybe :: DataCon -> Maybe Int

OutputableBndr PatSyn

Defined in GHC.Core.PatSyn

Methods

pprBndr :: BindingSite -> PatSyn -> SDoc

pprPrefixOcc :: PatSyn -> SDoc

pprInfixOcc :: PatSyn -> SDoc

bndrIsJoin_maybe :: PatSyn -> Maybe Int

OutputableBndr Name

Defined in GHC.Types.Name

Methods

pprBndr :: BindingSite -> Name -> SDoc

pprPrefixOcc :: Name -> SDoc

pprInfixOcc :: Name -> SDoc

bndrIsJoin_maybe :: Name -> Maybe Int

OutputableBndr OccName

Defined in GHC.Types.Name.Occurrence

Methods

pprBndr :: BindingSite -> OccName -> SDoc

pprPrefixOcc :: OccName -> SDoc

pprInfixOcc :: OccName -> SDoc

bndrIsJoin_maybe :: OccName -> Maybe Int

OutputableBndr RdrName

Defined in GHC.Types.Name.Reader

Methods

pprBndr :: BindingSite -> RdrName -> SDoc

pprPrefixOcc :: RdrName -> SDoc

pprInfixOcc :: RdrName -> SDoc

bndrIsJoin_maybe :: RdrName -> Maybe Int

OutputableBndr HsIPName

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> HsIPName -> SDoc

pprPrefixOcc :: HsIPName -> SDoc

pprInfixOcc :: HsIPName -> SDoc

bndrIsJoin_maybe :: HsIPName -> Maybe Int

OutputableBndr name => OutputableBndr (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

pprBndr :: BindingSite -> IEWrappedName name -> SDoc

pprPrefixOcc :: IEWrappedName name -> SDoc

pprInfixOcc :: IEWrappedName name -> SDoc

bndrIsJoin_maybe :: IEWrappedName name -> Maybe Int

OutputableBndr (FieldLabelStrings p)

Defined in Language.Haskell.Syntax.Expr

Methods

pprBndr :: BindingSite -> FieldLabelStrings p -> SDoc

pprPrefixOcc :: FieldLabelStrings p -> SDoc

pprInfixOcc :: FieldLabelStrings p -> SDoc

bndrIsJoin_maybe :: FieldLabelStrings p -> Maybe Int

OutputableBndr (FieldOcc pass)

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> FieldOcc pass -> SDoc

pprPrefixOcc :: FieldOcc pass -> SDoc

pprInfixOcc :: FieldOcc pass -> SDoc

bndrIsJoin_maybe :: FieldOcc pass -> Maybe Int

OutputableBndr (GenLocated SrcSpan (FieldOcc pass))

Defined in Language.Haskell.Syntax.Type

Methods

pprBndr :: BindingSite -> GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprPrefixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

pprInfixOcc :: GenLocated SrcSpan (FieldOcc pass) -> SDoc

bndrIsJoin_maybe :: GenLocated SrcSpan (FieldOcc pass) -> Maybe Int

class Outputable a where

Class designating that some type has an SDoc representation

Methods

ppr :: a -> SDoc

Instances

Outputable Fingerprint

Defined in GHC.Utils.Outputable

Methods

ppr :: Fingerprint -> SDoc

Outputable Int32

Defined in GHC.Utils.Outputable

Methods

ppr :: Int32 -> SDoc

Outputable Int64

Defined in GHC.Utils.Outputable

Methods

ppr :: Int64 -> SDoc

Outputable Word16

Defined in GHC.Utils.Outputable

Methods

ppr :: Word16 -> SDoc

Outputable Word32

Defined in GHC.Utils.Outputable

Methods

ppr :: Word32 -> SDoc

Outputable Word64

Defined in GHC.Utils.Outputable

Methods

ppr :: Word64 -> SDoc

Outputable IntSet

Defined in GHC.Utils.Outputable

Methods

ppr :: IntSet -> SDoc

Outputable PrimCall

Defined in GHC.Builtin.PrimOps

Methods

ppr :: PrimCall -> SDoc

Outputable PrimOp

Defined in GHC.Builtin.PrimOps

Methods

ppr :: PrimOp -> SDoc

Outputable Label

Defined in GHC.Cmm.Dataflow.Label

Methods

ppr :: Label -> SDoc

Outputable LabelSet

Defined in GHC.Cmm.Dataflow.Label

Methods

ppr :: LabelSet -> SDoc

Outputable AltCon

Defined in GHC.Core

Methods

ppr :: AltCon -> SDoc

Outputable Class

Defined in GHC.Core.Class

Methods

ppr :: Class -> SDoc

Outputable LiftingContext

Defined in GHC.Core.Coercion

Methods

ppr :: LiftingContext -> SDoc

Outputable CoAxBranch

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: CoAxBranch -> SDoc

Outputable CoAxiomRule

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: CoAxiomRule -> SDoc

Outputable Role

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: Role -> SDoc

Outputable ConLike

Defined in GHC.Core.ConLike

Methods

ppr :: ConLike -> SDoc

Outputable DataCon

Defined in GHC.Core.DataCon

Methods

ppr :: DataCon -> SDoc

Outputable EqSpec

Defined in GHC.Core.DataCon

Methods

ppr :: EqSpec -> SDoc

Outputable HsImplBang

Defined in GHC.Core.DataCon

Methods

ppr :: HsImplBang -> SDoc

Outputable HsSrcBang

Defined in GHC.Core.DataCon

Methods

ppr :: HsSrcBang -> SDoc

Outputable SrcStrictness

Defined in GHC.Core.DataCon

Methods

ppr :: SrcStrictness -> SDoc

Outputable SrcUnpackedness

Defined in GHC.Core.DataCon

Methods

ppr :: SrcUnpackedness -> SDoc

Outputable StrictnessMark

Defined in GHC.Core.DataCon

Methods

ppr :: StrictnessMark -> SDoc

Outputable FamInst

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamInst -> SDoc

Outputable FamInstMatch

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamInstMatch -> SDoc

Outputable FamilyInstEnv

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamilyInstEnv -> SDoc

Outputable ClsInst

Defined in GHC.Core.InstEnv

Methods

ppr :: ClsInst -> SDoc

Outputable ClsInstEnv

Defined in GHC.Core.InstEnv

Methods

ppr :: ClsInstEnv -> SDoc

Outputable FloatBind

Defined in GHC.Core.Make

Methods

ppr :: FloatBind -> SDoc

Outputable PatSyn

Defined in GHC.Core.PatSyn

Methods

ppr :: PatSyn -> SDoc

Outputable EqRel

Defined in GHC.Core.Predicate

Methods

ppr :: EqRel -> SDoc

Outputable Coercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Coercion -> SDoc

Outputable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: CoercionHole -> SDoc

Outputable MCoercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: MCoercion -> SDoc

Outputable TyCoBinder

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: TyCoBinder -> SDoc

Outputable TyLit

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: TyLit -> SDoc

Outputable Type

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Type -> SDoc

Outputable UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: UnivCoProvenance -> SDoc

Outputable TCvSubst

Defined in GHC.Core.TyCo.Subst

Methods

ppr :: TCvSubst -> SDoc

Outputable AlgTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: AlgTyConFlav -> SDoc

Outputable FamTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: FamTyConFlav -> SDoc

Outputable PrimElemRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimElemRep -> SDoc

Outputable PrimRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimRep -> SDoc

Outputable TyCon

Defined in GHC.Core.TyCon

Methods

ppr :: TyCon -> SDoc

Outputable TyConBndrVis

Defined in GHC.Core.TyCon

Methods

ppr :: TyConBndrVis -> SDoc

Outputable TyConFlavour

Defined in GHC.Core.TyCon

Methods

ppr :: TyConFlavour -> SDoc

Outputable MaybeApartReason

Defined in GHC.Core.Unify

Methods

ppr :: MaybeApartReason -> SDoc

Outputable Usage

Defined in GHC.Core.UsageEnv

Methods

ppr :: Usage -> SDoc

Outputable UsageEnv

Defined in GHC.Core.UsageEnv

Methods

ppr :: UsageEnv -> SDoc

Outputable FastString

Defined in GHC.Utils.Outputable

Methods

ppr :: FastString -> SDoc

Outputable LexicalFastString

Defined in GHC.Utils.Outputable

Methods

ppr :: LexicalFastString -> SDoc

Outputable NonDetFastString

Defined in GHC.Utils.Outputable

Methods

ppr :: NonDetFastString -> SDoc

Outputable Language

Defined in GHC.Driver.Flags

Methods

ppr :: Language -> SDoc

Outputable WarnReason

Defined in GHC.Driver.Flags

Methods

ppr :: WarnReason -> SDoc

Outputable PluginRecompile

Defined in GHC.Driver.Plugins

Methods

ppr :: PluginRecompile -> SDoc

Outputable GhcMode

Defined in GHC.Driver.Session

Methods

ppr :: GhcMode -> SDoc

Outputable ModRenaming

Defined in GHC.Driver.Session

Methods

ppr :: ModRenaming -> SDoc

Outputable PackageArg

Defined in GHC.Driver.Session

Methods

ppr :: PackageArg -> SDoc

Outputable PackageFlag

Defined in GHC.Driver.Session

Methods

ppr :: PackageFlag -> SDoc

Outputable HsModule

Defined in GHC.Hs

Methods

ppr :: HsModule -> SDoc

Outputable XViaStrategyPs

Defined in GHC.Hs.Decls

Methods

ppr :: XViaStrategyPs -> SDoc

Outputable ArgDocMap

Defined in GHC.Hs.Doc

Methods

ppr :: ArgDocMap -> SDoc

Outputable DeclDocMap

Defined in GHC.Hs.Doc

Methods

ppr :: DeclDocMap -> SDoc

Outputable HsDocString

Defined in GHC.Hs.Doc

Methods

ppr :: HsDocString -> SDoc

Outputable GrhsAnn

Defined in GHC.Hs.Expr

Methods

ppr :: GrhsAnn -> SDoc

Outputable PendingRnSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingRnSplice -> SDoc

Outputable PendingTcSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingTcSplice -> SDoc

Outputable SyntaxExprRn

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExprRn -> SDoc

Outputable SyntaxExprTc

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExprTc -> SDoc

Outputable IfaceAT

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceAT -> SDoc

Outputable IfaceAnnotation

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceAnnotation -> SDoc

Outputable IfaceClassOp

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceClassOp -> SDoc

Outputable IfaceClsInst

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceClsInst -> SDoc

Outputable IfaceCompleteMatch

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceCompleteMatch -> SDoc

Outputable IfaceConAlt

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceConAlt -> SDoc

Outputable IfaceDecl

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceDecl -> SDoc

Outputable IfaceExpr

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceExpr -> SDoc

Outputable IfaceFamInst

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceFamInst -> SDoc

Outputable IfaceIdDetails

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceIdDetails -> SDoc

Outputable IfaceInfoItem

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceInfoItem -> SDoc

Outputable IfaceJoinInfo

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceJoinInfo -> SDoc

Outputable IfaceLFInfo

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceLFInfo -> SDoc

Outputable IfaceRule

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceRule -> SDoc

Outputable IfaceTyConParent

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceTyConParent -> SDoc

Outputable IfaceUnfolding

Defined in GHC.Iface.Syntax

Methods

ppr :: IfaceUnfolding -> SDoc

Outputable ShowHowMuch

Defined in GHC.Iface.Syntax

Methods

ppr :: ShowHowMuch -> SDoc

Outputable IfaceAppArgs

Defined in GHC.Iface.Type

Methods

ppr :: IfaceAppArgs -> SDoc

Outputable IfaceBndr

Defined in GHC.Iface.Type

Methods

ppr :: IfaceBndr -> SDoc

Outputable IfaceCoercion

Defined in GHC.Iface.Type

Methods

ppr :: IfaceCoercion -> SDoc

Outputable IfaceOneShot

Defined in GHC.Iface.Type

Methods

ppr :: IfaceOneShot -> SDoc

Outputable IfaceTyCon

Defined in GHC.Iface.Type

Methods

ppr :: IfaceTyCon -> SDoc

Outputable IfaceTyConInfo

Defined in GHC.Iface.Type

Methods

ppr :: IfaceTyConInfo -> SDoc

Outputable IfaceTyConSort

Defined in GHC.Iface.Type

Methods

ppr :: IfaceTyConSort -> SDoc

Outputable IfaceTyLit

Defined in GHC.Iface.Type

Methods

ppr :: IfaceTyLit -> SDoc

Outputable IfaceType

Defined in GHC.Iface.Type

Methods

ppr :: IfaceType -> SDoc

Outputable Linkable

Defined in GHC.Linker.Types

Methods

ppr :: Linkable -> SDoc

Outputable SptEntry

Defined in GHC.Linker.Types

Methods

ppr :: SptEntry -> SDoc

Outputable Unlinked

Defined in GHC.Linker.Types

Methods

ppr :: Unlinked -> SDoc

Outputable AddEpAnn

Defined in GHC.Parser.Annotation

Methods

ppr :: AddEpAnn -> SDoc

Outputable Anchor

Defined in GHC.Parser.Annotation

Methods

ppr :: Anchor -> SDoc

Outputable AnchorOperation

Defined in GHC.Parser.Annotation

Methods

ppr :: AnchorOperation -> SDoc

Outputable AnnContext

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnContext -> SDoc

Outputable AnnKeywordId

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnKeywordId -> SDoc

Outputable AnnList

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnList -> SDoc

Outputable AnnListItem

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnListItem -> SDoc

Outputable AnnPragma

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnPragma -> SDoc

Outputable AnnSortKey

Defined in GHC.Parser.Annotation

Methods

ppr :: AnnSortKey -> SDoc

Outputable DeltaPos

Defined in GHC.Parser.Annotation

Methods

ppr :: DeltaPos -> SDoc

Outputable EpAnnComments

Defined in GHC.Parser.Annotation

Methods

ppr :: EpAnnComments -> SDoc

Outputable EpaComment

Defined in GHC.Parser.Annotation

Methods

ppr :: EpaComment -> SDoc

Outputable EpaLocation

Defined in GHC.Parser.Annotation

Methods

ppr :: EpaLocation -> SDoc

Outputable IsUnicodeSyntax

Defined in GHC.Parser.Annotation

Methods

ppr :: IsUnicodeSyntax -> SDoc

Outputable NameAdornment

Defined in GHC.Parser.Annotation

Methods

ppr :: NameAdornment -> SDoc

Outputable NameAnn

Defined in GHC.Parser.Annotation

Methods

ppr :: NameAnn -> SDoc

Outputable TrailingAnn

Defined in GHC.Parser.Annotation

Methods

ppr :: TrailingAnn -> SDoc

Outputable DataConBuilder

Defined in GHC.Parser.Types

Methods

ppr :: DataConBuilder -> SDoc

Outputable ChildLookupResult

Defined in GHC.Rename.Env

Methods

ppr :: ChildLookupResult -> SDoc

Outputable DisambigInfo

Defined in GHC.Rename.Env

Methods

ppr :: DisambigInfo -> SDoc

Outputable HsSigCtxt

Defined in GHC.Rename.Env

Methods

ppr :: HsSigCtxt -> SDoc

Outputable AltType

Defined in GHC.Stg.Syntax

Methods

ppr :: AltType -> SDoc

Outputable ConstructorNumber

Defined in GHC.Stg.Syntax

Methods

ppr :: ConstructorNumber -> SDoc

Outputable NoExtFieldSilent

Defined in GHC.Stg.Syntax

Methods

ppr :: NoExtFieldSilent -> SDoc

Outputable StgArg

Defined in GHC.Stg.Syntax

Methods

ppr :: StgArg -> SDoc

Outputable UpdateFlag

Defined in GHC.Stg.Syntax

Methods

ppr :: UpdateFlag -> SDoc

Outputable ArgDescr

Defined in GHC.StgToCmm.Types

Methods

ppr :: ArgDescr -> SDoc

Outputable LambdaFormInfo

Defined in GHC.StgToCmm.Types

Methods

ppr :: LambdaFormInfo -> SDoc

Outputable StandardFormInfo

Defined in GHC.StgToCmm.Types

Methods

ppr :: StandardFormInfo -> SDoc

Outputable HoleFit

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

ppr :: HoleFit -> SDoc

Outputable HoleFitCandidate

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

ppr :: HoleFitCandidate -> SDoc

Outputable TypedHole

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

ppr :: TypedHole -> SDoc

Outputable IdBindingInfo

Defined in GHC.Tc.Types

Methods

ppr :: IdBindingInfo -> SDoc

Outputable PromotionErr

Defined in GHC.Tc.Types

Methods

ppr :: PromotionErr -> SDoc

Outputable TcBinder

Defined in GHC.Tc.Types

Methods

ppr :: TcBinder -> SDoc

Outputable TcIdSigInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcIdSigInfo -> SDoc

Outputable TcIdSigInst

Defined in GHC.Tc.Types

Methods

ppr :: TcIdSigInst -> SDoc

Outputable TcPatSynInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcPatSynInfo -> SDoc

Outputable TcSigInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcSigInfo -> SDoc

Outputable TcTyThing

Defined in GHC.Tc.Types

Methods

ppr :: TcTyThing -> SDoc

Outputable ThStage

Defined in GHC.Tc.Types

Methods

ppr :: ThStage -> SDoc

Outputable WhereFrom

Defined in GHC.Tc.Types

Methods

ppr :: WhereFrom -> SDoc

Outputable CanEqLHS

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CanEqLHS -> SDoc

Outputable CheckTyEqResult

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CheckTyEqResult -> SDoc

Outputable Ct

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Ct -> SDoc

Outputable CtEvidence

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtEvidence -> SDoc

Outputable CtFlavour

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtFlavour -> SDoc

Outputable CtIrredReason

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtIrredReason -> SDoc

Outputable HasGivenEqs

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: HasGivenEqs -> SDoc

Outputable Hole

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Hole -> SDoc

Outputable HoleSort

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: HoleSort -> SDoc

Outputable ImplicStatus

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: ImplicStatus -> SDoc

Outputable Implication

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Implication -> SDoc

Outputable QCInst

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: QCInst -> SDoc

Outputable SubGoalDepth

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: SubGoalDepth -> SDoc

Outputable TcEvDest

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: TcEvDest -> SDoc

Outputable WantedConstraints

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: WantedConstraints -> SDoc

Outputable EvBind

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBind -> SDoc

Outputable EvBindMap

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBindMap -> SDoc

Outputable EvBindsVar

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBindsVar -> SDoc

Outputable EvCallStack

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvCallStack -> SDoc

Outputable EvTerm

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvTerm -> SDoc

Outputable EvTypeable

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvTypeable -> SDoc

Outputable HoleExprRef

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: HoleExprRef -> SDoc

Outputable HsWrapper

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: HsWrapper -> SDoc

Outputable TcEvBinds

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: TcEvBinds -> SDoc

Outputable CtOrigin

Defined in GHC.Tc.Types.Origin

Methods

ppr :: CtOrigin -> SDoc

Outputable SkolemInfo

Defined in GHC.Tc.Types.Origin

Methods

ppr :: SkolemInfo -> SDoc

Outputable IsExtraConstraint

Defined in GHC.Tc.Utils.Monad

Methods

ppr :: IsExtraConstraint -> SDoc

Outputable ExpType

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: ExpType -> SDoc

Outputable InferResult

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: InferResult -> SDoc

Outputable MetaDetails

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: MetaDetails -> SDoc

Outputable MetaInfo

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: MetaInfo -> SDoc

Outputable TcLevel

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: TcLevel -> SDoc

Outputable TcTyVarDetails

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: TcTyVarDetails -> SDoc

Outputable Annotation

Defined in GHC.Types.Annotations

Methods

ppr :: Annotation -> SDoc

Outputable AvailInfo

Defined in GHC.Types.Avail

Methods

ppr :: AvailInfo -> SDoc

Outputable GreName

Defined in GHC.Types.Avail

Methods

ppr :: GreName -> SDoc

Outputable Activation

Defined in GHC.Types.Basic

Methods

ppr :: Activation -> SDoc

Outputable Alignment

Defined in GHC.Types.Basic

Methods

ppr :: Alignment -> SDoc

Outputable Boxity

Defined in GHC.Types.Basic

Methods

ppr :: Boxity -> SDoc

Outputable CompilerPhase

Defined in GHC.Types.Basic

Methods

ppr :: CompilerPhase -> SDoc

Outputable FunctionOrData

Defined in GHC.Types.Basic

Methods

ppr :: FunctionOrData -> SDoc

Outputable InlinePragma

Defined in GHC.Types.Basic

Methods

ppr :: InlinePragma -> SDoc

Outputable InlineSpec

Defined in GHC.Types.Basic

Methods

ppr :: InlineSpec -> SDoc

Outputable IntWithInf

Defined in GHC.Types.Basic

Methods

ppr :: IntWithInf -> SDoc

Outputable LeftOrRight

Defined in GHC.Types.Basic

Methods

ppr :: LeftOrRight -> SDoc

Outputable OccInfo

Defined in GHC.Types.Basic

Methods

ppr :: OccInfo -> SDoc

Outputable OneShotInfo

Defined in GHC.Types.Basic

Methods

ppr :: OneShotInfo -> SDoc

Outputable Origin

Defined in GHC.Types.Basic

Methods

ppr :: Origin -> SDoc

Outputable OverlapFlag

Defined in GHC.Types.Basic

Methods

ppr :: OverlapFlag -> SDoc

Outputable OverlapMode

Defined in GHC.Types.Basic

Methods

ppr :: OverlapMode -> SDoc

Outputable PromotionFlag

Defined in GHC.Types.Basic

Methods

ppr :: PromotionFlag -> SDoc

Outputable RecFlag

Defined in GHC.Types.Basic

Methods

ppr :: RecFlag -> SDoc

Outputable RuleMatchInfo

Defined in GHC.Types.Basic

Methods

ppr :: RuleMatchInfo -> SDoc

Outputable SuccessFlag

Defined in GHC.Types.Basic

Methods

ppr :: SuccessFlag -> SDoc

Outputable SwapFlag

Defined in GHC.Types.Basic

Methods

ppr :: SwapFlag -> SDoc

Outputable TailCallInfo

Defined in GHC.Types.Basic

Methods

ppr :: TailCallInfo -> SDoc

Outputable TopLevelFlag

Defined in GHC.Types.Basic

Methods

ppr :: TopLevelFlag -> SDoc

Outputable TupleSort

Defined in GHC.Types.Basic

Methods

ppr :: TupleSort -> SDoc

Outputable TypeOrKind

Defined in GHC.Types.Basic

Methods

ppr :: TypeOrKind -> SDoc

Outputable CompleteMatch

Defined in GHC.Types.CompleteMatch

Methods

ppr :: CompleteMatch -> SDoc

Outputable Cpr

BNF: ``` cpr ::= '' -- TopCpr | n -- FlatConCpr n | n '(' cpr1 ',' cpr2 ',' ... ')' -- ConCpr n [cpr1,cpr2,...] | b -- BotCpr ``` Examples: * `f x = f x` has denotation b * `1(1,)` is a valid (nested) Cpr denotation for `(I# 42#, f 42)`.

Defined in GHC.Types.Cpr

Methods

ppr :: Cpr -> SDoc

Outputable CprSig

Only print the CPR result

Defined in GHC.Types.Cpr

Methods

ppr :: CprSig -> SDoc

Outputable CprType

Defined in GHC.Types.Cpr

Methods

ppr :: CprType -> SDoc

Outputable Card

See Note [Demand notation] Current syntax was discussed in #19016.

Defined in GHC.Types.Demand

Methods

ppr :: Card -> SDoc

Outputable Demand

See Note [Demand notation]

Defined in GHC.Types.Demand

Methods

ppr :: Demand -> SDoc

Outputable Divergence

Defined in GHC.Types.Demand

Methods

ppr :: Divergence -> SDoc

Outputable DmdType

Defined in GHC.Types.Demand

Methods

ppr :: DmdType -> SDoc

Outputable StrictSig

Defined in GHC.Types.Demand

Methods

ppr :: StrictSig -> SDoc

Outputable SubDemand

See Note [Demand notation]

Defined in GHC.Types.Demand

Methods

ppr :: SubDemand -> SDoc

Outputable TypeShape

Defined in GHC.Types.Demand

Methods

ppr :: TypeShape -> SDoc

Outputable DuplicateRecordFields

Defined in GHC.Types.FieldLabel

Methods

ppr :: DuplicateRecordFields -> SDoc

Outputable FieldLabel

Defined in GHC.Types.FieldLabel

Methods

ppr :: FieldLabel -> SDoc

Outputable FieldSelectors

Defined in GHC.Types.FieldLabel

Methods

ppr :: FieldSelectors -> SDoc

Outputable Fixity

Defined in GHC.Types.Fixity

Methods

ppr :: Fixity -> SDoc

Outputable FixityDirection

Defined in GHC.Types.Fixity

Methods

ppr :: FixityDirection -> SDoc

Outputable LexicalFixity

Defined in GHC.Types.Fixity

Methods

ppr :: LexicalFixity -> SDoc

Outputable FixItem

Defined in GHC.Types.Fixity.Env

Methods

ppr :: FixItem -> SDoc

Outputable CCallConv

Defined in GHC.Types.ForeignCall

Methods

ppr :: CCallConv -> SDoc

Outputable CCallSpec

Defined in GHC.Types.ForeignCall

Methods

ppr :: CCallSpec -> SDoc

Outputable CExportSpec

Defined in GHC.Types.ForeignCall

Methods

ppr :: CExportSpec -> SDoc

Outputable CType

Defined in GHC.Types.ForeignCall

Methods

ppr :: CType -> SDoc

Outputable ForeignCall

Defined in GHC.Types.ForeignCall

Methods

ppr :: ForeignCall -> SDoc

Outputable Header

Defined in GHC.Types.ForeignCall

Methods

ppr :: Header -> SDoc

Outputable Safety

Defined in GHC.Types.ForeignCall

Methods

ppr :: Safety -> SDoc

Outputable CafInfo

Defined in GHC.Types.Id.Info

Methods

ppr :: CafInfo -> SDoc

Outputable IdDetails

Defined in GHC.Types.Id.Info

Methods

ppr :: IdDetails -> SDoc

Outputable LevityInfo

Defined in GHC.Types.Id.Info

Methods

ppr :: LevityInfo -> SDoc

Outputable RecSelParent

Defined in GHC.Types.Id.Info

Methods

ppr :: RecSelParent -> SDoc

Outputable TickBoxOp

Defined in GHC.Types.Id.Info

Methods

ppr :: TickBoxOp -> SDoc

Outputable Name

Defined in GHC.Types.Name

Methods

ppr :: Name -> SDoc

Outputable NameSort

Defined in GHC.Types.Name

Methods

ppr :: NameSort -> SDoc

Outputable OccName

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccName -> SDoc

Outputable GlobalRdrElt

Defined in GHC.Types.Name.Reader

Methods

ppr :: GlobalRdrElt -> SDoc

Outputable ImportSpec

Defined in GHC.Types.Name.Reader

Methods

ppr :: ImportSpec -> SDoc

Outputable LocalRdrEnv

Defined in GHC.Types.Name.Reader

Methods

ppr :: LocalRdrEnv -> SDoc

Outputable Parent

Defined in GHC.Types.Name.Reader

Methods

ppr :: Parent -> SDoc

Outputable RdrName

Defined in GHC.Types.Name.Reader

Methods

ppr :: RdrName -> SDoc

Outputable IfaceTrustInfo

Defined in GHC.Types.SafeHaskell

Methods

ppr :: IfaceTrustInfo -> SDoc

Outputable SafeHaskellMode

Defined in GHC.Types.SafeHaskell

Methods

ppr :: SafeHaskellMode -> SDoc

Outputable FractionalLit

Defined in GHC.Types.SourceText

Methods

ppr :: FractionalLit -> SDoc

Outputable IntegralLit

Defined in GHC.Types.SourceText

Methods

ppr :: IntegralLit -> SDoc

Outputable SourceText

Defined in GHC.Types.SourceText

Methods

ppr :: SourceText -> SDoc

Outputable StringLiteral

Defined in GHC.Types.SourceText

Methods

ppr :: StringLiteral -> SDoc

Outputable RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

ppr :: RealSrcLoc -> SDoc

Outputable RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

ppr :: RealSrcSpan -> SDoc

Outputable SrcLoc

Defined in GHC.Types.SrcLoc

Methods

ppr :: SrcLoc -> SDoc

Outputable SrcSpan

Defined in GHC.Types.SrcLoc

Methods

ppr :: SrcSpan -> SDoc

Outputable UnhelpfulSpanReason

Defined in GHC.Types.SrcLoc

Methods

ppr :: UnhelpfulSpanReason -> SDoc

Outputable TyThing

Defined in GHC.Types.TyThing

Methods

ppr :: TyThing -> SDoc

Outputable Unique

Defined in GHC.Types.Unique

Methods

ppr :: Unique -> SDoc

Outputable AnonArgFlag

Defined in GHC.Types.Var

Methods

ppr :: AnonArgFlag -> SDoc

Outputable ArgFlag

Defined in GHC.Types.Var

Methods

ppr :: ArgFlag -> SDoc

Outputable Var

Defined in GHC.Types.Var

Methods

ppr :: Var -> SDoc

Outputable InScopeSet

Defined in GHC.Types.Var.Env

Methods

ppr :: InScopeSet -> SDoc

Outputable ModLocation

Defined in GHC.Unit.Module.Location

Methods

ppr :: ModLocation -> SDoc

Outputable ExtendedModSummary

Defined in GHC.Unit.Module.ModSummary

Methods

ppr :: ExtendedModSummary -> SDoc

Outputable ModSummary

Defined in GHC.Unit.Module.ModSummary

Methods

ppr :: ModSummary -> SDoc

Outputable ModuleName

Defined in GHC.Unit.Module.Name

Methods

ppr :: ModuleName -> SDoc

Outputable WarningTxt

Defined in GHC.Unit.Module.Warnings

Methods

ppr :: WarningTxt -> SDoc

Outputable ModuleOrigin

Defined in GHC.Unit.State

Methods

ppr :: ModuleOrigin -> SDoc

Outputable UnitErr

Defined in GHC.Unit.State

Methods

ppr :: UnitErr -> SDoc

Outputable UnitVisibility

Defined in GHC.Unit.State

Methods

ppr :: UnitVisibility -> SDoc

Outputable UnusableUnitReason

Defined in GHC.Unit.State

Methods

ppr :: UnusableUnitReason -> SDoc

Outputable InstalledModule

Defined in GHC.Unit.Types

Methods

ppr :: InstalledModule -> SDoc

Outputable InstantiatedModule

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedModule -> SDoc

Outputable InstantiatedUnit

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedUnit -> SDoc

Outputable Module

Defined in GHC.Unit.Types

Methods

ppr :: Module -> SDoc

Outputable Unit

Defined in GHC.Unit.Types

Methods

ppr :: Unit -> SDoc

Outputable UnitId

Defined in GHC.Unit.Types

Methods

ppr :: UnitId -> SDoc

Outputable PprStyle

Defined in GHC.Utils.Outputable

Methods

ppr :: PprStyle -> SDoc

Outputable QualifyName

Defined in GHC.Utils.Outputable

Methods

ppr :: QualifyName -> SDoc

Outputable SDoc

Defined in GHC.Utils.Outputable

Methods

ppr :: SDoc -> SDoc

Outputable DocDecl

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: DocDecl -> SDoc

Outputable ForeignExport

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: ForeignExport -> SDoc

Outputable ForeignImport

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: ForeignImport -> SDoc

Outputable NewOrData

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: NewOrData -> SDoc

Outputable SpliceDecoration

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: SpliceDecoration -> SDoc

Outputable NoExtCon

Defined in Language.Haskell.Syntax.Extension

Methods

ppr :: NoExtCon -> SDoc

Outputable NoExtField

Defined in Language.Haskell.Syntax.Extension

Methods

ppr :: NoExtField -> SDoc

Outputable OverLitVal

Defined in Language.Haskell.Syntax.Lit

Methods

ppr :: OverLitVal -> SDoc

Outputable HsIPName

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsIPName -> SDoc

Outputable HsTyLit

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsTyLit -> SDoc

Outputable Serialized

Defined in GHC.Utils.Outputable

Methods

ppr :: Serialized -> SDoc

Outputable Extension

Defined in GHC.Utils.Outputable

Methods

ppr :: Extension -> SDoc

Outputable Ordering

Defined in GHC.Utils.Outputable

Methods

ppr :: Ordering -> SDoc

Outputable Integer

Defined in GHC.Utils.Outputable

Methods

ppr :: Integer -> SDoc

Outputable ()

Defined in GHC.Utils.Outputable

Methods

ppr :: () -> SDoc

Outputable Bool

Defined in GHC.Utils.Outputable

Methods

ppr :: Bool -> SDoc

Outputable Char

Defined in GHC.Utils.Outputable

Methods

ppr :: Char -> SDoc

Outputable Double

Defined in GHC.Utils.Outputable

Methods

ppr :: Double -> SDoc

Outputable Float

Defined in GHC.Utils.Outputable

Methods

ppr :: Float -> SDoc

Outputable Int

Defined in GHC.Utils.Outputable

Methods

ppr :: Int -> SDoc

Outputable Word

Defined in GHC.Utils.Outputable

Methods

ppr :: Word -> SDoc

Outputable a => Outputable (SCC a)

Defined in GHC.Utils.Outputable

Methods

ppr :: SCC a -> SDoc

Outputable elt => Outputable (IntMap elt)

Defined in GHC.Utils.Outputable

Methods

ppr :: IntMap elt -> SDoc

Outputable a => Outputable (Set a)

Defined in GHC.Utils.Outputable

Methods

ppr :: Set a -> SDoc

Outputable a => Outputable (LabelMap a)

Defined in GHC.Cmm.Dataflow.Label

Methods

ppr :: LabelMap a -> SDoc

Outputable b => Outputable (TaggedBndr b)

Defined in GHC.Core

Methods

ppr :: TaggedBndr b -> SDoc

Outputable ev => Outputable (NormaliseStepResult ev)

Defined in GHC.Core.Coercion

Methods

ppr :: NormaliseStepResult ev -> SDoc

Outputable (CoAxiom br)

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: CoAxiom br -> SDoc

Outputable a => Outputable (TypeMapG a)

Defined in GHC.Core.Map.Type

Methods

ppr :: TypeMapG a -> SDoc

Outputable a => Outputable (Scaled a)

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Scaled a -> SDoc

Outputable a => Outputable (UnifyResultM a)

Defined in GHC.Core.Unify

Methods

ppr :: UnifyResultM a -> SDoc

Outputable a => Outputable (Bag a)

Defined in GHC.Data.Bag

Methods

ppr :: Bag a -> SDoc

OutputableBndr a => Outputable (BooleanFormula a)

Defined in GHC.Data.BooleanFormula

Methods

ppr :: BooleanFormula a -> SDoc

Outputable a => Outputable (Pair a)

Defined in GHC.Data.Pair

Methods

ppr :: Pair a -> SDoc

Outputable a => Outputable (OnOff a)

Defined in GHC.Driver.Session

Methods

ppr :: OnOff a -> SDoc

OutputableBndrId p => Outputable (IE (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc

OutputableBndr name => Outputable (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

ppr :: IEWrappedName name -> SDoc

(OutputableBndrId p, Outputable (Anno (IE (GhcPass p)))) => Outputable (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc

Outputable a => Outputable (EpAnn a)

Defined in GHC.Parser.Annotation

Methods

ppr :: EpAnn a -> SDoc

Outputable a => Outputable (SrcSpanAnn' a)

Defined in GHC.Parser.Annotation

Methods

ppr :: SrcSpanAnn' a -> SDoc

Outputable (PatBuilder GhcPs)

Defined in GHC.Parser.Types

Methods

ppr :: PatBuilder GhcPs -> SDoc

OutputableBndrId a => Outputable (InstInfo (GhcPass a))

Defined in GHC.Tc.Utils.Env

Methods

ppr :: InstInfo (GhcPass a) -> SDoc

Outputable name => Outputable (AnnTarget name)

Defined in GHC.Types.Annotations

Methods

ppr :: AnnTarget name -> SDoc

Outputable (DefMethSpec ty)

Defined in GHC.Types.Basic

Methods

ppr :: DefMethSpec ty -> SDoc

Outputable a => Outputable (OccEnv a)

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccEnv a -> SDoc

Outputable e => Outputable (Located e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: Located e -> SDoc

Outputable a => Outputable (UniqDSet a)

Defined in GHC.Types.Unique.DSet

Methods

ppr :: UniqDSet a -> SDoc

Outputable a => Outputable (UniqSet a)

Defined in GHC.Types.Unique.Set

Methods

ppr :: UniqSet a -> SDoc

Outputable unit => Outputable (Definite unit)

Defined in GHC.Unit.Types

Methods

ppr :: Definite unit -> SDoc

Outputable a => Outputable (GenWithIsBoot a)

Defined in GHC.Unit.Types

Methods

ppr :: GenWithIsBoot a -> SDoc

Outputable unit => Outputable (Indefinite unit)

Defined in GHC.Unit.Types

Methods

ppr :: Indefinite unit -> SDoc

Outputable (RecordPatSynField a)

Defined in Language.Haskell.Syntax.Binds

Methods

ppr :: RecordPatSynField a -> SDoc

Outputable (FamilyInfo pass)

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: FamilyInfo pass -> SDoc

Outputable (FieldLabelStrings p)

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: FieldLabelStrings p -> SDoc

Outputable (HsFieldLabel p)

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: HsFieldLabel p -> SDoc

Outputable (FieldOcc pass)

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: FieldOcc pass -> SDoc

Outputable a => Outputable (NonEmpty a)

Defined in GHC.Utils.Outputable

Methods

ppr :: NonEmpty a -> SDoc

Outputable a => Outputable (Maybe a)

Defined in GHC.Utils.Outputable

Methods

ppr :: Maybe a -> SDoc

Outputable a => Outputable [a]

Defined in GHC.Utils.Outputable

Methods

ppr :: [a] -> SDoc

(Outputable a, Outputable b) => Outputable (Either a b)

Defined in GHC.Utils.Outputable

Methods

ppr :: Either a b -> SDoc

(Outputable key, Outputable elt) => Outputable (Map key elt)

Defined in GHC.Utils.Outputable

Methods

ppr :: Map key elt -> SDoc

(Outputable a, Outputable (m a)) => Outputable (GenMap m a)

Defined in GHC.Data.TrieMap

Methods

ppr :: GenMap m a -> SDoc

(TrieMap m, Outputable a) => Outputable (ListMap m a)

Defined in GHC.Data.TrieMap

Methods

ppr :: ListMap m a -> SDoc

(Outputable a, Outputable b) => Outputable (HsExpansion a b)

Just print the original expression (the a).

Defined in GHC.Hs.Expr

Methods

ppr :: HsExpansion a b -> SDoc

Outputable (GenLocated Anchor EpaComment)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated Anchor EpaComment -> SDoc

(Outputable a, Outputable e) => Outputable (GenLocated (SrcSpanAnn' a) e)

Defined in GHC.Parser.Annotation

Methods

ppr :: GenLocated (SrcSpanAnn' a) e -> SDoc

Outputable e => Outputable (GenLocated RealSrcSpan e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: GenLocated RealSrcSpan e -> SDoc

Outputable a => Outputable (UniqDFM key a)

Defined in GHC.Types.Unique.DFM

Methods

ppr :: UniqDFM key a -> SDoc

Outputable a => Outputable (UniqFM key a)

Defined in GHC.Types.Unique.FM

Methods

ppr :: UniqFM key a -> SDoc

OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)

Defined in GHC.Core.TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

Outputable tv => Outputable (VarBndr tv ArgFlag)

Defined in GHC.Types.Var

Methods

ppr :: VarBndr tv ArgFlag -> SDoc

Outputable tv => Outputable (VarBndr tv Specificity)

Defined in GHC.Types.Var

Methods

ppr :: VarBndr tv Specificity -> SDoc

(Outputable p, OutputableBndr p, Outputable arg) => Outputable (HsRecField' p arg)

Defined in Language.Haskell.Syntax.Pat

Methods

ppr :: HsRecField' p arg -> SDoc

(Outputable arg, Outputable (XRec p (HsRecField p arg))) => Outputable (HsRecFields p arg)

Defined in Language.Haskell.Syntax.Pat

Methods

ppr :: HsRecFields p arg -> SDoc

(Outputable tm, Outputable ty) => Outputable (HsArg tm ty)

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsArg tm ty -> SDoc

Outputable a => Outputable (HsScaled pass a)

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsScaled pass a -> SDoc

(Outputable a, Outputable b) => Outputable (a, b)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b) -> SDoc

(Outputable tyarg, Outputable arg, Outputable rec) => Outputable (HsConDetails tyarg arg rec)

Defined in Language.Haskell.Syntax.Type

Methods

ppr :: HsConDetails tyarg arg rec -> SDoc

(Outputable a, Outputable b, Outputable c) => Outputable (a, b, c)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c) -> SDoc

(Outputable a, Outputable b, Outputable c, Outputable d) => Outputable (a, b, c, d)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c, d) -> SDoc

(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e) => Outputable (a, b, c, d, e)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c, d, e) -> SDoc

(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f) => Outputable (a, b, c, d, e, f)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c, d, e, f) -> SDoc

(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f, Outputable g) => Outputable (a, b, c, d, e, f, g)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c, d, e, f, g) -> SDoc

data LabelStyle

Style of label pretty-printing.

When we produce C sources or headers, we have to take into account that C compilers transform C labels when they convert them into symbols. For example, they can add prefixes (e.g., "_" on Darwin) or suffixes (size for stdcalls on Windows). So we provide two ways to pretty-print CLabels: C style or Asm style.

Constructors

CStyle

C label style (used by C and LLVM backends)

AsmStyle

Asm label style (used by NCG backend)

Instances

Show LabelStyle

Defined in GHC.Utils.Outputable

Methods

showsPrec :: Int -> LabelStyle -> ShowS

show :: LabelStyle -> String

showList :: [LabelStyle] -> ShowS

Eq LabelStyle

Defined in GHC.Utils.Outputable

Methods

(==) :: LabelStyle -> LabelStyle -> Bool

(/=) :: LabelStyle -> LabelStyle -> Bool

Ord LabelStyle

Defined in GHC.Utils.Outputable

Methods

compare :: LabelStyle -> LabelStyle -> Ordering

(<) :: LabelStyle -> LabelStyle -> Bool

(<=) :: LabelStyle -> LabelStyle -> Bool

(>) :: LabelStyle -> LabelStyle -> Bool

(>=) :: LabelStyle -> LabelStyle -> Bool

max :: LabelStyle -> LabelStyle -> LabelStyle

min :: LabelStyle -> LabelStyle -> LabelStyle

data Depth

Constructors

AllTheWay

PartWay Int

0 => stop

DefaultDepth

Use sdocDefaultDepth field as depth

data BindingSite

BindingSite is used to tell the thing that prints binder what language construct is binding the identifier. This can be used to decide how much info to print. Also see Note [Binding-site specific printing] in GHC.Core.Ppr

Constructors

LambdaBind

The x in (x. e)

CaseBind

The x in case scrut of x { (y,z) -> ... }

CasePatBind

The y,z in case scrut of x { (y,z) -> ... }

LetBind

The x in (let x = rhs in e)

ztext :: FastZString -> SDoc

word :: Integer -> SDoc

withUserStyle :: PrintUnqualified -> Depth -> SDoc -> SDoc

withPprStyle :: PprStyle -> SDoc -> SDoc

withErrStyle :: PrintUnqualified -> SDoc -> SDoc

whenPprDebug :: SDoc -> SDoc

Says what to do with -dppr-debug; without, return empty

vcat :: [SDoc] -> SDoc

Concatenate SDoc vertically with dovetailing

vbar :: SDoc

userStyle :: PprStyle -> Bool

updSDocContext :: (SDocContext -> SDocContext) -> SDoc -> SDoc

unicodeSyntax :: SDoc -> SDoc -> SDoc

underscore :: SDoc

speakNth :: Int -> SDoc

Converts an integer to a verbal index:

speakNth 1 = text "first"
speakNth 5 = text "fifth"
speakNth 21 = text "21st"

speakNOf :: Int -> SDoc -> SDoc

Converts an integer and object description to a statement about the multiplicity of those objects:

speakNOf 0 (text "melon") = text "no melons"
speakNOf 1 (text "melon") = text "one melon"
speakNOf 3 (text "melon") = text "three melons"

speakN :: Int -> SDoc

Converts an integer to a verbal multiplicity:

speakN 0 = text "none"
speakN 5 = text "five"
speakN 10 = text "10"

space :: SDoc

showSDocUnsafe :: SDoc -> String

showSDocOneLine :: SDocContext -> SDoc -> String

showPprUnsafe :: Outputable a => a -> String

setStyleColoured :: Bool -> PprStyle -> PprStyle

sep :: [SDoc] -> SDoc

Separate: is either like hsep or like vcat, depending on what fits

semi :: SDoc

sdocWithContext :: (SDocContext -> SDoc) -> SDoc

sdocOption :: (SDocContext -> a) -> (a -> SDoc) -> SDoc

runSDoc :: SDoc -> SDocContext -> Doc

rparen :: SDoc

renderWithContext :: SDocContext -> SDoc -> String

reallyAlwaysQualifyNames :: QueryQualifyName

reallyAlwaysQualify :: PrintUnqualified

rbrack :: SDoc

rbrace :: SDoc

rational :: Rational -> SDoc

quotes :: SDoc -> SDoc

quotedListWithOr :: [SDoc] -> SDoc

quotedListWithNor :: [SDoc] -> SDoc

quote :: SDoc -> SDoc

queryQual :: PprStyle -> PrintUnqualified

qualPackage :: PprStyle -> QueryQualifyPackage

qualName :: PprStyle -> QueryQualifyName

qualModule :: PprStyle -> QueryQualifyModule

punctuate

Arguments

:: SDoc

The punctuation

-> [SDoc]

The list that will have punctuation added between every adjacent pair of elements

-> [SDoc]

Punctuated list

ptext :: PtrString -> SDoc

printSDocLn :: SDocContext -> Mode -> Handle -> SDoc -> IO ()

Like printSDoc but appends an extra newline.

printSDoc :: SDocContext -> Mode -> Handle -> SDoc -> IO ()

The analog of printDoc_ for SDoc, which tries to make sure the terminal doesn't get screwed up by the ANSI color codes if an exception is thrown during pretty-printing.

primWordSuffix :: SDoc

primWord8Suffix :: SDoc

primWord64Suffix :: SDoc

primWord32Suffix :: SDoc

primWord16Suffix :: SDoc

primIntSuffix :: SDoc

primInt8Suffix :: SDoc

primInt64Suffix :: SDoc

primInt32Suffix :: SDoc

primInt16Suffix :: SDoc

primFloatSuffix :: SDoc

primDoubleSuffix :: SDoc

primCharSuffix :: SDoc

pprWithCommas

Arguments

:: (a -> SDoc)

The pretty printing function to use

-> [a]

The things to be pretty printed

-> SDoc

SDoc where the things have been pretty printed, comma-separated and finally packed into a paragraph.

pprWithBars

Arguments

:: (a -> SDoc)

The pretty printing function to use

-> [a]

The things to be pretty printed

-> SDoc

SDoc where the things have been pretty printed, bar-separated and finally packed into a paragraph.

pprSetDepth :: Depth -> SDoc -> SDoc

pprQuotedList :: Outputable a => [a] -> SDoc

Returns the comma-separated concatenation of the quoted pretty printed things.

[x,y,z]  ==>  `x', `y', `z'

pprPrimWord8 :: Integer -> SDoc

pprPrimWord64 :: Integer -> SDoc

pprPrimWord32 :: Integer -> SDoc

pprPrimWord16 :: Integer -> SDoc

pprPrimWord :: Integer -> SDoc

pprPrimInt8 :: Integer -> SDoc

pprPrimInt64 :: Integer -> SDoc

pprPrimInt32 :: Integer -> SDoc

pprPrimInt16 :: Integer -> SDoc

pprPrimInt :: Integer -> SDoc

pprPrimChar :: Char -> SDoc

Special combinator for showing unboxed literals.

pprPrefixVar :: Bool -> SDoc -> SDoc

pprInfixVar :: Bool -> SDoc -> SDoc

pprHsString :: FastString -> SDoc

Special combinator for showing string literals.

pprHsChar :: Char -> SDoc

Special combinator for showing character literals.

pprHsBytes :: ByteString -> SDoc

Special combinator for showing bytestring literals.

pprFilePathString :: FilePath -> SDoc

Normalise, escape and render a string representing a path

e.g. "c:\whatever"

pprFastFilePath :: FastString -> SDoc

pprDeeperList :: ([SDoc] -> SDoc) -> [SDoc] -> SDoc

Truncate a list that is longer than the current depth.

pprDeeper :: SDoc -> SDoc

pprCode :: LabelStyle -> SDoc -> SDoc

ppWhenOption :: (SDocContext -> Bool) -> SDoc -> SDoc

ppWhen :: Bool -> SDoc -> SDoc

ppUnlessOption :: (SDocContext -> Bool) -> SDoc -> SDoc

ppUnless :: Bool -> SDoc -> SDoc

plural :: [a] -> SDoc

Determines the pluralisation suffix appropriate for the length of a list:

plural [] = char 's'
plural ["Hello"] = empty
plural ["Hello", "World"] = char 's'

parens :: SDoc -> SDoc

neverQualifyPackages :: QueryQualifyPackage

neverQualifyNames :: QueryQualifyName

neverQualifyModules :: QueryQualifyModule

neverQualify :: PrintUnqualified

nest :: Int -> SDoc -> SDoc

Indent SDoc some specified amount

mulArrow :: SDoc -> SDoc

mkUserStyle :: PrintUnqualified -> Depth -> PprStyle

mkErrStyle :: PrintUnqualified -> PprStyle

Style for printing error messages

mkDumpStyle :: PrintUnqualified -> PprStyle

lparen :: SDoc

lollipop :: SDoc

lbrack :: SDoc

lbrace :: SDoc

larrowtt :: SDoc

larrowt :: SDoc

larrow :: SDoc

lambda :: SDoc

keyword :: SDoc -> SDoc

itsOrTheir :: [a] -> SDoc

Determines the form of possessive appropriate for the length of a list:

itsOrTheir [x]   = text "its"
itsOrTheir [x,y] = text "their"
itsOrTheir []    = text "their"  -- probably avoid this

isOrAre :: [a] -> SDoc

Determines the form of to be appropriate for the length of a list:

isOrAre [] = text "are"
isOrAre ["Hello"] = text "is"
isOrAre ["Hello", "World"] = text "are"

isEmpty :: SDocContext -> SDoc -> Bool

interppSP :: Outputable a => [a] -> SDoc

Returns the separated concatenation of the pretty printed things.

interpp'SP' :: (a -> SDoc) -> [a] -> SDoc

interpp'SP :: Outputable a => [a] -> SDoc

Returns the comma-separated concatenation of the pretty printed things.

integer :: Integer -> SDoc

intWithCommas :: Integral a => a -> SDoc

int :: Int -> SDoc

ifPprDebug :: SDoc -> SDoc -> SDoc

Says what to do with and without -dppr-debug

hsep :: [SDoc] -> SDoc

Concatenate SDoc horizontally with a space between each one

hcat :: [SDoc] -> SDoc

Concatenate SDoc horizontally

hangNotEmpty :: SDoc -> Int -> SDoc -> SDoc

This behaves like hang, but does not indent the second document when the header is empty.

hang

Arguments

:: SDoc

The header

-> Int

Amount to indent the hung body

-> SDoc

The hung body, indented and placed below the header

-> SDoc

getPprStyle :: (PprStyle -> SDoc) -> SDoc

getPprDebug :: (Bool -> SDoc) -> SDoc

Indicate if -dppr-debug mode is enabled

ftext :: FastString -> SDoc

fsep :: [SDoc] -> SDoc

A paragraph-fill combinator. It's much like sep, only it keeps fitting things on one line until it can't fit any more.

forAllLit :: SDoc

float :: Float -> SDoc

fcat :: [SDoc] -> SDoc

This behaves like fsep, but it uses <> for horizontal conposition rather than <+>

equals :: SDoc

empty :: SDoc

dumpStyle :: PprStyle -> Bool

doubleQuotes :: SDoc -> SDoc

doublePrec :: Int -> Double -> SDoc

doublePrec p n shows a floating point number n with p digits of precision after the decimal point.

double :: Double -> SDoc

dot :: SDoc

docToSDoc :: Doc -> SDoc

doOrDoes :: [a] -> SDoc

Determines the form of to do appropriate for the length of a list:

doOrDoes [] = text "do"
doOrDoes ["Hello"] = text "does"
doOrDoes ["Hello", "World"] = text "do"

defaultUserStyle :: PprStyle

defaultSDocContext :: SDocContext

Default pretty-printing options

defaultErrStyle :: PprStyle

Default style for error messages, when we don't know PrintUnqualified It's a bit of a hack because it doesn't take into account what's in scope Only used for desugarer warnings, and typechecker errors in interface sigs

defaultDumpStyle :: PprStyle

dcolon :: SDoc

darrow :: SDoc

cparen :: Bool -> SDoc -> SDoc

comma :: SDoc

coloured :: PprColour -> SDoc -> SDoc

Apply the given colour/style for the argument.

Only takes effect if colours are enabled.

colon :: SDoc

codeStyle :: PprStyle -> Bool

cmdlineParserStyle :: PprStyle

char :: Char -> SDoc

cat :: [SDoc] -> SDoc

Catenate: is either like hcat or like vcat, depending on what fits

bullet :: SDoc

bufLeftRenderSDoc :: SDocContext -> BufHandle -> SDoc -> IO ()

An efficient variant of printSDoc specialized for LeftMode that outputs to a BufHandle.

brackets :: SDoc -> SDoc

braces :: SDoc -> SDoc

blankLine :: SDoc

asmStyle :: PprStyle -> Bool

arrowtt :: SDoc

arrowt :: SDoc

arrow :: SDoc

angleBrackets :: SDoc -> SDoc

alwaysQualifyPackages :: QueryQualifyPackage

alwaysQualifyNames :: QueryQualifyName

NB: This won't ever show package IDs

alwaysQualifyModules :: QueryQualifyModule

alwaysQualify :: PrintUnqualified

(<>) :: SDoc -> SDoc -> SDoc

Join two SDoc together horizontally without a gap

(<+>) :: SDoc -> SDoc -> SDoc

Join two SDoc together horizontally with a gap between them

($+$) :: SDoc -> SDoc -> SDoc

Join two SDoc together vertically

($$) :: SDoc -> SDoc -> SDoc

Join two SDoc together vertically; if there is no vertical overlap it "dovetails" the two onto one line

data OccName

Occurrence Name

In this context that means: "classified (i.e. as a type name, value name, etc) but not qualified and not yet resolved"

Instances

Data OccName

Defined in GHC.Types.Name.Occurrence

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName

toConstr :: OccName -> Constr

dataTypeOf :: OccName -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName)

gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r

gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName

NFData OccName

Defined in GHC.Types.Name.Occurrence

Methods

rnf :: OccName -> ()

HasOccName OccName

Defined in GHC.Types.Name.Occurrence

Methods

occName :: OccName -> OccName

Uniquable OccName

Defined in GHC.Types.Name.Occurrence

Methods

getUnique :: OccName -> Unique

Binary OccName

Defined in GHC.Types.Name.Occurrence

Methods

put_ :: BinHandle -> OccName -> IO ()

put :: BinHandle -> OccName -> IO (Bin OccName)

get :: BinHandle -> IO OccName

Outputable OccName

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccName -> SDoc

OutputableBndr OccName

Defined in GHC.Types.Name.Occurrence

Methods

pprBndr :: BindingSite -> OccName -> SDoc

pprPrefixOcc :: OccName -> SDoc

pprInfixOcc :: OccName -> SDoc

bndrIsJoin_maybe :: OccName -> Maybe Int

Eq OccName

Defined in GHC.Types.Name.Occurrence

Methods

(==) :: OccName -> OccName -> Bool

(/=) :: OccName -> OccName -> Bool

Ord OccName

Defined in GHC.Types.Name.Occurrence

Methods

compare :: OccName -> OccName -> Ordering

(<) :: OccName -> OccName -> Bool

(<=) :: OccName -> OccName -> Bool

(>) :: OccName -> OccName -> Bool

(>=) :: OccName -> OccName -> Bool

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

class HasOccName name where

Other names in the compiler add additional information to an OccName. This class provides a consistent way to access the underlying OccName.

Methods

occName :: name -> OccName

Instances

HasOccName IfaceClassOp

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceClassOp -> OccName

HasOccName IfaceConDecl

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceConDecl -> OccName

HasOccName IfaceDecl

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceDecl -> OccName

HasOccName HoleFitCandidate

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

occName :: HoleFitCandidate -> OccName

HasOccName TcBinder

Defined in GHC.Tc.Types

Methods

occName :: TcBinder -> OccName

HasOccName GreName

Defined in GHC.Types.Avail

Methods

occName :: GreName -> OccName

HasOccName FieldLabel

Defined in GHC.Types.FieldLabel

Methods

occName :: FieldLabel -> OccName

HasOccName Name

Defined in GHC.Types.Name

Methods

occName :: Name -> OccName

HasOccName OccName

Defined in GHC.Types.Name.Occurrence

Methods

occName :: OccName -> OccName

HasOccName GlobalRdrElt

Defined in GHC.Types.Name.Reader

Methods

occName :: GlobalRdrElt -> OccName

HasOccName RdrName

Defined in GHC.Types.Name.Reader

Methods

occName :: RdrName -> OccName

HasOccName Var

Defined in GHC.Types.Var

Methods

occName :: Var -> OccName

HasOccName name => HasOccName (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

occName :: IEWrappedName name -> OccName

occNameString :: OccName -> String

mkVarOccFS :: FastString -> OccName

mkRecFldSelOcc :: String -> OccName

data PtrString

A PtrString is a pointer to some array of Latin-1 encoded chars.

Constructors

PtrString !(Ptr Word8) !Int

newtype NonDetFastString

Non-deterministic FastString

This is a simple FastString wrapper with an Ord instance using uniqCompareFS (i.e. which compares FastStrings on their Uniques). Hence it is not deterministic from one run to the other.

Constructors

NonDetFastString FastString

Instances

Data NonDetFastString

Defined in GHC.Data.FastString

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonDetFastString -> c NonDetFastString

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NonDetFastString

toConstr :: NonDetFastString -> Constr

dataTypeOf :: NonDetFastString -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NonDetFastString)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NonDetFastString)

gmapT :: (forall b. Data b => b -> b) -> NonDetFastString -> NonDetFastString

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonDetFastString -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonDetFastString -> r

gmapQ :: (forall d. Data d => d -> u) -> NonDetFastString -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NonDetFastString -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonDetFastString -> m NonDetFastString

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonDetFastString -> m NonDetFastString

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonDetFastString -> m NonDetFastString

Show NonDetFastString

Defined in GHC.Data.FastString

Methods

showsPrec :: Int -> NonDetFastString -> ShowS

show :: NonDetFastString -> String

showList :: [NonDetFastString] -> ShowS

Outputable NonDetFastString

Defined in GHC.Utils.Outputable

Methods

ppr :: NonDetFastString -> SDoc

Eq NonDetFastString

Defined in GHC.Data.FastString

Methods

(==) :: NonDetFastString -> NonDetFastString -> Bool

(/=) :: NonDetFastString -> NonDetFastString -> Bool

Ord NonDetFastString

Defined in GHC.Data.FastString

Methods

compare :: NonDetFastString -> NonDetFastString -> Ordering

(<) :: NonDetFastString -> NonDetFastString -> Bool

(<=) :: NonDetFastString -> NonDetFastString -> Bool

(>) :: NonDetFastString -> NonDetFastString -> Bool

(>=) :: NonDetFastString -> NonDetFastString -> Bool

max :: NonDetFastString -> NonDetFastString -> NonDetFastString

min :: NonDetFastString -> NonDetFastString -> NonDetFastString

newtype LexicalFastString

Lexical FastString

This is a simple FastString wrapper with an Ord instance using lexicalCompareFS (i.e. which compares FastStrings on their String representation). Hence it is deterministic from one run to the other.

Constructors

LexicalFastString FastString

Instances

Data LexicalFastString

Defined in GHC.Data.FastString

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LexicalFastString -> c LexicalFastString

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LexicalFastString

toConstr :: LexicalFastString -> Constr

dataTypeOf :: LexicalFastString -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LexicalFastString)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LexicalFastString)

gmapT :: (forall b. Data b => b -> b) -> LexicalFastString -> LexicalFastString

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFastString -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFastString -> r

gmapQ :: (forall d. Data d => d -> u) -> LexicalFastString -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LexicalFastString -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LexicalFastString -> m LexicalFastString

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LexicalFastString -> m LexicalFastString

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LexicalFastString -> m LexicalFastString

Show LexicalFastString

Defined in GHC.Data.FastString

Methods

showsPrec :: Int -> LexicalFastString -> ShowS

show :: LexicalFastString -> String

showList :: [LexicalFastString] -> ShowS

Outputable LexicalFastString

Defined in GHC.Utils.Outputable

Methods

ppr :: LexicalFastString -> SDoc

Eq LexicalFastString

Defined in GHC.Data.FastString

Methods

(==) :: LexicalFastString -> LexicalFastString -> Bool

(/=) :: LexicalFastString -> LexicalFastString -> Bool

Ord LexicalFastString

Defined in GHC.Data.FastString

Methods

compare :: LexicalFastString -> LexicalFastString -> Ordering

(<) :: LexicalFastString -> LexicalFastString -> Bool

(<=) :: LexicalFastString -> LexicalFastString -> Bool

(>) :: LexicalFastString -> LexicalFastString -> Bool

(>=) :: LexicalFastString -> LexicalFastString -> Bool

max :: LexicalFastString -> LexicalFastString -> LexicalFastString

min :: LexicalFastString -> LexicalFastString -> LexicalFastString

data FastZString

Instances

NFData FastZString

Defined in GHC.Data.FastString

Methods

rnf :: FastZString -> ()

data FastString

A FastString is a UTF-8 encoded string together with a unique ID. All FastStrings are stored in a global hashtable to support fast O(1) comparison.

It is also associated with a lazy reference to the Z-encoding of this string which is used by the compiler internally.

Constructors

FastString

Fields

• uniq :: !Int
• n_chars :: !Int
• fs_sbs :: !ShortByteString
• fs_zenc :: FastZString

  Lazily computed Z-encoding of this string. See Note [Z-Encoding] in GHC.Utils.Encoding.

  Since FastStrings are globally memoized this is computed at most once for any given string.

Instances

Data FastString

Defined in GHC.Data.FastString

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FastString -> c FastString

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FastString

toConstr :: FastString -> Constr

dataTypeOf :: FastString -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FastString)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FastString)

gmapT :: (forall b. Data b => b -> b) -> FastString -> FastString

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FastString -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FastString -> r

gmapQ :: (forall d. Data d => d -> u) -> FastString -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FastString -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FastString -> m FastString

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FastString -> m FastString

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FastString -> m FastString

IsString FastString

Defined in GHC.Data.FastString

Methods

fromString :: String -> FastString

Monoid FastString

Defined in GHC.Data.FastString

Methods

mempty :: FastString

mappend :: FastString -> FastString -> FastString

mconcat :: [FastString] -> FastString

Semigroup FastString

Defined in GHC.Data.FastString

Methods

(<>) :: FastString -> FastString -> FastString

sconcat :: NonEmpty FastString -> FastString

stimes :: Integral b => b -> FastString -> FastString

Show FastString

Defined in GHC.Data.FastString

Methods

showsPrec :: Int -> FastString -> ShowS

show :: FastString -> String

showList :: [FastString] -> ShowS

NFData FastString

Defined in GHC.Data.FastString

Methods

rnf :: FastString -> ()

Uniquable FastString

Defined in GHC.Types.Unique

Methods

getUnique :: FastString -> Unique

Outputable FastString

Defined in GHC.Utils.Outputable

Methods

ppr :: FastString -> SDoc

Eq FastString

Defined in GHC.Data.FastString

Methods

(==) :: FastString -> FastString -> Bool

(/=) :: FastString -> FastString -> Bool

type Anno (SourceText, RuleName)

Defined in GHC.Hs.Decls

type Anno (SourceText, RuleName) = SrcSpan

type Anno (SourceText, RuleName)

Defined in GHC.Hs.Decls

type Anno (SourceText, RuleName) = SrcSpan

zString :: FastZString -> String

zEncodeFS :: FastString -> FastZString

Returns a Z-encoded version of a FastString. This might be the original, if it was already Z-encoded. The first time this function is applied to a particular FastString, the results are memoized.

unsafeMkByteString :: String -> ByteString

unpackPtrString :: PtrString -> String

Decode a PtrString back into a String using Latin-1 encoding. This does not free the memory associated with PtrString.

unpackFS :: FastString -> String

Unpacks and decodes the FastString

uniqueOfFS :: FastString -> Int

uniqCompareFS :: FastString -> FastString -> Ordering

Compare FastString by their Unique (not lexically).

Much cheaper than lexicalCompareFS but non-deterministic!

unconsFS :: FastString -> Maybe (Char, FastString)

sLit :: String -> PtrString

nullFS :: FastString -> Bool

Returns True if the FastString is empty

nilFS :: FastString

mkPtrString# :: Addr# -> PtrString

Wrap an unboxed address into a PtrString.

mkPtrString :: String -> PtrString

Encode a String into a newly allocated PtrString using Latin-1 encoding. The original string must not contain non-Latin-1 characters (above codepoint 0xff).

mkFastStringShortByteString :: ShortByteString -> FastString

Create a FastString from an existing ShortByteString without copying.

mkFastStringBytes :: Ptr Word8 -> Int -> FastString

mkFastStringByteString :: ByteString -> FastString

Create a FastString by copying an existing ByteString

mkFastStringByteList :: [Word8] -> FastString

Creates a FastString from a UTF-8 encoded [Word8]

mkFastString# :: Addr# -> FastString

mkFastString :: String -> FastString

Creates a UTF-8 encoded FastString from a String

lexicalCompareFS :: FastString -> FastString -> Ordering

Compare FastString lexically

If you don't care about the lexical ordering, use uniqCompareFS instead.

lengthPS :: PtrString -> Int

Return the length of a PtrString

lengthFZS :: FastZString -> Int

lengthFS :: FastString -> Int

Returns the length of the FastString in characters

isUnderscoreFS :: FastString -> Bool

headFS :: FastString -> Char

hPutFZS :: Handle -> FastZString -> IO ()

hPutFS :: Handle -> FastString -> IO ()

Outputs a FastString with no decoding at all, that is, you get the actual bytes in the FastString written to the Handle.

getFastStringZEncCounter :: IO Int

getFastStringTable :: IO [[[FastString]]]

fsLit :: String -> FastString

fastZStringToByteString :: FastZString -> ByteString

fastStringToShortByteString :: FastString -> ShortByteString

fastStringToByteString :: FastString -> ByteString

Gives the Modified UTF-8 encoded bytes corresponding to a FastString

consFS :: Char -> FastString -> FastString

concatFS :: [FastString] -> FastString

bytesFS :: FastString -> ByteString

Gives the Modified UTF-8 encoded bytes corresponding to a FastString

appendFS :: FastString -> FastString -> FastString

data SDocContext

Constructors

SDC

Fields

• sdocStyle :: !PprStyle
• sdocColScheme :: !Scheme
• sdocLastColour :: !PprColour

  The most recently used colour. This allows nesting colours.

• sdocShouldUseColor :: !Bool
• sdocDefaultDepth :: !Int
• sdocLineLength :: !Int
• sdocCanUseUnicode :: !Bool

  True if Unicode encoding is supported and not disable by GHC_NO_UNICODE environment variable

• sdocHexWordLiterals :: !Bool
• sdocPprDebug :: !Bool
• sdocPrintUnicodeSyntax :: !Bool
• sdocPrintCaseAsLet :: !Bool
• sdocPrintTypecheckerElaboration :: !Bool
• sdocPrintAxiomIncomps :: !Bool
• sdocPrintExplicitKinds :: !Bool
• sdocPrintExplicitCoercions :: !Bool
• sdocPrintExplicitRuntimeReps :: !Bool
• sdocPrintExplicitForalls :: !Bool
• sdocPrintPotentialInstances :: !Bool
• sdocPrintEqualityRelations :: !Bool
• sdocSuppressTicks :: !Bool
• sdocSuppressTypeSignatures :: !Bool
• sdocSuppressTypeApplications :: !Bool
• sdocSuppressIdInfo :: !Bool
• sdocSuppressCoercions :: !Bool
• sdocSuppressUnfoldings :: !Bool
• sdocSuppressVarKinds :: !Bool
• sdocSuppressUniques :: !Bool
• sdocSuppressModulePrefixes :: !Bool
• sdocSuppressStgExts :: !Bool
• sdocErrorSpans :: !Bool
• sdocStarIsType :: !Bool
• sdocLinearTypes :: !Bool
• sdocImpredicativeTypes :: !Bool
• sdocPrintTypeAbbreviations :: !Bool
• sdocUnitIdForUser :: !(FastString -> SDoc)

  Used to map UnitIds to more friendly "package-version:component" strings while pretty-printing.

  Use pprWithUnitState to set it. Users should never have to set it to pretty-print SDocs emitted by GHC, otherwise it's a bug. It's an internal field used to thread the UnitState so that the Outputable instance of UnitId can use it.

  See Note [Pretty-printing UnitId] in GHC.Unit for more details.

  Note that we use FastString instead of UnitId to avoid boring module inter-dependency issues.

data SDoc

Represents a pretty-printable document.

To display an SDoc, use printSDoc, printSDocLn, bufLeftRenderSDoc, or renderWithContext. Avoid calling runSDoc directly as it breaks the abstraction layer.

Instances

IsString SDoc

Defined in GHC.Utils.Outputable

Methods

fromString :: String -> SDoc

Outputable SDoc

Defined in GHC.Utils.Outputable

Methods

ppr :: SDoc -> SDoc

OutputableP env SDoc

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> SDoc -> SDoc

data PprStyle

Constructors

PprUser PrintUnqualified Depth Coloured

PprDump PrintUnqualified

PprCode LabelStyle

Print code; either C or assembler

Instances

Outputable PprStyle

Defined in GHC.Utils.Outputable

Methods

ppr :: PprStyle -> SDoc

text :: String -> SDoc

zipWithAndUnzipM :: Monad m => (a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])

zipWith4M :: Monad m => (a -> b -> c -> d -> m e) -> [a] -> [b] -> [c] -> [d] -> m [e]

zipWith3M_ :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m ()

zipWith3M :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m [d]

whenM :: Monad m => m Bool -> m () -> m ()

Monadic version of when, taking the condition in the monad

unlessM :: Monad m => m Bool -> m () -> m ()

Monadic version of unless, taking the condition in the monad

orM :: Monad m => m Bool -> m Bool -> m Bool

Monadic version of or

maybeMapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)

Monadic version of fmap specialised for Maybe

mapSndM :: Monad m => (b -> m c) -> [(a, b)] -> m [(a, c)]

Monadic version of mapSnd

mapMaybeM :: Applicative m => (a -> m (Maybe b)) -> [a] -> m [b]

Applicative version of mapMaybe

mapAndUnzip5M :: Monad m => (a -> m (b, c, d, e, f)) -> [a] -> m ([b], [c], [d], [e], [f])

mapAndUnzip4M :: Monad m => (a -> m (b, c, d, e)) -> [a] -> m ([b], [c], [d], [e])

mapAndUnzip3M :: Monad m => (a -> m (b, c, d)) -> [a] -> m ([b], [c], [d])

mapAndUnzipM for triples

mapAccumLM

Arguments

:: Monad m

=> (acc -> x -> m (acc, y))

combining function

-> acc

initial state

-> [x]

inputs

-> m (acc, [y])

final state, outputs

Monadic version of mapAccumL

liftSndM :: Monad m => (a -> b) -> m (r, a) -> m (r, b)

liftFstM :: Monad m => (a -> b) -> m (a, r) -> m (b, r)

foldlM_ :: (Monad m, Foldable t) => (a -> b -> m a) -> a -> t b -> m ()

Monadic version of foldl that discards its result

fmapMaybeM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)

Monadic version of fmap

fmapEitherM :: Monad m => (a -> m b) -> (c -> m d) -> Either a c -> m (Either b d)

Monadic version of fmap

filterOutM :: Applicative m => (a -> m Bool) -> [a] -> m [a]

Like filterM, only it reverses the sense of the test.

concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]

Monadic version of concatMap

anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool

Monadic version of any, aborts the computation at the first True value

allM :: Monad m => (a -> m Bool) -> [a] -> m Bool

Monad version of all, aborts the computation at the first False value

data ModuleName

A ModuleName is essentially a simple string, e.g. Data.List.

Instances

Data ModuleName

Defined in GHC.Unit.Module.Name

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName -> c ModuleName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleName

toConstr :: ModuleName -> Constr

dataTypeOf :: ModuleName -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleName)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName)

gmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r

gmapQ :: (forall d. Data d => d -> u) -> ModuleName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName

Show ModuleName

Defined in GHC.Unit.Module.Name

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

NFData ModuleName

Defined in GHC.Unit.Module.Name

Methods

rnf :: ModuleName -> ()

Uniquable ModuleName

Defined in GHC.Unit.Module.Name

Methods

getUnique :: ModuleName -> Unique

Binary ModuleName

Defined in GHC.Unit.Module.Name

Methods

put_ :: BinHandle -> ModuleName -> IO ()

put :: BinHandle -> ModuleName -> IO (Bin ModuleName)

get :: BinHandle -> IO ModuleName

Outputable ModuleName

Defined in GHC.Unit.Module.Name

Methods

ppr :: ModuleName -> SDoc

Eq ModuleName

Defined in GHC.Unit.Module.Name

Methods

(==) :: ModuleName -> ModuleName -> Bool

(/=) :: ModuleName -> ModuleName -> Bool

Ord ModuleName

Defined in GHC.Unit.Module.Name

Methods

compare :: ModuleName -> ModuleName -> Ordering

(<) :: ModuleName -> ModuleName -> Bool

(<=) :: ModuleName -> ModuleName -> Bool

(>) :: ModuleName -> ModuleName -> Bool

(>=) :: ModuleName -> ModuleName -> Bool

max :: ModuleName -> ModuleName -> ModuleName

min :: ModuleName -> ModuleName -> ModuleName

type Anno ModuleName

Defined in GHC.Hs.ImpExp

type Anno ModuleName = SrcSpanAnnA

data StaticPlugin

A static plugin with its arguments. For registering compiled-in plugins through the GHC API.

Constructors

StaticPlugin

Fields

• spPlugin :: PluginWithArgs

  the actual plugin together with its commandline arguments

data LoadedPlugin

A plugin with its arguments. The result of loading the plugin.

Constructors

LoadedPlugin

Fields

• lpPlugin :: PluginWithArgs

  the actual plugin together with its commandline arguments

• lpModule :: ModIface

  the module containing the plugin

data ForeignSrcLang

Foreign formats supported by GHC via TH

Constructors

LangC

C

LangCxx

C++

LangObjc

Objective C

LangObjcxx

Objective C++

LangAsm

Assembly language (.s)

RawObject

Object (.o)

Instances

Generic ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type

Methods

from :: ForeignSrcLang -> Rep ForeignSrcLang x

to :: Rep ForeignSrcLang x -> ForeignSrcLang

Show ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

showsPrec :: Int -> ForeignSrcLang -> ShowS

show :: ForeignSrcLang -> String

showList :: [ForeignSrcLang] -> ShowS

Eq ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

(==) :: ForeignSrcLang -> ForeignSrcLang -> Bool

(/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool

type Rep ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

type Rep ForeignSrcLang = D1 ('MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-9.2.4" 'False) ((C1 ('MetaCons "LangC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangCxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LangObjc" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "LangObjcxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangAsm" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RawObject" 'PrefixI 'False) (U1 :: Type -> Type))))

liftedRepName :: Name

type LexicalFastString' = LexicalFastString

mkLexicalFastString :: FastString -> LexicalFastString'

fromLexicalFastString :: LexicalFastString' -> FastString

collectHsBindBinders' :: HsBindLR GhcRn idR -> [Name]

collectPatBinders' :: LPat GhcRn -> [Name]

noLocA' :: a -> LocatedAn an a

locA' :: SrcSpanAnn' ann -> SrcSpan

mkWildValBinder' :: Type -> Id

pprTypeForUser' :: Type -> SDoc

showSDocOneLine' :: SDoc -> String

findImportedModule' :: ModuleName -> TcPluginM FindResult

findPluginModule' :: ModuleName -> TcM FindResult

pattern HsLet' :: XLet GhcRn -> LetToken -> Located (HsLocalBinds GhcRn) -> InToken -> LHsExpr GhcRn -> HsExpr GhcRn

pattern LetStmt' :: XLetStmt GhcRn GhcRn body -> Located (HsLocalBinds GhcRn) -> StmtLR GhcRn GhcRn body

pattern ExplicitList' :: XExplicitList p -> [LHsExpr p] -> HsExpr p

pattern BindStmt' :: XBindStmt GhcRn GhcRn body -> LPat GhcRn -> body -> SyntaxExpr GhcRn -> SyntaxExpr GhcRn -> Stmt GhcRn body

pattern OverLit' :: OverLitVal -> HsOverLit GhcRn