Desugared data types

Methods

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

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

toConstr :: DExp -> Constr Source #

dataTypeOf :: DExp -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DExp Source #

Instance details

Associated Types

type Rep DExp

Instance details

Methods

from :: DExp -> Rep DExp x Source #

to :: Rep DExp x -> DExp Source #

Show DExp Source #

Instance details

Methods

showsPrec :: Int -> DExp -> ShowS Source #

show :: DExp -> String Source #

showList :: [DExp] -> ShowS Source #

Eq DExp Source #

Instance details

Methods

(==) :: DExp -> DExp -> Bool Source #

(/=) :: DExp -> DExp -> Bool Source #

Lift DExp Source #

Instance details

Methods

lift :: Quote m => DExp -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DExp -> Code m DExp Source #

Desugar Exp DExp Source #

Instance details

Methods

desugar :: DsMonad q => Exp -> q DExp Source #

sweeten :: DExp -> Exp Source #

type Rep DExp Source #

Instance details

data DLetDec Source #

Declarations as used in a let statement.

Constructors

DFunD Name [DClause]
DValD DPat DExp
DSigD Name DType
DInfixD Fixity NamespaceSpecifier Name
DPragmaD DPragma

Instances

Instances details

Data DLetDec Source #

Instance details

Methods

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

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

toConstr :: DLetDec -> Constr Source #

dataTypeOf :: DLetDec -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DLetDec Source #

Instance details

Associated Types

type Rep DLetDec

Instance details

Methods

from :: DLetDec -> Rep DLetDec x Source #

to :: Rep DLetDec x -> DLetDec Source #

Show DLetDec Source #

Instance details

Methods

showsPrec :: Int -> DLetDec -> ShowS Source #

show :: DLetDec -> String Source #

showList :: [DLetDec] -> ShowS Source #

Eq DLetDec Source #

Instance details

Methods

(==) :: DLetDec -> DLetDec -> Bool Source #

(/=) :: DLetDec -> DLetDec -> Bool Source #

Lift DLetDec Source #

Instance details

Methods

lift :: Quote m => DLetDec -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DLetDec -> Code m DLetDec Source #

type Rep DLetDec Source #

Instance details

data NamespaceSpecifier Source #

A way to specify a namespace to look in when GHC needs to find a name's source

Constructors

NoNamespaceSpecifier	Name may be everything; If there are two names in different namespaces, then consider both
TypeNamespaceSpecifier	Name should be a type-level entity, such as a data type, type alias, type family, type class, or type variable
DataNamespaceSpecifier	Name should be a term-level entity, such as a function, data constructor, or pattern synonym

Instances

Instances details

Data NamespaceSpecifier

Instance details

Generic NamespaceSpecifier

Methods

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

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

toConstr :: NamespaceSpecifier -> Constr Source #

dataTypeOf :: NamespaceSpecifier -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Instance details

Associated Types

type Rep NamespaceSpecifier

Instance details

type Rep NamespaceSpecifier = D1 ('MetaData "NamespaceSpecifier" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DataNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type)))

Methods

from :: NamespaceSpecifier -> Rep NamespaceSpecifier x Source #

to :: Rep NamespaceSpecifier x -> NamespaceSpecifier Source #

Show NamespaceSpecifier

Instance details

Methods

showsPrec :: Int -> NamespaceSpecifier -> ShowS Source #

show :: NamespaceSpecifier -> String Source #

showList :: [NamespaceSpecifier] -> ShowS Source #

Eq NamespaceSpecifier

Instance details

Methods

(==) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source #

(/=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source #

Ord NamespaceSpecifier

Instance details

Methods

compare :: NamespaceSpecifier -> NamespaceSpecifier -> Ordering Source #

(<) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source #

(<=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source #

(>) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source #

(>=) :: NamespaceSpecifier -> NamespaceSpecifier -> Bool Source #

max :: NamespaceSpecifier -> NamespaceSpecifier -> NamespaceSpecifier Source #

min :: NamespaceSpecifier -> NamespaceSpecifier -> NamespaceSpecifier Source #

Lift NamespaceSpecifier

Instance details

Methods

lift :: Quote m => NamespaceSpecifier -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => NamespaceSpecifier -> Code m NamespaceSpecifier Source #

type Rep NamespaceSpecifier

Instance details

type Rep NamespaceSpecifier = D1 ('MetaData "NamespaceSpecifier" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DataNamespaceSpecifier" 'PrefixI 'False) (U1 :: Type -> Type)))

data DPat Source #

Corresponds to TH's Pat type.

Constructors

DLitP Lit
DVarP Name
DConP Name [DType] [DPat]
DTildeP DPat
DBangP DPat
DSigP DPat DType
DWildP
DTypeP DType	Note that `th-desugar` only has partial support for desugaring embedded type patterns. In particular, `th-desugar` supports desugaring embedded type patterns in function clauses, but not in lambda expressions, `\case` expressions, or `\cases` expressions. See the "Known limitations" section of the `th-desugar` `README` for more details.
DInvisP DType	Note that `th-desugar` only has partial support for desugaring invisible type patterns. In particular, `th-desugar` supports desugaring invisible type patterns in function clauses, but not in lambda expressions or `\cases` expressions. See the "Known limitations" section of the `th-desugar` `README` for more details.

Instances

Instances details

Data DPat Source #

Instance details

Methods

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

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

toConstr :: DPat -> Constr Source #

dataTypeOf :: DPat -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DPat Source #

Instance details

Associated Types

type Rep DPat

Instance details

Methods

from :: DPat -> Rep DPat x Source #

to :: Rep DPat x -> DPat Source #

Show DPat Source #

Instance details

Methods

showsPrec :: Int -> DPat -> ShowS Source #

show :: DPat -> String Source #

showList :: [DPat] -> ShowS Source #

Eq DPat Source #

Instance details

Methods

(==) :: DPat -> DPat -> Bool Source #

(/=) :: DPat -> DPat -> Bool Source #

Lift DPat Source #

Instance details

Methods

lift :: Quote m => DPat -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DPat -> Code m DPat Source #

type Rep DPat Source #

Instance details

data DType Source #

Corresponds to TH's Type type, used to represent types and kinds.

Constructors

DForallT DForallTelescope DType
DConstrainedT DCxt DType
DAppT DType DType
DAppKindT DType DKind
DSigT DType DKind
DVarT Name
DConT Name
DArrowT
DLitT TyLit
DWildCardT

Instances

Instances details

Data DType Source #

Instance details

Methods

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

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

toConstr :: DType -> Constr Source #

dataTypeOf :: DType -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DType Source #

Instance details

Associated Types

type Rep DType

Instance details

Methods

from :: DType -> Rep DType x Source #

to :: Rep DType x -> DType Source #

Show DType Source #

Instance details

Methods

showsPrec :: Int -> DType -> ShowS Source #

show :: DType -> String Source #

showList :: [DType] -> ShowS Source #

Eq DType Source #

Instance details

Methods

(==) :: DType -> DType -> Bool Source #

(/=) :: DType -> DType -> Bool Source #

Lift DType Source #

Instance details

Methods

lift :: Quote m => DType -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DType -> Code m DType Source #

Desugar Cxt DCxt Source #

Instance details

Methods

desugar :: DsMonad q => Cxt -> q DCxt Source #

sweeten :: DCxt -> Cxt Source #

Desugar Type DType Source #

Instance details

Methods

desugar :: DsMonad q => Type -> q DType Source #

sweeten :: DType -> Type Source #

type Rep DType Source #

Instance details

data DForallTelescope Source #

The type variable binders in a forall.

Constructors

DForallVis [DTyVarBndrUnit]	A visible `forall` (e.g., `forall a -> {...}`). These do not have any notion of specificity, so we use `()` as a placeholder value in the `DTyVarBndr`s.
DForallInvis [DTyVarBndrSpec]	An invisible `forall` (e.g., `forall a {b} c -> {...}`), where each binder has a `Specificity`.

Instances

Instances details

Data DForallTelescope Source #

Instance details

Methods

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

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

toConstr :: DForallTelescope -> Constr Source #

dataTypeOf :: DForallTelescope -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DForallTelescope Source #

Instance details

Associated Types

type Rep DForallTelescope

Instance details

type Rep DForallTelescope = D1 ('MetaData "DForallTelescope" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DForallVis" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrUnit])) :+: C1 ('MetaCons "DForallInvis" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrSpec])))

Methods

from :: DForallTelescope -> Rep DForallTelescope x Source #

to :: Rep DForallTelescope x -> DForallTelescope Source #

Show DForallTelescope Source #

Instance details

Methods

showsPrec :: Int -> DForallTelescope -> ShowS Source #

show :: DForallTelescope -> String Source #

showList :: [DForallTelescope] -> ShowS Source #

Eq DForallTelescope Source #

Instance details

Methods

(==) :: DForallTelescope -> DForallTelescope -> Bool Source #

(/=) :: DForallTelescope -> DForallTelescope -> Bool Source #

Lift DForallTelescope Source #

Instance details

Methods

lift :: Quote m => DForallTelescope -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DForallTelescope -> Code m DForallTelescope Source #

type Rep DForallTelescope Source #

Instance details

type Rep DForallTelescope = D1 ('MetaData "DForallTelescope" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DForallVis" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrUnit])) :+: C1 ('MetaCons "DForallInvis" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrSpec])))

type DKind = DType Source #

Kinds are types. Corresponds to TH's Kind

type DCxt = [DPred] Source #

Corresponds to TH's Cxt

type DPred = DType Source #

Predicates are types. Corresponds to TH's Pred

data DTyVarBndr flag Source #

Corresponds to TH's TyVarBndr

Constructors

DPlainTV Name flag
DKindedTV Name flag DKind

Instances

Instances details

Functor DTyVarBndr Source #

Instance details

Methods

fmap :: (a -> b) -> DTyVarBndr a -> DTyVarBndr b Source #

(<$) :: a -> DTyVarBndr b -> DTyVarBndr a Source #

Foldable DTyVarBndr Source #

Instance details

Methods

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

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

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

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

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

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

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

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

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

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

null :: DTyVarBndr a -> Bool Source #

length :: DTyVarBndr a -> Int Source #

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

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

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

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

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

Traversable DTyVarBndr Source #

Instance details

Methods

traverse :: Applicative f => (a -> f b) -> DTyVarBndr a -> f (DTyVarBndr b) Source #

sequenceA :: Applicative f => DTyVarBndr (f a) -> f (DTyVarBndr a) Source #

mapM :: Monad m => (a -> m b) -> DTyVarBndr a -> m (DTyVarBndr b) Source #

sequence :: Monad m => DTyVarBndr (m a) -> m (DTyVarBndr a) Source #

Lift flag => Lift (DTyVarBndr flag :: Type) Source #

Instance details

Methods

lift :: Quote m => DTyVarBndr flag -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DTyVarBndr flag -> Code m (DTyVarBndr flag) Source #

Data flag => Data (DTyVarBndr flag) Source #

Instance details

Methods

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

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

toConstr :: DTyVarBndr flag -> Constr Source #

dataTypeOf :: DTyVarBndr flag -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic (DTyVarBndr flag) Source #

Instance details

Associated Types

type Rep (DTyVarBndr flag)

Instance details

type Rep (DTyVarBndr flag) = D1 ('MetaData "DTyVarBndr" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DPlainTV" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 flag)) :+: C1 ('MetaCons "DKindedTV" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 flag) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DKind))))

Methods

from :: DTyVarBndr flag -> Rep (DTyVarBndr flag) x Source #

to :: Rep (DTyVarBndr flag) x -> DTyVarBndr flag Source #

Show flag => Show (DTyVarBndr flag) Source #

Instance details

Methods

showsPrec :: Int -> DTyVarBndr flag -> ShowS Source #

show :: DTyVarBndr flag -> String Source #

showList :: [DTyVarBndr flag] -> ShowS Source #

Eq flag => Eq (DTyVarBndr flag) Source #

Instance details

Methods

(==) :: DTyVarBndr flag -> DTyVarBndr flag -> Bool Source #

(/=) :: DTyVarBndr flag -> DTyVarBndr flag -> Bool Source #

Desugar (TyVarBndr flag) (DTyVarBndr flag) Source #

This instance is only flag-polymorphic on GHC 9.0 or later, since previous versions of GHC do not equip TyVarBndr with a flag type parameter. As a result, we define two separate instances for DTyVarBndr on older GHCs:

instance Desugar TyVarBndrSpec DTyVarBndrSpec
instance Desugar TyVarBndrUnit DTyVarBndrUnit

Instance details

Methods

desugar :: DsMonad q => TyVarBndr flag -> q (DTyVarBndr flag) Source #

sweeten :: DTyVarBndr flag -> TyVarBndr flag Source #

type Rep (DTyVarBndr flag) Source #

Instance details

type Rep (DTyVarBndr flag) = D1 ('MetaData "DTyVarBndr" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DPlainTV" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 flag)) :+: C1 ('MetaCons "DKindedTV" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 flag) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DKind))))

type DTyVarBndrSpec = DTyVarBndr Specificity Source #

Corresponds to TH's TyVarBndrSpec

type DTyVarBndrUnit = DTyVarBndr () Source #

Corresponds to TH's TyVarBndrUnit

data Specificity Source #

Constructors

SpecifiedSpec	a
InferredSpec	{a}

Instances

Instances details

Data Specificity

Instance details

Methods

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

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

toConstr :: Specificity -> Constr Source #

dataTypeOf :: Specificity -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic Specificity

Instance details

Associated Types

type Rep Specificity
Instance details Defined in Language.Haskell.TH.Syntax type Rep Specificity = D1 ('MetaData "Specificity" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "SpecifiedSpec" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InferredSpec" 'PrefixI 'False) (U1 :: Type -> Type))

Methods

from :: Specificity -> Rep Specificity x Source #

to :: Rep Specificity x -> Specificity Source #

Show Specificity

Instance details

Methods

showsPrec :: Int -> Specificity -> ShowS Source #

show :: Specificity -> String Source #

showList :: [Specificity] -> ShowS Source #

Eq Specificity

Instance details

Methods

(==) :: Specificity -> Specificity -> Bool Source #

(/=) :: Specificity -> Specificity -> Bool Source #

Ord Specificity

Instance details

DefaultBndrFlag Specificity

Methods

compare :: Specificity -> Specificity -> Ordering Source #

(<) :: Specificity -> Specificity -> Bool Source #

(<=) :: Specificity -> Specificity -> Bool Source #

(>) :: Specificity -> Specificity -> Bool Source #

(>=) :: Specificity -> Specificity -> Bool Source #

max :: Specificity -> Specificity -> Specificity Source #

min :: Specificity -> Specificity -> Specificity Source #

Instance details

Defined in Language.Haskell.TH.Lib

Methods

defaultBndrFlag :: Specificity Source #

PprFlag Specificity

Instance details

Defined in Language.Haskell.TH.Ppr

Methods

pprTyVarBndr :: TyVarBndr Specificity -> Doc Source #

Lift Specificity

Instance details

Methods

lift :: Quote m => Specificity -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => Specificity -> Code m Specificity Source #

type Rep Specificity

Instance details

type Rep Specificity = D1 ('MetaData "Specificity" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "SpecifiedSpec" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InferredSpec" 'PrefixI 'False) (U1 :: Type -> Type))

type DTyVarBndrVis = DTyVarBndr BndrVis Source #

Corresponds to TH's TyVarBndrVis

data BndrVis Source #

Constructors

BndrReq	a
BndrInvis	@a

Instances

Instances details

Data BndrVis

Instance details

Methods

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

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

toConstr :: BndrVis -> Constr Source #

dataTypeOf :: BndrVis -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic BndrVis

Instance details

Associated Types

type Rep BndrVis
Instance details Defined in Language.Haskell.TH.Syntax type Rep BndrVis = D1 ('MetaData "BndrVis" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "BndrReq" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BndrInvis" 'PrefixI 'False) (U1 :: Type -> Type))

Methods

from :: BndrVis -> Rep BndrVis x Source #

to :: Rep BndrVis x -> BndrVis Source #

Show BndrVis

Instance details

Methods

showsPrec :: Int -> BndrVis -> ShowS Source #

show :: BndrVis -> String Source #

showList :: [BndrVis] -> ShowS Source #

Eq BndrVis

Instance details

Methods

(==) :: BndrVis -> BndrVis -> Bool Source #

(/=) :: BndrVis -> BndrVis -> Bool Source #

Ord BndrVis

Instance details

Methods

compare :: BndrVis -> BndrVis -> Ordering Source #

(<) :: BndrVis -> BndrVis -> Bool Source #

(<=) :: BndrVis -> BndrVis -> Bool Source #

(>) :: BndrVis -> BndrVis -> Bool Source #

(>=) :: BndrVis -> BndrVis -> Bool Source #

max :: BndrVis -> BndrVis -> BndrVis Source #

min :: BndrVis -> BndrVis -> BndrVis Source #

DefaultBndrFlag BndrVis

Instance details

Defined in Language.Haskell.TH.Lib

Methods

defaultBndrFlag :: BndrVis Source #

PprFlag BndrVis

Instance details

Defined in Language.Haskell.TH.Ppr

Methods

pprTyVarBndr :: TyVarBndr BndrVis -> Doc Source #

Lift BndrVis

Instance details

Methods

lift :: Quote m => BndrVis -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => BndrVis -> Code m BndrVis Source #

type Rep BndrVis

Instance details

type Rep BndrVis = D1 ('MetaData "BndrVis" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "BndrReq" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BndrInvis" 'PrefixI 'False) (U1 :: Type -> Type))

data DMatch Source #

Corresponds to TH's Match type.

Constructors

DMatch DPat DExp

Instances

Instances details

Data DMatch Source #

Instance details

Methods

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

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

toConstr :: DMatch -> Constr Source #

dataTypeOf :: DMatch -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DMatch Source #

Instance details

Associated Types

type Rep DMatch

Instance details

type Rep DMatch = D1 ('MetaData "DMatch" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DMatch" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DPat) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DExp)))

Methods

from :: DMatch -> Rep DMatch x Source #

to :: Rep DMatch x -> DMatch Source #

Show DMatch Source #

Instance details

Methods

showsPrec :: Int -> DMatch -> ShowS Source #

show :: DMatch -> String Source #

showList :: [DMatch] -> ShowS Source #

Eq DMatch Source #

Instance details

Methods

(==) :: DMatch -> DMatch -> Bool Source #

(/=) :: DMatch -> DMatch -> Bool Source #

Lift DMatch Source #

Instance details

Methods

lift :: Quote m => DMatch -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DMatch -> Code m DMatch Source #

type Rep DMatch Source #

Instance details

type Rep DMatch = D1 ('MetaData "DMatch" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DMatch" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DPat) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DExp)))

data DClause Source #

Corresponds to TH's Clause type.

Constructors

DClause [DPat] DExp

Instances

Instances details

Data DClause Source #

Instance details

Methods

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

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

toConstr :: DClause -> Constr Source #

dataTypeOf :: DClause -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DClause Source #

Instance details

Associated Types

type Rep DClause

Instance details

type Rep DClause = D1 ('MetaData "DClause" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DPat]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DExp)))

Methods

from :: DClause -> Rep DClause x Source #

to :: Rep DClause x -> DClause Source #

Show DClause Source #

Instance details

Methods

showsPrec :: Int -> DClause -> ShowS Source #

show :: DClause -> String Source #

showList :: [DClause] -> ShowS Source #

Eq DClause Source #

Instance details

Methods

(==) :: DClause -> DClause -> Bool Source #

(/=) :: DClause -> DClause -> Bool Source #

Lift DClause Source #

Instance details

Methods

lift :: Quote m => DClause -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DClause -> Code m DClause Source #

type Rep DClause Source #

Instance details

type Rep DClause = D1 ('MetaData "DClause" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DPat]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DExp)))

data DDec Source #

Corresponds to TH's Dec type.

Constructors

DLetDec DLetDec
DDataD DataFlavor DCxt Name [DTyVarBndrVis] (Maybe DKind) [DCon] [DDerivClause]	An ordinary (i.e., non-data family) data type declaration. Note that desugaring upholds the following properties regarding the `DataFlavor` field: If the `DataFlavor` is `NewType`, then there will be exactly one `DCon`. If the `DataFlavor` is `TypeData`, then there will be no `DDerivClause`s, the `DCxt` will be empty, and the `DConFields` in each `DCon` will be a `NormalC` where each `Bang` is equal to `Bang NoSourceUnpackedness NoSourceStrictness`.
DTySynD Name [DTyVarBndrVis] DType
DClassD DCxt Name [DTyVarBndrVis] [FunDep] [DDec]
DInstanceD (Maybe Overlap) (Maybe [DTyVarBndrUnit]) DCxt DType [DDec]	Note that the `Maybe [DTyVarBndrUnit]` field is dropped entirely when sweetened, so it is only useful for functions that directly consume `DDec`s.
DForeignD DForeign
DOpenTypeFamilyD DTypeFamilyHead
DClosedTypeFamilyD DTypeFamilyHead [DTySynEqn]
DDataFamilyD Name [DTyVarBndrVis] (Maybe DKind)
DDataInstD DataFlavor DCxt (Maybe [DTyVarBndrUnit]) DType (Maybe DKind) [DCon] [DDerivClause]	A data family instance declaration. Note that desugaring upholds the following properties regarding the `DataFlavor` field: If the `DataFlavor` is `NewType`, then there will be exactly one `DCon`. The `DataFlavor` will never be `TypeData`, as GHC does not permit combining data families with `type data`.
DTySynInstD DTySynEqn
DRoleAnnotD Name [Role]
DStandaloneDerivD (Maybe DDerivStrategy) (Maybe [DTyVarBndrUnit]) DCxt DType	Note that the `Maybe [DTyVarBndrUnit]` field is dropped entirely when sweetened, so it is only useful for functions that directly consume `DDec`s.
DDefaultSigD Name DType
DPatSynD Name PatSynArgs DPatSynDir DPat
DPatSynSigD Name DPatSynType
DKiSigD Name DKind
DDefaultD [DType]

Instances

Instances details

Data DDec Source #

Instance details

Methods

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

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

toConstr :: DDec -> Constr Source #

dataTypeOf :: DDec -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DDec Source #

Instance details

Associated Types

type Rep DDec

Instance details

Methods

from :: DDec -> Rep DDec x Source #

to :: Rep DDec x -> DDec Source #

Show DDec Source #

Instance details

Methods

showsPrec :: Int -> DDec -> ShowS Source #

show :: DDec -> String Source #

showList :: [DDec] -> ShowS Source #

Eq DDec Source #

Instance details

Methods

(==) :: DDec -> DDec -> Bool Source #

(/=) :: DDec -> DDec -> Bool Source #

Lift DDec Source #

Instance details

Methods

lift :: Quote m => DDec -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DDec -> Code m DDec Source #

Desugar [Dec] [DDec] Source #

Instance details

Methods

desugar :: DsMonad q => [Dec] -> q [DDec] Source #

sweeten :: [DDec] -> [Dec] Source #

type Rep DDec Source #

Instance details

data DDerivClause Source #

Corresponds to TH's DerivClause type.

Constructors

DDerivClause (Maybe DDerivStrategy) DCxt

Instances

Instances details

Data DDerivClause Source #

Instance details

Methods

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

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

toConstr :: DDerivClause -> Constr Source #

dataTypeOf :: DDerivClause -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DDerivClause Source #

Instance details

Associated Types

type Rep DDerivClause

Instance details

type Rep DDerivClause = D1 ('MetaData "DDerivClause" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DDerivClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DDerivStrategy)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DCxt)))

Methods

from :: DDerivClause -> Rep DDerivClause x Source #

to :: Rep DDerivClause x -> DDerivClause Source #

Show DDerivClause Source #

Instance details

Methods

showsPrec :: Int -> DDerivClause -> ShowS Source #

show :: DDerivClause -> String Source #

showList :: [DDerivClause] -> ShowS Source #

Eq DDerivClause Source #

Instance details

Methods

(==) :: DDerivClause -> DDerivClause -> Bool Source #

(/=) :: DDerivClause -> DDerivClause -> Bool Source #

Lift DDerivClause Source #

Instance details

Methods

lift :: Quote m => DDerivClause -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DDerivClause -> Code m DDerivClause Source #

type Rep DDerivClause Source #

Instance details

type Rep DDerivClause = D1 ('MetaData "DDerivClause" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DDerivClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DDerivStrategy)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DCxt)))

data DDerivStrategy Source #

Corresponds to TH's DerivStrategy type.

Constructors

DStockStrategy	A "standard" derived instance
DAnyclassStrategy	-XDeriveAnyClass
DNewtypeStrategy	-XGeneralizedNewtypeDeriving
DViaStrategy DType	-XDerivingVia

Instances

Instances details

Data DDerivStrategy Source #

Instance details

Methods

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

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

toConstr :: DDerivStrategy -> Constr Source #

dataTypeOf :: DDerivStrategy -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DDerivStrategy Source #

Instance details

Associated Types

type Rep DDerivStrategy

Instance details

type Rep DDerivStrategy = D1 ('MetaData "DDerivStrategy" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) ((C1 ('MetaCons "DStockStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DAnyclassStrategy" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DNewtypeStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DViaStrategy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType))))

Methods

from :: DDerivStrategy -> Rep DDerivStrategy x Source #

to :: Rep DDerivStrategy x -> DDerivStrategy Source #

Show DDerivStrategy Source #

Instance details

Methods

showsPrec :: Int -> DDerivStrategy -> ShowS Source #

show :: DDerivStrategy -> String Source #

showList :: [DDerivStrategy] -> ShowS Source #

Eq DDerivStrategy Source #

Instance details

Methods

(==) :: DDerivStrategy -> DDerivStrategy -> Bool Source #

(/=) :: DDerivStrategy -> DDerivStrategy -> Bool Source #

Lift DDerivStrategy Source #

Instance details

Methods

lift :: Quote m => DDerivStrategy -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DDerivStrategy -> Code m DDerivStrategy Source #

type Rep DDerivStrategy Source #

Instance details

type Rep DDerivStrategy = D1 ('MetaData "DDerivStrategy" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) ((C1 ('MetaCons "DStockStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DAnyclassStrategy" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DNewtypeStrategy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DViaStrategy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType))))

data DPatSynDir Source #

Corresponds to TH's PatSynDir type

Constructors

DUnidir	pattern P x {<-} p
DImplBidir	pattern P x {=} p
DExplBidir [DClause]	pattern P x {<-} p where P x = e

Instances

Instances details

Data DPatSynDir Source #

Instance details

Methods

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

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

toConstr :: DPatSynDir -> Constr Source #

dataTypeOf :: DPatSynDir -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DPatSynDir Source #

Instance details

Associated Types

type Rep DPatSynDir

Instance details

type Rep DPatSynDir = D1 ('MetaData "DPatSynDir" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DUnidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DImplBidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DExplBidir" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DClause]))))

Methods

from :: DPatSynDir -> Rep DPatSynDir x Source #

to :: Rep DPatSynDir x -> DPatSynDir Source #

Show DPatSynDir Source #

Instance details

Methods

showsPrec :: Int -> DPatSynDir -> ShowS Source #

show :: DPatSynDir -> String Source #

showList :: [DPatSynDir] -> ShowS Source #

Eq DPatSynDir Source #

Instance details

Methods

(==) :: DPatSynDir -> DPatSynDir -> Bool Source #

(/=) :: DPatSynDir -> DPatSynDir -> Bool Source #

Lift DPatSynDir Source #

Instance details

Methods

lift :: Quote m => DPatSynDir -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DPatSynDir -> Code m DPatSynDir Source #

type Rep DPatSynDir Source #

Instance details

type Rep DPatSynDir = D1 ('MetaData "DPatSynDir" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DUnidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DImplBidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DExplBidir" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DClause]))))

type DPatSynType = DType Source #

Corresponds to TH's PatSynType type

data Overlap Source #

Varieties of allowed instance overlap.

Constructors

Overlappable	May be overlapped by more specific instances
Overlapping	May overlap a more general instance
Overlaps	Both `Overlapping` and `Overlappable`
Incoherent	Both `Overlapping` and `Overlappable`, and pick an arbitrary one if multiple choices are available.

Instances

Instances details

Data Overlap

Instance details

Methods

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

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

toConstr :: Overlap -> Constr Source #

dataTypeOf :: Overlap -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic Overlap

Instance details

Associated Types

type Rep Overlap

Instance details

type Rep Overlap = D1 ('MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "Overlappable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Overlapping" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Overlaps" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Incoherent" 'PrefixI 'False) (U1 :: Type -> Type)))

Methods

from :: Overlap -> Rep Overlap x Source #

to :: Rep Overlap x -> Overlap Source #

Show Overlap

Instance details

Methods

showsPrec :: Int -> Overlap -> ShowS Source #

show :: Overlap -> String Source #

showList :: [Overlap] -> ShowS Source #

Eq Overlap

Instance details

Methods

(==) :: Overlap -> Overlap -> Bool Source #

(/=) :: Overlap -> Overlap -> Bool Source #

Ord Overlap

Instance details

Methods

compare :: Overlap -> Overlap -> Ordering Source #

(<) :: Overlap -> Overlap -> Bool Source #

(<=) :: Overlap -> Overlap -> Bool Source #

(>) :: Overlap -> Overlap -> Bool Source #

(>=) :: Overlap -> Overlap -> Bool Source #

max :: Overlap -> Overlap -> Overlap Source #

min :: Overlap -> Overlap -> Overlap Source #

Lift Overlap

Instance details

Methods

lift :: Quote m => Overlap -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => Overlap -> Code m Overlap Source #

type Rep Overlap

Instance details

type Rep Overlap = D1 ('MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "Overlappable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Overlapping" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Overlaps" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Incoherent" 'PrefixI 'False) (U1 :: Type -> Type)))

data PatSynArgs Source #

A pattern synonym's argument type.

Constructors

PrefixPatSyn [Name]	pattern P {x y z} = p
InfixPatSyn Name Name	pattern {x P y} = p
RecordPatSyn [Name]	pattern P { {x,y,z} } = p

Instances

Instances details

Data PatSynArgs

Instance details

Methods

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

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

toConstr :: PatSynArgs -> Constr Source #

dataTypeOf :: PatSynArgs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic PatSynArgs

Instance details

Associated Types

type Rep PatSynArgs

Instance details

type Rep PatSynArgs = D1 ('MetaData "PatSynArgs" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "PrefixPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :+: (C1 ('MetaCons "InfixPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "RecordPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]))))

Methods

from :: PatSynArgs -> Rep PatSynArgs x Source #

to :: Rep PatSynArgs x -> PatSynArgs Source #

Show PatSynArgs

Instance details

Methods

showsPrec :: Int -> PatSynArgs -> ShowS Source #

show :: PatSynArgs -> String Source #

showList :: [PatSynArgs] -> ShowS Source #

Eq PatSynArgs

Instance details

Methods

(==) :: PatSynArgs -> PatSynArgs -> Bool Source #

(/=) :: PatSynArgs -> PatSynArgs -> Bool Source #

Ord PatSynArgs

Instance details

Methods

compare :: PatSynArgs -> PatSynArgs -> Ordering Source #

(<) :: PatSynArgs -> PatSynArgs -> Bool Source #

(<=) :: PatSynArgs -> PatSynArgs -> Bool Source #

(>) :: PatSynArgs -> PatSynArgs -> Bool Source #

(>=) :: PatSynArgs -> PatSynArgs -> Bool Source #

max :: PatSynArgs -> PatSynArgs -> PatSynArgs Source #

min :: PatSynArgs -> PatSynArgs -> PatSynArgs Source #

Ppr PatSynArgs

Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: PatSynArgs -> Doc Source #

ppr_list :: [PatSynArgs] -> Doc Source #

Lift PatSynArgs

Instance details

Methods

lift :: Quote m => PatSynArgs -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => PatSynArgs -> Code m PatSynArgs Source #

type Rep PatSynArgs

Instance details

type Rep PatSynArgs = D1 ('MetaData "PatSynArgs" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "PrefixPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :+: (C1 ('MetaCons "InfixPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "RecordPatSyn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]))))

data DataFlavor Source #

Is a data type or data instance declaration a newtype declaration, a data declaration, or a type data declaration?

Constructors

Newtype	newtype
Data	data
TypeData	type data

Instances

Instances details

Data DataFlavor Source #

Instance details

Methods

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

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

toConstr :: DataFlavor -> Constr Source #

dataTypeOf :: DataFlavor -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DataFlavor Source #

Instance details

Associated Types

type Rep DataFlavor
Instance details Defined in Language.Haskell.TH.Desugar.Util type Rep DataFlavor = D1 ('MetaData "DataFlavor" "Language.Haskell.TH.Desugar.Util" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "Newtype" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Data" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TypeData" 'PrefixI 'False) (U1 :: Type -> Type)))

Methods

from :: DataFlavor -> Rep DataFlavor x Source #

to :: Rep DataFlavor x -> DataFlavor Source #

Show DataFlavor Source #

Instance details

Methods

showsPrec :: Int -> DataFlavor -> ShowS Source #

show :: DataFlavor -> String Source #

showList :: [DataFlavor] -> ShowS Source #

Eq DataFlavor Source #

Instance details

Methods

(==) :: DataFlavor -> DataFlavor -> Bool Source #

(/=) :: DataFlavor -> DataFlavor -> Bool Source #

Lift DataFlavor Source #

Instance details

Methods

lift :: Quote m => DataFlavor -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DataFlavor -> Code m DataFlavor Source #

type Rep DataFlavor Source #

Instance details

type Rep DataFlavor = D1 ('MetaData "DataFlavor" "Language.Haskell.TH.Desugar.Util" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "Newtype" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Data" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TypeData" 'PrefixI 'False) (U1 :: Type -> Type)))

data DTypeFamilyHead Source #

Corresponds to TH's TypeFamilyHead type

Constructors

DTypeFamilyHead Name [DTyVarBndrVis] DFamilyResultSig (Maybe InjectivityAnn)

Instances

Instances details

Data DTypeFamilyHead Source #

Instance details

Methods

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

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

toConstr :: DTypeFamilyHead -> Constr Source #

dataTypeOf :: DTypeFamilyHead -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DTypeFamilyHead Source #

Instance details

Associated Types

type Rep DTypeFamilyHead

Instance details

type Rep DTypeFamilyHead = D1 ('MetaData "DTypeFamilyHead" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DTypeFamilyHead" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrVis])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DFamilyResultSig) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe InjectivityAnn)))))

Methods

from :: DTypeFamilyHead -> Rep DTypeFamilyHead x Source #

to :: Rep DTypeFamilyHead x -> DTypeFamilyHead Source #

Show DTypeFamilyHead Source #

Instance details

Methods

showsPrec :: Int -> DTypeFamilyHead -> ShowS Source #

show :: DTypeFamilyHead -> String Source #

showList :: [DTypeFamilyHead] -> ShowS Source #

Eq DTypeFamilyHead Source #

Instance details

Methods

(==) :: DTypeFamilyHead -> DTypeFamilyHead -> Bool Source #

(/=) :: DTypeFamilyHead -> DTypeFamilyHead -> Bool Source #

Lift DTypeFamilyHead Source #

Instance details

Methods

lift :: Quote m => DTypeFamilyHead -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DTypeFamilyHead -> Code m DTypeFamilyHead Source #

type Rep DTypeFamilyHead Source #

Instance details

type Rep DTypeFamilyHead = D1 ('MetaData "DTypeFamilyHead" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DTypeFamilyHead" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrVis])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DFamilyResultSig) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe InjectivityAnn)))))

data DFamilyResultSig Source #

Corresponds to TH's FamilyResultSig type

Constructors

DNoSig
DKindSig DKind
DTyVarSig DTyVarBndrUnit

Instances

Instances details

Data DFamilyResultSig Source #

Instance details

Methods

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

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

toConstr :: DFamilyResultSig -> Constr Source #

dataTypeOf :: DFamilyResultSig -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DFamilyResultSig Source #

Instance details

Associated Types

type Rep DFamilyResultSig

Instance details

type Rep DFamilyResultSig = D1 ('MetaData "DFamilyResultSig" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DNoSig" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DKindSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DKind)) :+: C1 ('MetaCons "DTyVarSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DTyVarBndrUnit))))

Methods

from :: DFamilyResultSig -> Rep DFamilyResultSig x Source #

to :: Rep DFamilyResultSig x -> DFamilyResultSig Source #

Show DFamilyResultSig Source #

Instance details

Methods

showsPrec :: Int -> DFamilyResultSig -> ShowS Source #

show :: DFamilyResultSig -> String Source #

showList :: [DFamilyResultSig] -> ShowS Source #

Eq DFamilyResultSig Source #

Instance details

Methods

(==) :: DFamilyResultSig -> DFamilyResultSig -> Bool Source #

(/=) :: DFamilyResultSig -> DFamilyResultSig -> Bool Source #

Lift DFamilyResultSig Source #

Instance details

Methods

lift :: Quote m => DFamilyResultSig -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DFamilyResultSig -> Code m DFamilyResultSig Source #

type Rep DFamilyResultSig Source #

Instance details

type Rep DFamilyResultSig = D1 ('MetaData "DFamilyResultSig" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DNoSig" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DKindSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DKind)) :+: C1 ('MetaCons "DTyVarSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DTyVarBndrUnit))))

data InjectivityAnn Source #

Injectivity annotation

Constructors

InjectivityAnn Name [Name]

Instances

Instances details

Data InjectivityAnn

Instance details

Methods

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

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

toConstr :: InjectivityAnn -> Constr Source #

dataTypeOf :: InjectivityAnn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic InjectivityAnn

Instance details

Associated Types

type Rep InjectivityAnn

Instance details

type Rep InjectivityAnn = D1 ('MetaData "InjectivityAnn" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "InjectivityAnn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])))

Methods

from :: InjectivityAnn -> Rep InjectivityAnn x Source #

to :: Rep InjectivityAnn x -> InjectivityAnn Source #

Show InjectivityAnn

Instance details

Methods

showsPrec :: Int -> InjectivityAnn -> ShowS Source #

show :: InjectivityAnn -> String Source #

showList :: [InjectivityAnn] -> ShowS Source #

Eq InjectivityAnn

Instance details

Methods

(==) :: InjectivityAnn -> InjectivityAnn -> Bool Source #

(/=) :: InjectivityAnn -> InjectivityAnn -> Bool Source #

Ord InjectivityAnn

Instance details

Methods

compare :: InjectivityAnn -> InjectivityAnn -> Ordering Source #

(<) :: InjectivityAnn -> InjectivityAnn -> Bool Source #

(<=) :: InjectivityAnn -> InjectivityAnn -> Bool Source #

(>) :: InjectivityAnn -> InjectivityAnn -> Bool Source #

(>=) :: InjectivityAnn -> InjectivityAnn -> Bool Source #

max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn Source #

min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn Source #

Ppr InjectivityAnn

Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: InjectivityAnn -> Doc Source #

ppr_list :: [InjectivityAnn] -> Doc Source #

Lift InjectivityAnn

Instance details

Methods

lift :: Quote m => InjectivityAnn -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => InjectivityAnn -> Code m InjectivityAnn Source #

type Rep InjectivityAnn

Instance details

type Rep InjectivityAnn = D1 ('MetaData "InjectivityAnn" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "InjectivityAnn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])))

data DCon Source #

Corresponds to TH's Con type. Unlike Con, all DCons reflect GADT syntax. This is beneficial for th-desugar's since it means that all data type declarations can support explicit return kinds, so one does not need to represent them with something like Maybe DKind, since Haskell98-style data declaration syntax isn't used. Accordingly, there are some differences between DCon and Con to keep in mind:

Unlike ForallC, where the meaning of the TyVarBndrs changes depending on whether it's followed by GadtC/RecGadtC or not, the meaning of the DTyVarBndrs in a DCon is always the same: it is the list of universally and existentially quantified type variables. Note that it is not guaranteed that one set of type variables will appear before the other.
A DCon always has an explicit return type.

Constructors

DCon [DTyVarBndrSpec] DCxt Name DConFields DType

The GADT result type

Instances

Instances details

Data DCon Source #

Instance details

Methods

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

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

toConstr :: DCon -> Constr Source #

dataTypeOf :: DCon -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DCon Source #

Instance details

Associated Types

type Rep DCon

Instance details

type Rep DCon = D1 ('MetaData "DCon" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DCon" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrSpec]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DCxt)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DConFields) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))))

Methods

from :: DCon -> Rep DCon x Source #

to :: Rep DCon x -> DCon Source #

Show DCon Source #

Instance details

Methods

showsPrec :: Int -> DCon -> ShowS Source #

show :: DCon -> String Source #

showList :: [DCon] -> ShowS Source #

Eq DCon Source #

Instance details

Methods

(==) :: DCon -> DCon -> Bool Source #

(/=) :: DCon -> DCon -> Bool Source #

Lift DCon Source #

Instance details

Methods

lift :: Quote m => DCon -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DCon -> Code m DCon Source #

type Rep DCon Source #

Instance details

type Rep DCon = D1 ('MetaData "DCon" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DCon" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DTyVarBndrSpec]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DCxt)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DConFields) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))))

data DConFields Source #

A list of fields either for a standard data constructor or a record data constructor.

Constructors

DNormalC DDeclaredInfix [DBangType]
DRecC [DVarBangType]

Instances

Instances details

Data DConFields Source #

Instance details

Methods

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

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

toConstr :: DConFields -> Constr Source #

dataTypeOf :: DConFields -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DConFields Source #

Instance details

Associated Types

type Rep DConFields

Instance details

type Rep DConFields = D1 ('MetaData "DConFields" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DNormalC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DDeclaredInfix) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DBangType])) :+: C1 ('MetaCons "DRecC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DVarBangType])))

Methods

from :: DConFields -> Rep DConFields x Source #

to :: Rep DConFields x -> DConFields Source #

Show DConFields Source #

Instance details

Methods

showsPrec :: Int -> DConFields -> ShowS Source #

show :: DConFields -> String Source #

showList :: [DConFields] -> ShowS Source #

Eq DConFields Source #

Instance details

Methods

(==) :: DConFields -> DConFields -> Bool Source #

(/=) :: DConFields -> DConFields -> Bool Source #

Lift DConFields Source #

Instance details

Methods

lift :: Quote m => DConFields -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DConFields -> Code m DConFields Source #

type Rep DConFields Source #

Instance details

Bang SourceUnpackedness SourceStrictness

type Rep DConFields = D1 ('MetaData "DConFields" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DNormalC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DDeclaredInfix) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DBangType])) :+: C1 ('MetaCons "DRecC" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DVarBangType])))

type DDeclaredInfix = Bool Source #

True if a constructor is declared infix. For normal ADTs, this means that is was written in infix style. For example, both of the constructors below are declared infix.

data Infix = Int Infix Int | Int :*: Int

Whereas neither of these constructors are declared infix:

data Prefix = Prefix Int Int | (:+:) Int Int

For GADTs, detecting whether a constructor is declared infix is a bit trickier, as one cannot write a GADT constructor "infix-style" like one can for normal ADT constructors. GHC considers a GADT constructor to be declared infix if it meets the following three criteria:

Its name uses operator syntax (e.g., (:*:)).
It has exactly two fields (without record syntax).
It has a programmer-specified fixity declaration.

For example, in the following GADT:

infixl 5 :**:, :&&:, :^^:, ActuallyPrefix
data InfixGADT a where
  (:**:) :: Int -> b -> InfixGADT (Maybe b) -- Only this one is infix
  ActuallyPrefix :: Char -> Bool -> InfixGADT Double
  (:&&:) :: { infixGADT1 :: b, infixGADT2 :: Int } -> InfixGADT b :: Int -> Int -> Int -> InfixGADT Int
  (:!!:) :: Char -> Char -> InfixGADT Char

Only the (:**:) constructor is declared infix. The other constructors are not declared infix, because:

ActuallyPrefix does not use operator syntax (criterion 1).
(:&&:) uses record syntax (criterion 2).
(:^^:) does not have exactly two fields (criterion 2).
(:!!:) does not have a programmer-specified fixity declaration (criterion 3).

type DBangType = (Bang, DType) Source #

Corresponds to TH's BangType type.

type DVarBangType = (Name, Bang, DType) Source #

Corresponds to TH's VarBangType type.

data Bang Source #

Constructors

C { {-# UNPACK #-} !}a

Instances

Instances details

Data Bang

Instance details

Methods

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

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

toConstr :: Bang -> Constr Source #

dataTypeOf :: Bang -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic Bang

Instance details

Associated Types

type Rep Bang

Instance details

type Rep Bang = D1 ('MetaData "Bang" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Bang" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SourceUnpackedness) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SourceStrictness)))

Methods

from :: Bang -> Rep Bang x Source #

to :: Rep Bang x -> Bang Source #

Show Bang

Instance details

Methods

showsPrec :: Int -> Bang -> ShowS Source #

show :: Bang -> String Source #

showList :: [Bang] -> ShowS Source #

Eq Bang

Instance details

Methods

(==) :: Bang -> Bang -> Bool Source #

(/=) :: Bang -> Bang -> Bool Source #

Ord Bang

Instance details

Methods

compare :: Bang -> Bang -> Ordering Source #

(<) :: Bang -> Bang -> Bool Source #

(<=) :: Bang -> Bang -> Bool Source #

(>) :: Bang -> Bang -> Bool Source #

(>=) :: Bang -> Bang -> Bool Source #

max :: Bang -> Bang -> Bang Source #

min :: Bang -> Bang -> Bang Source #

Ppr Bang

Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Bang -> Doc Source #

ppr_list :: [Bang] -> Doc Source #

Lift Bang

Instance details

Methods

lift :: Quote m => Bang -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => Bang -> Code m Bang Source #

type Rep Bang

Instance details

type Rep Bang = D1 ('MetaData "Bang" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Bang" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SourceUnpackedness) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SourceStrictness)))

data SourceUnpackedness Source #

SourceUnpackedness corresponds to unpack annotations found in the source code.

This may not agree with the annotations returned by reifyConStrictness. See reifyConStrictness for more information.

Constructors

NoSourceUnpackedness	C a
SourceNoUnpack	C { {-# NOUNPACK #-} } a
SourceUnpack	C { {-# UNPACK #-} } a

Instances

Instances details

Data SourceUnpackedness

Instance details

Generic SourceUnpackedness

Methods

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

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

toConstr :: SourceUnpackedness -> Constr Source #

dataTypeOf :: SourceUnpackedness -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Instance details

Associated Types

type Rep SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax type Rep SourceUnpackedness = D1 ('MetaData "SourceUnpackedness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSourceUnpackedness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceNoUnpack" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceUnpack" 'PrefixI 'False) (U1 :: Type -> Type)))

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x Source #

to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #

Show SourceUnpackedness

Instance details

Methods

showsPrec :: Int -> SourceUnpackedness -> ShowS Source #

show :: SourceUnpackedness -> String Source #

showList :: [SourceUnpackedness] -> ShowS Source #

Eq SourceUnpackedness

Instance details

Methods

(==) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #

(/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #

Ord SourceUnpackedness

Instance details

Methods

compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering Source #

(<) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #

(<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #

(>) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #

(>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #

max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source #

min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source #

Ppr SourceUnpackedness

Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: SourceUnpackedness -> Doc Source #

ppr_list :: [SourceUnpackedness] -> Doc Source #

Lift SourceUnpackedness

Instance details

Methods

lift :: Quote m => SourceUnpackedness -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => SourceUnpackedness -> Code m SourceUnpackedness Source #

type Rep SourceUnpackedness

Instance details

type Rep SourceUnpackedness = D1 ('MetaData "SourceUnpackedness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSourceUnpackedness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceNoUnpack" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceUnpack" 'PrefixI 'False) (U1 :: Type -> Type)))

data SourceStrictness Source #

SourceStrictness corresponds to strictness annotations found in the source code.

This may not agree with the annotations returned by reifyConStrictness. See reifyConStrictness for more information.

Constructors

NoSourceStrictness	C a
SourceLazy	C {~}a
SourceStrict	C {!}a

Instances

Instances details

Data SourceStrictness

Instance details

Methods

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

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

toConstr :: SourceStrictness -> Constr Source #

dataTypeOf :: SourceStrictness -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic SourceStrictness

Instance details

Associated Types

type Rep SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax type Rep SourceStrictness = D1 ('MetaData "SourceStrictness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSourceStrictness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceLazy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceStrict" 'PrefixI 'False) (U1 :: Type -> Type)))

Methods

from :: SourceStrictness -> Rep SourceStrictness x Source #

to :: Rep SourceStrictness x -> SourceStrictness Source #

Show SourceStrictness

Instance details

Methods

showsPrec :: Int -> SourceStrictness -> ShowS Source #

show :: SourceStrictness -> String Source #

showList :: [SourceStrictness] -> ShowS Source #

Eq SourceStrictness

Instance details

Methods

(==) :: SourceStrictness -> SourceStrictness -> Bool Source #

(/=) :: SourceStrictness -> SourceStrictness -> Bool Source #

Ord SourceStrictness

Instance details

Methods

compare :: SourceStrictness -> SourceStrictness -> Ordering Source #

(<) :: SourceStrictness -> SourceStrictness -> Bool Source #

(<=) :: SourceStrictness -> SourceStrictness -> Bool Source #

(>) :: SourceStrictness -> SourceStrictness -> Bool Source #

(>=) :: SourceStrictness -> SourceStrictness -> Bool Source #

max :: SourceStrictness -> SourceStrictness -> SourceStrictness Source #

min :: SourceStrictness -> SourceStrictness -> SourceStrictness Source #

Ppr SourceStrictness

Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: SourceStrictness -> Doc Source #

ppr_list :: [SourceStrictness] -> Doc Source #

Lift SourceStrictness

Instance details

Methods

lift :: Quote m => SourceStrictness -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => SourceStrictness -> Code m SourceStrictness Source #

type Rep SourceStrictness

Instance details

type Rep SourceStrictness = D1 ('MetaData "SourceStrictness" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NoSourceStrictness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceLazy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceStrict" 'PrefixI 'False) (U1 :: Type -> Type)))

data DForeign Source #

Corresponds to TH's Foreign type.

Constructors

DImportF Callconv Safety String Name DType
DExportF Callconv String Name DType

Instances

Instances details

Data DForeign Source #

Instance details

Methods

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

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

toConstr :: DForeign -> Constr Source #

dataTypeOf :: DForeign -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DForeign Source #

Instance details

Associated Types

type Rep DForeign

Instance details

Methods

from :: DForeign -> Rep DForeign x Source #

to :: Rep DForeign x -> DForeign Source #

Show DForeign Source #

Instance details

Methods

showsPrec :: Int -> DForeign -> ShowS Source #

show :: DForeign -> String Source #

showList :: [DForeign] -> ShowS Source #

Eq DForeign Source #

Instance details

Methods

(==) :: DForeign -> DForeign -> Bool Source #

(/=) :: DForeign -> DForeign -> Bool Source #

Lift DForeign Source #

Instance details

Methods

lift :: Quote m => DForeign -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DForeign -> Code m DForeign Source #

type Rep DForeign Source #

Instance details

data DPragma Source #

Corresponds to TH's Pragma type.

Constructors

DInlineP Name Inline RuleMatch Phases
DSpecialiseP Name DType (Maybe Inline) Phases
DSpecialiseInstP DType
DRuleP String (Maybe [DTyVarBndrUnit]) [DRuleBndr] DExp DExp Phases
DAnnP AnnTarget DExp
DLineP Int String
DCompleteP [Name] (Maybe Name)
DOpaqueP Name
DSCCP Name (Maybe String)

Instances

Instances details

Data DPragma Source #

Instance details

Methods

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

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

toConstr :: DPragma -> Constr Source #

dataTypeOf :: DPragma -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DPragma Source #

Instance details

Associated Types

type Rep DPragma

Instance details

Methods

from :: DPragma -> Rep DPragma x Source #

to :: Rep DPragma x -> DPragma Source #

Show DPragma Source #

Instance details

Methods

showsPrec :: Int -> DPragma -> ShowS Source #

show :: DPragma -> String Source #

showList :: [DPragma] -> ShowS Source #

Eq DPragma Source #

Instance details

Methods

(==) :: DPragma -> DPragma -> Bool Source #

(/=) :: DPragma -> DPragma -> Bool Source #

Lift DPragma Source #

Instance details

Methods

lift :: Quote m => DPragma -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DPragma -> Code m DPragma Source #

type Rep DPragma Source #

Instance details

data DRuleBndr Source #

Corresponds to TH's RuleBndr type.

Constructors

DRuleVar Name
DTypedRuleVar Name DType

Instances

Instances details

Data DRuleBndr Source #

Instance details

Methods

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

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

toConstr :: DRuleBndr -> Constr Source #

dataTypeOf :: DRuleBndr -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DRuleBndr Source #

Instance details

Associated Types

type Rep DRuleBndr

Instance details

type Rep DRuleBndr = D1 ('MetaData "DRuleBndr" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DRuleVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "DTypedRuleVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))

Methods

from :: DRuleBndr -> Rep DRuleBndr x Source #

to :: Rep DRuleBndr x -> DRuleBndr Source #

Show DRuleBndr Source #

Instance details

Methods

showsPrec :: Int -> DRuleBndr -> ShowS Source #

show :: DRuleBndr -> String Source #

showList :: [DRuleBndr] -> ShowS Source #

Eq DRuleBndr Source #

Instance details

Methods

(==) :: DRuleBndr -> DRuleBndr -> Bool Source #

(/=) :: DRuleBndr -> DRuleBndr -> Bool Source #

Lift DRuleBndr Source #

Instance details

Methods

lift :: Quote m => DRuleBndr -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DRuleBndr -> Code m DRuleBndr Source #

type Rep DRuleBndr Source #

Instance details

type Rep DRuleBndr = D1 ('MetaData "DRuleBndr" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DRuleVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "DTypedRuleVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))

data DTySynEqn Source #

Corresponds to TH's TySynEqn type (to store type family equations).

Constructors

DTySynEqn (Maybe [DTyVarBndrUnit]) DType DType

Instances

Instances details

Data DTySynEqn Source #

Instance details

Methods

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

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

toConstr :: DTySynEqn -> Constr Source #

dataTypeOf :: DTySynEqn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DTySynEqn Source #

Instance details

Associated Types

type Rep DTySynEqn

Instance details

type Rep DTySynEqn = D1 ('MetaData "DTySynEqn" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DTySynEqn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [DTyVarBndrUnit])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType))))

Methods

from :: DTySynEqn -> Rep DTySynEqn x Source #

to :: Rep DTySynEqn x -> DTySynEqn Source #

Show DTySynEqn Source #

Instance details

Methods

showsPrec :: Int -> DTySynEqn -> ShowS Source #

show :: DTySynEqn -> String Source #

showList :: [DTySynEqn] -> ShowS Source #

Eq DTySynEqn Source #

Instance details

Methods

(==) :: DTySynEqn -> DTySynEqn -> Bool Source #

(/=) :: DTySynEqn -> DTySynEqn -> Bool Source #

Lift DTySynEqn Source #

Instance details

Methods

lift :: Quote m => DTySynEqn -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DTySynEqn -> Code m DTySynEqn Source #

type Rep DTySynEqn Source #

Instance details

type Rep DTySynEqn = D1 ('MetaData "DTySynEqn" "Language.Haskell.TH.Desugar.AST" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DTySynEqn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [DTyVarBndrUnit])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType))))

data DInfo Source #

Corresponds to TH's Info type.

Constructors

DTyConI DDec (Maybe [DInstanceDec])
DVarI Name DType (Maybe Name)	The `Maybe Name` stores the name of the enclosing definition (datatype, for a data constructor; class, for a method), if any
DTyVarI Name DKind
DPrimTyConI Name Int Bool	The `Int` is the arity; the `Bool` is whether this tycon is unlifted.
DPatSynI Name DPatSynType

Instances

Instances details

Data DInfo Source #

Instance details

Methods

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

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

toConstr :: DInfo -> Constr Source #

dataTypeOf :: DInfo -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DInfo Source #

Instance details

Associated Types

type Rep DInfo

Instance details

Methods

from :: DInfo -> Rep DInfo x Source #

to :: Rep DInfo x -> DInfo Source #

Show DInfo Source #

Instance details

Methods

showsPrec :: Int -> DInfo -> ShowS Source #

show :: DInfo -> String Source #

showList :: [DInfo] -> ShowS Source #

Eq DInfo Source #

Instance details

Methods

(==) :: DInfo -> DInfo -> Bool Source #

(/=) :: DInfo -> DInfo -> Bool Source #

Lift DInfo Source #

Instance details

Methods

lift :: Quote m => DInfo -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => DInfo -> Code m DInfo Source #

type Rep DInfo Source #

Instance details

type DInstanceDec Source #

Arguments

= DDec

Guaranteed to be an instance declaration

data Role Source #

Role annotations

Constructors

NominalR	nominal
RepresentationalR	representational
PhantomR	phantom
InferR	_

Instances

Instances details

Data Role

Instance details

Methods

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

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

toConstr :: Role -> Constr Source #

dataTypeOf :: Role -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic Role

Instance details

Associated Types

type Rep Role

Instance details

type Rep Role = D1 ('MetaData "Role" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "NominalR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RepresentationalR" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PhantomR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InferR" 'PrefixI 'False) (U1 :: Type -> Type)))

Methods

from :: Role -> Rep Role x Source #

to :: Rep Role x -> Role Source #

Show Role

Instance details

Methods

showsPrec :: Int -> Role -> ShowS Source #

show :: Role -> String Source #

showList :: [Role] -> ShowS Source #

Eq Role

Instance details

Methods

(==) :: Role -> Role -> Bool Source #

(/=) :: Role -> Role -> Bool Source #

Ord Role

Instance details

Methods

compare :: Role -> Role -> Ordering Source #

(<) :: Role -> Role -> Bool Source #

(<=) :: Role -> Role -> Bool Source #

(>) :: Role -> Role -> Bool Source #

(>=) :: Role -> Role -> Bool Source #

max :: Role -> Role -> Role Source #

min :: Role -> Role -> Role Source #

Ppr Role

Instance details

Defined in Language.Haskell.TH.Ppr

Methods

ppr :: Role -> Doc Source #

ppr_list :: [Role] -> Doc Source #

Lift Role

Instance details

Methods

lift :: Quote m => Role -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => Role -> Code m Role Source #

type Rep Role

Instance details

type Rep Role = D1 ('MetaData "Role" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "NominalR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RepresentationalR" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PhantomR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InferR" 'PrefixI 'False) (U1 :: Type -> Type)))

data AnnTarget Source #

Constructors

ModuleAnnotation
TypeAnnotation Name
ValueAnnotation Name

Instances

Instances details

Data AnnTarget

Instance details

Methods

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

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

toConstr :: AnnTarget -> Constr Source #

dataTypeOf :: AnnTarget -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic AnnTarget

Instance details

Associated Types

type Rep AnnTarget

Instance details

type Rep AnnTarget = D1 ('MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "ModuleAnnotation" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ValueAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))))

Methods

from :: AnnTarget -> Rep AnnTarget x Source #

to :: Rep AnnTarget x -> AnnTarget Source #

Show AnnTarget

Instance details

Methods

showsPrec :: Int -> AnnTarget -> ShowS Source #

show :: AnnTarget -> String Source #

showList :: [AnnTarget] -> ShowS Source #

Eq AnnTarget

Instance details

Methods

(==) :: AnnTarget -> AnnTarget -> Bool Source #

(/=) :: AnnTarget -> AnnTarget -> Bool Source #

Ord AnnTarget

Instance details

Methods

compare :: AnnTarget -> AnnTarget -> Ordering Source #

(<) :: AnnTarget -> AnnTarget -> Bool Source #

(<=) :: AnnTarget -> AnnTarget -> Bool Source #

(>) :: AnnTarget -> AnnTarget -> Bool Source #

(>=) :: AnnTarget -> AnnTarget -> Bool Source #

max :: AnnTarget -> AnnTarget -> AnnTarget Source #

min :: AnnTarget -> AnnTarget -> AnnTarget Source #

Lift AnnTarget

Instance details

Methods

lift :: Quote m => AnnTarget -> m Exp Source #

liftTyped :: forall (m :: Type -> Type). Quote m => AnnTarget -> Code m AnnTarget Source #

type Rep AnnTarget

Instance details

type Rep AnnTarget = D1 ('MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "ModuleAnnotation" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ValueAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))))

The `Desugar` class

class Desugar th ds | ds -> th where Source #

This class relates a TH type with its th-desugar type and allows conversions back and forth. The functional dependency goes only one way because we define the following instances on old versions of GHC:

instance Desugar TyVarBndrSpec DTyVarBndrSpec
instance Desugar TyVarBndrUnit DTyVarBndrUnit

Prior to GHC 9.0, TyVarBndrSpec and TyVarBndrUnit are simply type synonyms for TyVarBndr, so making the functional dependencies bidirectional would cause these instances to be rejected.

Methods

desugar :: DsMonad q => th -> q ds Source #

sweeten :: ds -> th Source #

Instances

Instances details

Desugar Cxt DCxt Source #
Instance details Defined in Language.Haskell.TH.Desugar Methods desugar :: DsMonad q => Cxt -> q DCxt Source # sweeten :: DCxt -> Cxt Source #
Desugar Exp DExp Source #
Instance details Defined in Language.Haskell.TH.Desugar Methods desugar :: DsMonad q => Exp -> q DExp Source # sweeten :: DExp -> Exp Source #
Desugar Type DType Source #
Instance details Defined in Language.Haskell.TH.Desugar Methods desugar :: DsMonad q => Type -> q DType Source # sweeten :: DType -> Type Source #
Desugar TypeArg DTypeArg Source #
Instance details Defined in Language.Haskell.TH.Desugar Methods desugar :: DsMonad q => TypeArg -> q DTypeArg Source # sweeten :: DTypeArg -> TypeArg Source #
Desugar (TyVarBndr flag) (DTyVarBndr flag) Source #	This instance is only `flag`-polymorphic on GHC 9.0 or later, since previous versions of GHC do not equip `TyVarBndr` with a `flag` type parameter. As a result, we define two separate instances for `DTyVarBndr` on older GHCs: instance `Desugar` `TyVarBndrSpec` `DTyVarBndrSpec` instance `Desugar` `TyVarBndrUnit` `DTyVarBndrUnit`
Instance details Defined in Language.Haskell.TH.Desugar Methods desugar :: DsMonad q => TyVarBndr flag -> q (DTyVarBndr flag) Source # sweeten :: DTyVarBndr flag -> TyVarBndr flag Source #
Desugar [Dec] [DDec] Source #
Instance details Defined in Language.Haskell.TH.Desugar Methods desugar :: DsMonad q => [Dec] -> q [DDec] Source # sweeten :: [DDec] -> [Dec] Source #

Main desugaring functions

dsExp :: DsMonad q => Exp -> q DExp Source #

Desugar an expression

dsDecs :: DsMonad q => [Dec] -> q [DDec] Source #

Desugar arbitrary Decs

dsType :: DsMonad q => Type -> q DType Source #

Desugar a type

dsInfo :: DsMonad q => Info -> q DInfo Source #

Desugar Info

dsPatOverExp :: DsMonad q => Pat -> DExp -> q (DPat, DExp) Source #

Desugar a pattern, along with processing a (desugared) expression that is the entire scope of the variables bound in the pattern.

dsPatsOverExp :: DsMonad q => [Pat] -> DExp -> q ([DPat], DExp) Source #

Desugar multiple patterns. Like dsPatOverExp.

dsPatX :: DsMonad q => Pat -> q (DPat, [(Name, DExp)]) Source #

Desugar a pattern, returning a list of (Name, DExp) pairs of extra variables that must be bound within the scope of the pattern

dsLetDecs :: DsMonad q => [Dec] -> q ([DLetDec], DExp -> DExp) Source #

Desugar Decs that can appear in a let expression. See the documentation for dsLetDec for an explanation of what the return type represents.

dsTvb :: DsMonad q => TyVarBndr_ flag -> q (DTyVarBndr flag) Source #

Desugar a TyVarBndr.

dsTvbSpec :: DsMonad q => TyVarBndrSpec -> q DTyVarBndrSpec Source #

Desugar a TyVarBndrSpec.

dsTvbUnit :: DsMonad q => TyVarBndrUnit -> q DTyVarBndrUnit Source #

Desugar a TyVarBndrUnit.

dsTvbVis :: DsMonad q => TyVarBndrVis -> q DTyVarBndrVis Source #

Desugar a TyVarBndrVis.

dsCxt :: DsMonad q => Cxt -> q DCxt Source #

Desugar a Cxt

dsCon Source #

Arguments

:: DsMonad q
=> [DTyVarBndrVis]	The universally quantified type variables (used if desugaring a non-GADT constructor).
-> DType	The original data declaration's type (used if desugaring a non-GADT constructor).
-> Con
-> q [DCon]

Desugar a single Con.

Because we always desugar Cons to GADT syntax (see the documentation for DCon), it is not always possible to desugar with just a Con alone. For instance, we must desugar:

data Foo a = forall b. MkFoo b

To this:

data Foo a :: Type where
  MkFoo :: forall a b. b -> Foo a

If our only argument was forall b. MkFoo b, it would be somewhat awkward to figure out (1) what the set of universally quantified type variables ([a]) was, and (2) what the return type (Foo a) was. For this reason, we require passing these as arguments. (If we desugar an actual GADT constructor, these arguments are ignored.)

dsForeign :: DsMonad q => Foreign -> q DForeign Source #

Desugar a Foreign.

dsPragma :: DsMonad q => Pragma -> q DPragma Source #

Desugar a Pragma.

dsRuleBndr :: DsMonad q => RuleBndr -> q DRuleBndr Source #

Desugar a RuleBndr.

Secondary desugaring functions

type PatM (q :: Type -> Type) = WriterT [(Name, DExp)] q Source #

Desugaring a pattern also returns the list of variables bound in as-patterns and the values they should be bound to. This variables must be brought into scope in the "body" of the pattern.

dsPred :: DsMonad q => Pred -> q DCxt Source #

Desugar a Pred, flattening any internal tuples

dsPat :: forall (q :: Type -> Type). DsMonad q => Pat -> PatM q DPat Source #

Desugar a pattern.

dsDec :: DsMonad q => Dec -> q [DDec] Source #

Desugar a single Dec, perhaps producing multiple DDecs

dsDataDec :: DsMonad q => DataFlavor -> Cxt -> Name -> [TyVarBndrVis] -> Maybe Kind -> [Con] -> [DerivingClause] -> q [DDec] Source #

Desugar a DataD, NewtypeD, or TypeDataD.

dsDataInstDec :: DsMonad q => DataFlavor -> Cxt -> Name -> Maybe [TyVarBndrUnit] -> [TypeArg] -> Maybe Kind -> [Con] -> [DerivingClause] -> q [DDec] Source #

Desugar a DataInstD or a NewtypeInstD.

type DerivingClause = DerivClause Source #

A backwards-compatible type synonym for the thing representing a single derived class in a deriving clause. (This is a DerivClause, Pred, or Name depending on the GHC version.)

dsDerivClause :: DsMonad q => DerivingClause -> q DDerivClause Source #

Desugar a DerivingClause.

dsLetDec :: DsMonad q => Dec -> q ([DLetDec], DExp -> DExp) Source #

Desugar a single Dec that can appear in a let expression. This produces the following output:

One or more DLetDecs (a single Dec can produce multiple DLetDecs in the event of a value declaration that binds multiple things by way of pattern matching.
A function of type DExp -> DExp, which should be applied to the expression immediately following the DLetDecs. This function prepends binding forms for any implicit params that were bound in the argument Dec. (If no implicit params are bound, this is simply the id function.)

For instance, if the argument to dsLetDec is the ?x = 42 part of this expression:

let { ?x = 42 } in ?x

Then the output is:

```
let new_x_val = 42
```
```
\z -> bindIP @"x" new_x_val z
```

This way, the expression let { new_x_val = 42 } in bindIP @"x" new_x_val (ip @"x") can be formed. The implicit param binders always come after all the other DLetDecs to support parallel assignment of implicit params.

dsMatches Source #

Arguments

:: DsMonad q
=> Name	Name of the scrutinee, which must be a bare var
-> [Match]	Matches of the `case` statement
-> q [DMatch]

Desugar a list of matches for a case statement

dsBody Source #

Arguments

:: DsMonad q
=> Body	body to desugar
-> [Dec]	"where" declarations
-> DExp	what to do if the guards don't match
-> q DExp

Desugar a Body

dsGuards Source #

Arguments

:: DsMonad q
=> [(Guard, Exp)]	Guarded expressions
-> DExp	What to do if none of the guards match
-> q DExp

Desugar guarded expressions

dsDoStmts :: DsMonad q => Maybe ModName -> [Stmt] -> q DExp Source #

Desugar the Stmts in a do expression

dsComp :: DsMonad q => [Stmt] -> q DExp Source #

Desugar the Stmts in a list or monad comprehension

dsClauses Source #

Arguments

:: DsMonad q
=> MatchContext	The context in which the clauses arise
-> [Clause]	Clauses to desugar
-> q [DClause]

Desugar clauses to a function definition

dsBangType :: DsMonad q => BangType -> q DBangType Source #

Desugar a BangType.

dsVarBangType :: DsMonad q => VarBangType -> q DVarBangType Source #

Desugar a VarBangType.

dsTypeFamilyHead :: DsMonad q => TypeFamilyHead -> q DTypeFamilyHead Source #

Desugar a TypeFamilyHead

dsFamilyResultSig :: DsMonad q => FamilyResultSig -> q DFamilyResultSig Source #

Desugar a FamilyResultSig

dsPatSynDir :: DsMonad q => Name -> PatSynDir -> q DPatSynDir Source #

Desugar a PatSynDir. (Available only with GHC 8.2+)

dsTypeArg :: DsMonad q => TypeArg -> q DTypeArg Source #

Desugar a TypeArg.

Converting desugared AST back to TH AST

module Language.Haskell.TH.Desugar.Sweeten

Expanding type synonyms

expand :: (DsMonad q, Data a) => a -> q a Source #

Expand all type synonyms and type families in the desugared abstract syntax tree provided, where type family simplification is on a "best effort" basis. Normally, the first parameter should have a type like DExp or DLetDec.

expandType :: DsMonad q => DType -> q DType Source #

Expands all type synonyms in a desugared type. Also expands open type family applications. (In GHCs before 7.10, this part does not work if there are any variables.) Attempts to expand closed type family applications, but aborts the moment it spots anything strange, like a nested type family application or type variable.

Reification

reifyWithWarning :: (Quasi q, MonadFail q) => Name -> q Info Source #

Reify a declaration, warning the user about splices if the reify fails. The warning says that reification can fail if you try to reify a type in the same splice as it is declared.

Local reification

template-haskell reification functions like reify and qReify, as well as th-desugar's reifyWithWarning, only look through declarations that either (1) have already been typechecked in the current module, or (2) are in scope because of imports. We refer to this as global reification. Sometimes, however, you may wish to reify declarations that have been quoted but not yet been typechecked, such as in the following example:

example :: IO ()
example = putStrLn
  $(do decs <- [d| data Foo = MkFoo |]
       info <- reify (mkName "Foo")
       stringE $ pprint info)

Because Foo only exists in a TH quote, it is not available globally. As a result, the call to reify (mkName "Foo") will fail.

To make this sort of example possible, th-desugar extends global reification with local reification. A function that performs local reification (such as dsReify, reifyWithLocals, or similar functions that have a DsMonad context) looks through both typechecked (or imported) declarations and quoted declarations that are currently in scope. One can add quoted declarations in the current scope by using the withLocalDeclarations function. Here is an example of how to repair the example above using withLocalDeclarations:

example2 :: IO ()
example2 = putStrLn
  $(do decs <- [d| data Foo = MkFoo |]
       info <- withLocalDeclarations decs $
                 reifyWithLocals (mkName "Foo")
       stringE $ pprint info)

Note that withLocalDeclarations should only be used to add quoted declarations with names that are not duplicates of existing global or local declarations. Adding duplicate declarations through withLocalDeclarations is undefined behavior and should be avoided. This is unlikely to happen if you are only using withLocalDeclarations in conjunction with TH quotes, however. For instance, this is not an example of duplicate declarations:

data T = MkT1

$(do decs <- [d| data T = MkT2 |]
     info <- withLocalDeclarations decs ...
     ...)

The quoted data T = MkT2 does not conflict with the top-level data T = Mk1 since declaring a data type within TH quotes gives it a fresh, unique name that distinguishes it from any other data types already in scope.

withLocalDeclarations :: DsMonad q => [Dec] -> DsM q a -> q a Source #

Add a list of declarations to be considered when reifying local declarations.

dsReify :: DsMonad q => Name -> q (Maybe DInfo) Source #

Like reify, but safer and desugared. Uses local declarations where available.

dsReifyType :: DsMonad q => Name -> q (Maybe DType) Source #

Like reifyType, but safer and desugared. Uses local declarations where available.

reifyWithLocals_maybe :: DsMonad q => Name -> q (Maybe Info) Source #

Like reify from Template Haskell, but looks also in any not-yet-typechecked declarations. To establish this list of not-yet-typechecked declarations, use withLocalDeclarations. Returns Nothing if reification fails. Note that no inferred type information is available from local declarations; bottoms may be used if necessary.

reifyWithLocals :: DsMonad q => Name -> q Info Source #

Like reifyWithLocals_maybe, but throws an exception upon failure, warning the user about separating splices.

reifyFixityWithLocals :: DsMonad q => Name -> q (Maybe Fixity) Source #

Like reifyWithLocals_maybe, but for fixities. Note that a return value of Nothing might mean that the name is not in scope, or it might mean that the name has no assigned fixity. (Use reifyWithLocals_maybe if you really need to tell the difference.)

reifyTypeWithLocals_maybe :: DsMonad q => Name -> q (Maybe Type) Source #

Like reifyWithLocals_maybe but for types and kinds. Note that a return value of Nothing might mean that the name is not in scope, or it might mean that the full type of the name cannot be determined. (Use reifyWithLocals_maybe if you really need to tell the difference.)

reifyTypeWithLocals :: DsMonad q => Name -> q Type Source #

Like reifyTypeWithLocals_maybe, but throws an exception upon failure, warning the user about separating splices.

lookupValueNameWithLocals :: DsMonad q => String -> q (Maybe Name) Source #

Like lookupValueName from Template Haskell, but looks also in Names of not-yet-typechecked declarations. To establish this list of not-yet-typechecked declarations, use withLocalDeclarations. Returns Nothing if no value with the same name can be found.

lookupTypeNameWithLocals :: DsMonad q => String -> q (Maybe Name) Source #

Like lookupTypeName from Template Haskell, but looks also in Names of not-yet-typechecked declarations. To establish this list of not-yet-typechecked declarations, use withLocalDeclarations. Returns Nothing if no type with the same name can be found.

mkDataNameWithLocals :: DsMonad q => String -> q Name Source #

Like TH's lookupValueName, but if this name is not bound, then we assume it is declared in the current module.

Unlike mkDataName, this also consults the local declarations in scope when determining if the name is currently bound.

mkTypeNameWithLocals :: DsMonad q => String -> q Name Source #

Like TH's lookupTypeName, but if this name is not bound, then we assume it is declared in the current module.

Unlike mkTypeName, this also consults the local declarations in scope when determining if the name is currently bound.

reifyNameSpace :: DsMonad q => Name -> q (Maybe NameSpace) Source #

Determines a Name's NameSpace. If the NameSpace is attached to the Name itself (i.e., it is unambiguous), then that NameSpace is immediately returned. Otherwise, reification is used to lookup up the NameSpace (consulting local declarations if necessary).

Note that if a Name lives in two different NameSpaces (which can genuinely happen--for instance, mkName "==", where == is both a function and a type family), then this function will simply return whichever NameSpace is discovered first via reification. If you wish to find a Name in a particular NameSpace, use the lookupValueNameWithLocals or lookupTypeNameWithLocals functions.

class (Quasi m, MonadFail m) => DsMonad (m :: Type -> Type) where Source #

A DsMonad stores some list of declarations that should be considered in scope. DsM is the prototypical inhabitant of DsMonad.

Methods

localDeclarations :: m [Dec] Source #

Produce a list of local declarations.

Instances

Instances details

DsMonad IO Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: IO [Dec] Source #
DsMonad Q Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: Q [Dec] Source #
(Quasi q, MonadFail q) => DsMonad (DsM q) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: DsM q [Dec] Source #
DsMonad m => DsMonad (ReaderT r m) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: ReaderT r m [Dec] Source #
DsMonad m => DsMonad (StateT s m) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: StateT s m [Dec] Source #
(DsMonad m, Monoid w) => DsMonad (WriterT w m) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: WriterT w m [Dec] Source #
(DsMonad m, Monoid w) => DsMonad (RWST r w s m) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: RWST r w s m [Dec] Source #

data DsM (q :: Type -> Type) a Source #

A convenient implementation of the DsMonad class. Use by calling withLocalDeclarations.

Instances

Instances details

MonadTrans DsM Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods lift :: Monad m => m a -> DsM m a Source #
MonadIO q => MonadIO (DsM q) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods liftIO :: IO a -> DsM q a Source #
Applicative q => Applicative (DsM q) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods pure :: a -> DsM q a Source # (<>) :: DsM q (a -> b) -> DsM q a -> DsM q b Source # liftA2 :: (a -> b -> c) -> DsM q a -> DsM q b -> DsM q c Source # (>) :: DsM q a -> DsM q b -> DsM q b Source # (<*) :: DsM q a -> DsM q b -> DsM q a Source #
Functor q => Functor (DsM q) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods fmap :: (a -> b) -> DsM q a -> DsM q b Source # (<$) :: a -> DsM q b -> DsM q a Source #
Monad q => Monad (DsM q) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods (>>=) :: DsM q a -> (a -> DsM q b) -> DsM q b Source # (>>) :: DsM q a -> DsM q b -> DsM q b Source # return :: a -> DsM q a Source #
MonadFail q => MonadFail (DsM q) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods fail :: String -> DsM q a Source #
Quasi q => Quasi (DsM q) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods qNewName :: String -> DsM q Name Source # qReport :: Bool -> String -> DsM q () Source # qRecover :: DsM q a -> DsM q a -> DsM q a Source # qLookupName :: Bool -> String -> DsM q (Maybe Name) Source # qReify :: Name -> DsM q Info Source # qReifyFixity :: Name -> DsM q (Maybe Fixity) Source # qReifyType :: Name -> DsM q Type Source # qReifyInstances :: Name -> [Type] -> DsM q [Dec] Source # qReifyRoles :: Name -> DsM q [Role] Source # qReifyAnnotations :: Data a => AnnLookup -> DsM q [a] Source # qReifyModule :: Module -> DsM q ModuleInfo Source # qReifyConStrictness :: Name -> DsM q [DecidedStrictness] Source # qLocation :: DsM q Loc Source # qRunIO :: IO a -> DsM q a Source # qGetPackageRoot :: DsM q FilePath Source # qAddDependentFile :: FilePath -> DsM q () Source # qAddTempFile :: String -> DsM q FilePath Source # qAddTopDecls :: [Dec] -> DsM q () Source # qAddForeignFilePath :: ForeignSrcLang -> String -> DsM q () Source # qAddModFinalizer :: Q () -> DsM q () Source # qAddCorePlugin :: String -> DsM q () Source # qGetQ :: Typeable a => DsM q (Maybe a) Source # qPutQ :: Typeable a => a -> DsM q () Source # qIsExtEnabled :: Extension -> DsM q Bool Source # qExtsEnabled :: DsM q [Extension] Source # qPutDoc :: DocLoc -> String -> DsM q () Source # qGetDoc :: DocLoc -> DsM q (Maybe String) Source #
(Quasi q, MonadFail q) => DsMonad (DsM q) Source #
Instance details Defined in Language.Haskell.TH.Desugar.Reify Methods localDeclarations :: DsM q [Dec] Source #

Nested pattern flattening

scExp :: DsMonad q => DExp -> q DExp Source #

Remove all nested pattern-matches within this expression. This also removes all DTildePas and DBangPas. After this is run, every pattern is guaranteed to be either a DConPa with bare variables as arguments, a DLitPa, or a DWildPa.

scLetDec :: DsMonad q => DLetDec -> q DLetDec Source #

Like scExp, but for a DLetDec.

Capture-avoiding substitution and utilities

module Language.Haskell.TH.Desugar.Subst

Free variable calculation

fvDType :: DType -> OSet Name Source #

Compute the free variables of a DType.

extractBoundNamesDPat :: DPat -> OSet Name Source #

Extract the term variables bound by a DPat.

This does not extract any type variables bound by pattern signatures, constructor patterns, or type patterns.

Utility functions

applyDExp :: DExp -> [DExp] -> DExp Source #

Apply one DExp to a list of arguments

dPatToDExp :: DPat -> DExp Source #

Convert a DPat to a DExp. Fails on DWildP and DInvisP.

removeWilds :: DsMonad q => DPat -> q DPat Source #

Remove all wildcards from a pattern, replacing any wildcard with a fresh variable

getDataD Source #

Arguments

:: DsMonad q
=> String	Print this out on failure
-> Name	Name of the datatype (`data` or `newtype`) of interest
-> q (DataFlavor, [TyVarBndrVis], [Con])

Extract the DataFlavor, TyVarBndrs and constructors given the Name of a type.

dataConNameToDataName :: DsMonad q => Name -> q Name Source #

From the name of a data constructor, retrive the datatype definition it is a part of.

dataConNameToCon :: DsMonad q => Name -> q Con Source #

From the name of a data constructor, retrieve its definition as a Con

nameOccursIn :: Data a => Name -> a -> Bool Source #

Check if a name occurs anywhere within a TH tree.

allNamesIn :: Data a => a -> [Name] Source #

Extract all Names mentioned in a TH tree.

flattenDValD :: Quasi q => DLetDec -> q [DLetDec] Source #

If the declaration passed in is a DValD, creates new, equivalent declarations such that the DPat in all DValDs is just a plain DVarPa. Other declarations are passed through unchanged. Note that the declarations that come out of this function are rather less efficient than those that come in: they have many more pattern matches.

getRecordSelectors :: DsMonad q => [DCon] -> q [DLetDec] Source #

Produces DLetDecs representing the record selector functions from the provided DCons.

Note that if the same record selector appears in multiple constructors, getRecordSelectors will return only one binding for that selector. For example, if you had:

data X = X1 {y :: Symbol} | X2 {y :: Symbol}

Then calling getRecordSelectors on [X1, X2] will return:

[ DSigD y (DAppT (DAppT DArrowT (DConT X)) (DConT Symbol))
, DFunD y [ DClause [DConP X1 [DVarP field]] (DVarE field)
          , DClause [DConP X2 [DVarP field]] (DVarE field) ] ]

instead of returning one binding for X1 and another binding for X2.

getRecordSelectors does not attempt to filter out "naughty" record selectors—that is, records whose field types mention existentially quantified type variables that do not appear in the constructor's return type. Here is an example of a naughty record selector:

data Some :: (Type -> Type) -> Type where
  MkSome :: { getSome :: f a } -> Some f

GHC itself will not allow the use of getSome as a top-level function due to its type f a mentioning the existential variable a, but getRecordSelectors will return it nonetheless. Ultimately, this design choice is a practical one, as detecting which type variables are existential in Template Haskell is difficult in the general case.

mkTypeName :: Quasi q => String -> q Name Source #

Like TH's lookupTypeName, but if this name is not bound, then we assume it is declared in the current module.

mkDataName :: Quasi q => String -> q Name Source #

Like TH's lookupDataName, but if this name is not bound, then we assume it is declared in the current module.

newUniqueName :: Quasi q => String -> q Name Source #

Like newName, but even more unique (unique across different splices), and with unique nameBases. Precondition: the string is a valid Haskell alphanumeric identifier (could be upper- or lower-case).

mkTupleDExp :: [DExp] -> DExp Source #

Make a tuple DExp from a list of DExps. Avoids using a 1-tuple.

mkTupleDPat :: [DPat] -> DPat Source #

Make a tuple DPat from a list of DPats. Avoids using a 1-tuple.

maybeDLetE :: [DLetDec] -> DExp -> DExp Source #

If decs is non-empty, delcare them in a let:

maybeDCaseE :: MatchContext -> DExp -> [DMatch] -> DExp Source #

If matches is non-empty, make a case statement; otherwise make an error statement

mkDLamEFromDPats :: Quasi q => [DPat] -> DExp -> q DExp Source #

Convert a list of DPat arguments and a DExp body into a DLamE. This is needed since DLamE takes a list of Names for its bound variables instead of DPats, so some reorganization is needed.

tupleNameDegree_maybe :: Name -> Maybe Int Source #

Extract the degree of a tuple Name.

In addition to recognizing tuple syntax (e.g., ''(,,)), this also recognizes the following:

''Unit (for 0-tuples)
''Solo/'MkSolo (for 1-tuples)
''TupleN (for N-tuples)

In recent versions of GHC, ''() is a synonym for ''Unit, ''(,) is a synonym for ''Tuple2, and so on. As a result, we must check for ''Unit and ''TupleN in tupleDegree_maybe to be thorough. (There is no special tuple syntax for ''Solo/'MkSolo, but we check them here as well for the sake of completeness.)

unboxedSumNameDegree_maybe :: Name -> Maybe Int Source #

Extract the degree of an unboxed sum Name.

In addition to recognizing unboxed sum syntax (e.g., ''()), this also recognizes ''SumN# (for unboxed N-ary sum type constructors). In recent versions of GHC, ''Sum2# is a synonym for ''(), ''Sum3# is a synonym for ''(), and so on. As a result, we must check for ''SumN# in unboxedSumNameDegree_maybe to be thorough.

unboxedTupleNameDegree_maybe :: Name -> Maybe Int Source #

Extract the degree of an unboxed tuple Name.

In addition to recognizing unboxed tuple syntax (e.g., ''()), this also recognizes the following:

''Unit# (for unboxed 0-tuples)
''Solo#/'Solo# (for unboxed 1-tuples)
''TupleN# (for unboxed N-tuples)

In recent versions of GHC, ''(##) is a synonym for ''Unit#, ''() is a synonym for ''Tuple2#, and so on. As a result, we must check for ''Unit#, and ''TupleN in unboxedTupleNameDegree_maybe to be thorough. (There is no special unboxed tuple type constructor for ''Solo#/'Solo#, but we check them here as well for the sake of completeness.)

isTypeKindName :: Name -> Bool Source #

Returns True if the argument Name is that of Type (or * or ★, to support older GHCs).

typeKindName :: Name Source #

The Name of the kind Type. 2. The kind * on older GHCs.

bindIP :: forall (name :: Symbol) a r. a -> (IP name a => r) -> r Source #

Get an implicit param constraint (IP name a, which is the desugared form of (?name :: a)) from an explicit value.

This function is only available with GHC 8.0 or later.

mkExtraDKindBinders :: DsMonad q => DKind -> q [DTyVarBndrVis] Source #

Create new kind variable binder names corresponding to the return kind of a data type. This is useful when you have a data type like:

data Foo :: forall k. k -> Type -> Type where ...

But you want to be able to refer to the type Foo a b. mkExtraDKindBinders will take the kind forall k. k -> Type -> Type, discover that is has two visible argument kinds, and return as a result two new kind variable binders [a :: k, b :: Type], where a and b are fresh type variable names.

This expands kind synonyms if necessary.

dTyVarBndrToDType :: DTyVarBndr flag -> DType Source #

Convert a DTyVarBndr into a DType

changeDTVFlags :: newFlag -> [DTyVarBndr oldFlag] -> [DTyVarBndr newFlag] Source #

Set the flag in a list of DTyVarBndrs. This is often useful in contexts where one needs to re-use a list of DTyVarBndrs from one flag setting to another flag setting. For example, in order to re-use the DTyVarBndrs bound by a DDataD in a DForallT, one can do the following:

case x of
  DDataD _ _ _ tvbs _ _ _ ->
    DForallT (DForallInvis (changeDTVFlags SpecifiedSpec tvbs)) ...

toposortTyVarsOf :: [DType] -> [DTyVarBndrUnit] Source #

Take a list of DTypes, find their free variables, and sort them in reverse topological order to ensure that they are well scoped. In other words, the free variables are ordered such that:

Whenever an explicit kind signature of the form (A :: K) is encountered, the free variables of K will always appear to the left of the free variables of A in the returned result.
The constraint in (1) notwithstanding, free variables will appear in left-to-right order of their original appearance.

On older GHCs, this takes measures to avoid returning explicitly bound kind variables, which was not possible before TypeInType.

toposortKindVarsOfTvbs :: [DTyVarBndr flag] -> [DTyVarBndrUnit] Source #

Take a telescope of DTyVarBndrs, find the free variables in their kinds, and sort them in reverse topological order to ensure that they are well scoped. Because the argument list is assumed to be telescoping, kind variables that are bound earlier in the list are not returned. For example, this:

toposortKindVarsOfTvbs [a :: k, b :: Proxy a]

Will return [k], not [k, a], since a is bound earlier by a :: k.

`FunArgs` and `VisFunArg`

data FunArgs Source #

The list of arguments in a function Type.

Constructors

FANil	No more arguments.
FAForalls ForallTelescope FunArgs	A series of `forall`ed type variables followed by a dot (if `ForallInvis`) or an arrow (if `ForallVis`). For example, the type variables `a1 ... an` in `forall a1 ... an. r`.
FACxt Cxt FunArgs	A series of constraint arguments followed by `=>`. For example, the `(c1, ..., cn)` in `(c1, ..., cn) => r`.
FAAnon Type FunArgs	An anonymous argument followed by an arrow. For example, the `a` in `a -> r`.

Instances

Instances details

Data FunArgs Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunArgs -> c FunArgs Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunArgs Source # toConstr :: FunArgs -> Constr Source # dataTypeOf :: FunArgs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunArgs) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunArgs) Source # gmapT :: (forall b. Data b => b -> b) -> FunArgs -> FunArgs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunArgs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunArgs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FunArgs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunArgs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunArgs -> m FunArgs Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunArgs -> m FunArgs Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunArgs -> m FunArgs Source #
Show FunArgs Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods showsPrec :: Int -> FunArgs -> ShowS Source # show :: FunArgs -> String Source # showList :: [FunArgs] -> ShowS Source #
Eq FunArgs Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods (==) :: FunArgs -> FunArgs -> Bool Source # (/=) :: FunArgs -> FunArgs -> Bool Source #

data ForallTelescope Source #

The type variable binders in a forall. This is not used by the TH AST itself, but this is used as an intermediate data type in FAForalls.

Constructors

ForallVis [TyVarBndrUnit]	A visible `forall` (e.g., `forall a -> {...}`). These do not have any notion of specificity, so we use `()` as a placeholder value in the `TyVarBndr`s.
ForallInvis [TyVarBndrSpec]	An invisible `forall` (e.g., `forall a {b} c -> {...}`), where each binder has a `Specificity`.

Instances

Instances details

Data ForallTelescope Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForallTelescope -> c ForallTelescope Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForallTelescope Source # toConstr :: ForallTelescope -> Constr Source # dataTypeOf :: ForallTelescope -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForallTelescope) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForallTelescope) Source # gmapT :: (forall b. Data b => b -> b) -> ForallTelescope -> ForallTelescope Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForallTelescope -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForallTelescope -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ForallTelescope -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForallTelescope -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForallTelescope -> m ForallTelescope Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForallTelescope -> m ForallTelescope Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForallTelescope -> m ForallTelescope Source #
Show ForallTelescope Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods showsPrec :: Int -> ForallTelescope -> ShowS Source # show :: ForallTelescope -> String Source # showList :: [ForallTelescope] -> ShowS Source #
Eq ForallTelescope Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods (==) :: ForallTelescope -> ForallTelescope -> Bool Source # (/=) :: ForallTelescope -> ForallTelescope -> Bool Source #

data VisFunArg Source #

A visible function argument type (i.e., one that must be supplied explicitly in the source code). This is in contrast to invisible arguments (e.g., the c in c => r), which are instantiated without the need for explicit user input.

Constructors

VisFADep TyVarBndrUnit	A visible `forall` (e.g., `forall a -> a`).
VisFAAnon Type	An anonymous argument followed by an arrow (e.g., `a -> r`).

Instances

Instances details

Data VisFunArg Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VisFunArg -> c VisFunArg Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VisFunArg Source # toConstr :: VisFunArg -> Constr Source # dataTypeOf :: VisFunArg -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c VisFunArg) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VisFunArg) Source # gmapT :: (forall b. Data b => b -> b) -> VisFunArg -> VisFunArg Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VisFunArg -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VisFunArg -> r Source # gmapQ :: (forall d. Data d => d -> u) -> VisFunArg -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> VisFunArg -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VisFunArg -> m VisFunArg Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VisFunArg -> m VisFunArg Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VisFunArg -> m VisFunArg Source #
Show VisFunArg Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods showsPrec :: Int -> VisFunArg -> ShowS Source # show :: VisFunArg -> String Source # showList :: [VisFunArg] -> ShowS Source #
Eq VisFunArg Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods (==) :: VisFunArg -> VisFunArg -> Bool Source # (/=) :: VisFunArg -> VisFunArg -> Bool Source #

filterVisFunArgs :: FunArgs -> [VisFunArg] Source #

Filter the visible function arguments from a list of FunArgs.

ravelType :: FunArgs -> Type -> Type Source #

Reconstruct an arrow Type from its argument and result types.

unravelType :: Type -> (FunArgs, Type) Source #

Decompose a function Type into its arguments (the FunArgs) and its result type (the 'Type).

`DFunArgs` and `DVisFunArg`

data DFunArgs Source #

The list of arguments in a function DType.

Constructors

DFANil	No more arguments.
DFAForalls DForallTelescope DFunArgs	A series of `forall`ed type variables followed by a dot (if `ForallInvis`) or an arrow (if `ForallVis`). For example, the type variables `a1 ... an` in `forall a1 ... an. r`.
DFACxt DCxt DFunArgs	A series of constraint arguments followed by `=>`. For example, the `(c1, ..., cn)` in `(c1, ..., cn) => r`.
DFAAnon DType DFunArgs	An anonymous argument followed by an arrow. For example, the `a` in `a -> r`.

Instances

Instances details

Data DFunArgs Source #

Instance details

Methods

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

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

toConstr :: DFunArgs -> Constr Source #

dataTypeOf :: DFunArgs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DFunArgs Source #

Instance details

Associated Types

type Rep DFunArgs

Instance details

type Rep DFunArgs = D1 ('MetaData "DFunArgs" "Language.Haskell.TH.Desugar.Core" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) ((C1 ('MetaCons "DFANil" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DFAForalls" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DForallTelescope) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DFunArgs))) :+: (C1 ('MetaCons "DFACxt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DCxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DFunArgs)) :+: C1 ('MetaCons "DFAAnon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DFunArgs))))

Methods

from :: DFunArgs -> Rep DFunArgs x Source #

to :: Rep DFunArgs x -> DFunArgs Source #

Show DFunArgs Source #

Instance details

Methods

showsPrec :: Int -> DFunArgs -> ShowS Source #

show :: DFunArgs -> String Source #

showList :: [DFunArgs] -> ShowS Source #

Eq DFunArgs Source #

Instance details

Methods

(==) :: DFunArgs -> DFunArgs -> Bool Source #

(/=) :: DFunArgs -> DFunArgs -> Bool Source #

type Rep DFunArgs Source #

Instance details

type Rep DFunArgs = D1 ('MetaData "DFunArgs" "Language.Haskell.TH.Desugar.Core" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) ((C1 ('MetaCons "DFANil" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DFAForalls" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DForallTelescope) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DFunArgs))) :+: (C1 ('MetaCons "DFACxt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DCxt) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DFunArgs)) :+: C1 ('MetaCons "DFAAnon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DFunArgs))))

data DVisFunArg Source #

A visible function argument type (i.e., one that must be supplied explicitly in the source code). This is in contrast to invisible arguments (e.g., the c in c => r), which are instantiated without the need for explicit user input.

Constructors

DVisFADep DTyVarBndrUnit	A visible `forall` (e.g., `forall a -> a`).
DVisFAAnon DType	An anonymous argument followed by an arrow (e.g., `a -> r`).

Instances

Instances details

Data DVisFunArg Source #

Instance details

Methods

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

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

toConstr :: DVisFunArg -> Constr Source #

dataTypeOf :: DVisFunArg -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DVisFunArg Source #

Instance details

Associated Types

type Rep DVisFunArg

Instance details

type Rep DVisFunArg = D1 ('MetaData "DVisFunArg" "Language.Haskell.TH.Desugar.Core" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DVisFADep" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DTyVarBndrUnit)) :+: C1 ('MetaCons "DVisFAAnon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))

Methods

from :: DVisFunArg -> Rep DVisFunArg x Source #

to :: Rep DVisFunArg x -> DVisFunArg Source #

Show DVisFunArg Source #

Instance details

Methods

showsPrec :: Int -> DVisFunArg -> ShowS Source #

show :: DVisFunArg -> String Source #

showList :: [DVisFunArg] -> ShowS Source #

Eq DVisFunArg Source #

Instance details

Methods

(==) :: DVisFunArg -> DVisFunArg -> Bool Source #

(/=) :: DVisFunArg -> DVisFunArg -> Bool Source #

type Rep DVisFunArg Source #

Instance details

type Rep DVisFunArg = D1 ('MetaData "DVisFunArg" "Language.Haskell.TH.Desugar.Core" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DVisFADep" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DTyVarBndrUnit)) :+: C1 ('MetaCons "DVisFAAnon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))

filterDVisFunArgs :: DFunArgs -> [DVisFunArg] Source #

Filter the visible function arguments from a list of DFunArgs.

ravelDType :: DFunArgs -> DType -> DType Source #

Reconstruct an arrow DType from its argument and result types.

unravelDType :: DType -> (DFunArgs, DType) Source #

Decompose a function DType into its arguments (the DFunArgs) and its result type (the 'DType).

`TypeArg`

data TypeArg Source #

An argument to a type, either a normal type (TANormal) or a visible kind application (TyArg).

TypeArg is useful when decomposing an application of a Type to its arguments (e.g., in unfoldType).

Constructors

TANormal Type
TyArg Kind

Instances

Instances details

Data TypeArg Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeArg -> c TypeArg Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeArg Source # toConstr :: TypeArg -> Constr Source # dataTypeOf :: TypeArg -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeArg) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeArg) Source # gmapT :: (forall b. Data b => b -> b) -> TypeArg -> TypeArg Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeArg -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeArg -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TypeArg -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeArg -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeArg -> m TypeArg Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeArg -> m TypeArg Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeArg -> m TypeArg Source #
Show TypeArg Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods showsPrec :: Int -> TypeArg -> ShowS Source # show :: TypeArg -> String Source # showList :: [TypeArg] -> ShowS Source #
Eq TypeArg Source #
Instance details Defined in Language.Haskell.TH.Desugar.Util Methods (==) :: TypeArg -> TypeArg -> Bool Source # (/=) :: TypeArg -> TypeArg -> Bool Source #
Desugar TypeArg DTypeArg Source #
Instance details Defined in Language.Haskell.TH.Desugar Methods desugar :: DsMonad q => TypeArg -> q DTypeArg Source # sweeten :: DTypeArg -> TypeArg Source #

applyType :: Type -> [TypeArg] -> Type Source #

Apply one Type to a list of arguments.

filterTANormals :: [TypeArg] -> [Type] Source #

Filter the normal type arguments from a list of TypeArgs.

tyVarBndrVisToTypeArg :: TyVarBndrVis -> TypeArg Source #

Convert a TyVarBndrVis to a TypeArg. That is, convert a binder with a BndrReq visibility to a TANormal and a binder with BndrInvis visibility to a TyArg.

If given a KindedTV, the resulting TypeArg will omit the kind signature. Use tyVarBndrVisToTypeArgWithSig if you want to preserve the kind signature.

tyVarBndrVisToTypeArgWithSig :: TyVarBndrVis -> TypeArg Source #

Convert a TyVarBndrVis to a TypeArg. That is, convert a binder with a BndrReq visibility to a TANormal and a binder with BndrInvis visibility to a TyArg.

If given a KindedTV, the resulting TypeArg will preserve the kind signature. Use tyVarBndrVisToTypeArg if you want to omit the kind signature.

unfoldType :: Type -> (Type, [TypeArg]) Source #

Decompose an applied type into its individual components. For example, this:

Proxy @Type Char

would be unfolded to this:

(ConT ''Proxy, [TyArg (ConT ''Type), TANormal (ConT ''Char)])

This process forgets about infix application, so both of these types:

Int :++: Int
(:++:) Int Int

will be unfolded to this:

(ConT ''(:+:), [TANormal (ConT ''Int), TANormal (ConT ''Int)])

This function should only be used after all UInfixT and PromotedUInfixT types have been resolved (e.g., via th-abstraction's resolveInfixT function).

`DTypeArg`

data DTypeArg Source #

An argument to a type, either a normal type (DTANormal) or a visible kind application (DTyArg).

DTypeArg does not appear directly in the th-desugar AST, but it is useful when decomposing an application of a DType to its arguments.

Constructors

DTANormal DType
DTyArg DKind

Instances

Instances details

Data DTypeArg Source #

Instance details

Methods

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

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

toConstr :: DTypeArg -> Constr Source #

dataTypeOf :: DTypeArg -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Generic DTypeArg Source #

Instance details

Associated Types

type Rep DTypeArg

Instance details

type Rep DTypeArg = D1 ('MetaData "DTypeArg" "Language.Haskell.TH.Desugar.Core" "th-desugar-1.17-LjmgTB0R5ZN6DcpXjEdY8c" 'False) (C1 ('MetaCons "DTANormal" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)) :+: C1 ('MetaCons "DTyArg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DKind)))

Methods

from :: DTypeArg -> Rep DTypeArg x Source #

to :: Rep DTypeArg x -> DTypeArg Source #

Show DTypeArg Source #

Instance details

Methods

showsPrec :: Int -> DTypeArg -> ShowS Source #

show :: DTypeArg -> String Source #

showList :: [DTypeArg] -> ShowS Source #

Eq DTypeArg Source #

Instance details

Methods

(==) :: DTypeArg -> DTypeArg -> Bool Source #

(/=) :: DTypeArg -> DTypeArg -> Bool Source #

Desugar TypeArg DTypeArg Source #

Instance details

Methods

desugar :: DsMonad q => TypeArg -> q DTypeArg Source #

sweeten :: DTypeArg -> TypeArg Source #

type Rep DTypeArg Source #

Instance details