TH.ReifySimple

Utilities for reifying simplified datatype info. It omits details that aren't usually relevant to generating instances that work with the datatype. This makes it easier to use TH to derive instances.

The "Simple" in the module name refers to the simplicity of the datatypes, not the module itself, which exports quite a few things which are useful in some circumstance or another. I anticipate that the most common uses of this will be the following APIs:

• Getting info about a data or newtype declaration, via DataType, reifyDataType, and DataCon. This is useful for writing something which generates declarations based on a datatype, one of the most common uses of Template Haskell.
• Getting nicely structured info about a named type. See TypeInfo and reifyType. This does not yet support reifying typeclasses, primitive type constructors, or type variables (TyVarI).

Currently, this module supports reifying simplified versions of the following Info constructors:

• TyConI with DataD and NewtypeD (becomes a DataType value)
• FamilyI becomes a DataFamily or TypeFamily value.
• DataConI becomes a DataCon value.

In the future it will hopefully also have support for the remaining Info constructors, ClassI, ClassOpI, PrimTyConI, VarI, and TyVarI.

Reifying simplified type info

data TypeInfo

reifyType :: Name -> Q TypeInfo

Reifies a Name as a TypeInfo, and calls fail if this doesn't work. Use reify with infoToType if you want to handle the failure case more gracefully.

This does not yet support reifying typeclasses, primitive type constructors, or type variables (TyVarI).

infoToType :: Info -> Q (Maybe TypeInfo)

Convert an Info into a TypeInfo if possible, and otherwise yield Nothing. Needs to run in Q so that

reifyTypeNoDataKinds :: Name -> Q (Maybe TypeInfo)

Reifies type info, but instead of yielding a LiftedDataConInfo, will instead yield Nothing.

infoToTypeNoDataKinds :: Info -> Maybe TypeInfo

Convert an 'Info into a TypeInfo if possible. If it's a data constructor, instead of yielding LiftedDataConInfo, it will instead yield Nothing.

Reifying simplified info for specific declaration varieties

Datatype info

data DataType

Simplified info about a DataD. Omits deriving, strictness, kind info, and whether it's data or newtype.

Constructors

DataType

Fields

• dtName :: Name
• dtTvs :: [Name]
• dtCxt :: Cxt
• dtCons :: [DataCon]

Instances

Data DataType

Defined in TH.ReifySimple

Methods

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

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

toConstr :: DataType -> Constr

dataTypeOf :: DataType -> DataType0

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

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

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

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

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

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

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

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

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

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

Generic DataType

Defined in TH.ReifySimple

Associated Types

type Rep DataType :: Type -> Type

Methods

from :: DataType -> Rep DataType x

to :: Rep DataType x -> DataType

Show DataType

Defined in TH.ReifySimple

Methods

showsPrec :: Int -> DataType -> ShowS

show :: DataType -> String

showList :: [DataType] -> ShowS

Eq DataType

Defined in TH.ReifySimple

Methods

(==) :: DataType -> DataType -> Bool

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

Ord DataType

Defined in TH.ReifySimple

Methods

compare :: DataType -> DataType -> Ordering

(<) :: DataType -> DataType -> Bool

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

(>) :: DataType -> DataType -> Bool

(>=) :: DataType -> DataType -> Bool

max :: DataType -> DataType -> DataType

min :: DataType -> DataType -> DataType

type Rep DataType

Defined in TH.ReifySimple

type Rep DataType = D1 ('MetaData "DataType" "TH.ReifySimple" "th-utilities-0.2.5.0-K0RNPnbhjz1AzY6uzY221h" 'False) (C1 ('MetaCons "DataType" 'PrefixI 'True) ((S1 ('MetaSel ('Just "dtName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Just "dtTvs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :*: (S1 ('MetaSel ('Just "dtCxt") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Just "dtCons") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DataCon]))))

reifyDataType :: Name -> Q DataType

Reify the given data or newtype declaration, and yields its DataType representation.

infoToDataType :: Info -> Maybe DataType

Data constructor info

data DataCon

Simplified info about a Con. Omits deriving, strictness, and kind info. This is much nicer than consuming Con directly, because it unifies all the constructors into one.

Constructors

DataCon

Fields

• dcName :: Name
• dcTvs :: [Name]
• dcCxt :: Cxt
• dcFields :: [(Maybe Name, Type)]

Instances

Data DataCon

Defined in TH.ReifySimple

Methods

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

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

toConstr :: DataCon -> Constr

dataTypeOf :: DataCon -> DataType

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

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

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

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

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

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

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

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

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

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

Generic DataCon

Defined in TH.ReifySimple

Associated Types

type Rep DataCon :: Type -> Type

Methods

from :: DataCon -> Rep DataCon x

to :: Rep DataCon x -> DataCon

Show DataCon

Defined in TH.ReifySimple

Methods

showsPrec :: Int -> DataCon -> ShowS

show :: DataCon -> String

showList :: [DataCon] -> ShowS

Eq DataCon

Defined in TH.ReifySimple

Methods

(==) :: DataCon -> DataCon -> Bool

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

Ord DataCon

Defined in TH.ReifySimple

Methods

compare :: DataCon -> DataCon -> Ordering

(<) :: DataCon -> DataCon -> Bool

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

(>) :: DataCon -> DataCon -> Bool

(>=) :: DataCon -> DataCon -> Bool

max :: DataCon -> DataCon -> DataCon

min :: DataCon -> DataCon -> DataCon

type Rep DataCon

Defined in TH.ReifySimple

type Rep DataCon = D1 ('MetaData "DataCon" "TH.ReifySimple" "th-utilities-0.2.5.0-K0RNPnbhjz1AzY6uzY221h" 'False) (C1 ('MetaCons "DataCon" 'PrefixI 'True) ((S1 ('MetaSel ('Just "dcName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Just "dcTvs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :*: (S1 ('MetaSel ('Just "dcCxt") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt) :*: S1 ('MetaSel ('Just "dcFields") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Maybe Name, Type)]))))

reifyDataCon :: Name -> Q DataCon

Reify the given data constructor.

infoToDataCon :: Info -> Maybe DataCon

typeToDataCon :: Name -> Type -> DataCon

Creates a DataCon given the Name and Type of a data-constructor. Note that the result the function type is *not* checked to match the provided Name.

Data family info

data DataFamily

Simplified info about a data family. Omits deriving, strictness, and kind info.

Constructors

DataFamily

Fields

• dfName :: Name
• dfTvs :: [Name]
• dfInsts :: [DataInst]

Instances

Data DataFamily

Defined in TH.ReifySimple

Methods

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

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

toConstr :: DataFamily -> Constr

dataTypeOf :: DataFamily -> DataType

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

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

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

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

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

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

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

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

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

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

Generic DataFamily

Defined in TH.ReifySimple

Associated Types

type Rep DataFamily :: Type -> Type

Methods

from :: DataFamily -> Rep DataFamily x

to :: Rep DataFamily x -> DataFamily

Show DataFamily

Defined in TH.ReifySimple

Methods

showsPrec :: Int -> DataFamily -> ShowS

show :: DataFamily -> String

showList :: [DataFamily] -> ShowS

Eq DataFamily

Defined in TH.ReifySimple

Methods

(==) :: DataFamily -> DataFamily -> Bool

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

Ord DataFamily

Defined in TH.ReifySimple

Methods

compare :: DataFamily -> DataFamily -> Ordering

(<) :: DataFamily -> DataFamily -> Bool

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

(>) :: DataFamily -> DataFamily -> Bool

(>=) :: DataFamily -> DataFamily -> Bool

max :: DataFamily -> DataFamily -> DataFamily

min :: DataFamily -> DataFamily -> DataFamily

type Rep DataFamily

Defined in TH.ReifySimple

type Rep DataFamily = D1 ('MetaData "DataFamily" "TH.ReifySimple" "th-utilities-0.2.5.0-K0RNPnbhjz1AzY6uzY221h" 'False) (C1 ('MetaCons "DataFamily" 'PrefixI 'True) (S1 ('MetaSel ('Just "dfName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Just "dfTvs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Just "dfInsts") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DataInst]))))

data DataInst

Simplified info about a data family instance. Omits deriving, strictness, and kind info.

Constructors

DataInst

Fields

• diName :: Name
• diCxt :: Cxt
• diParams :: [Type]
• diCons :: [DataCon]

Instances

Data DataInst

Defined in TH.ReifySimple

Methods

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

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

toConstr :: DataInst -> Constr

dataTypeOf :: DataInst -> DataType

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

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

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

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

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

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

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

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

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

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

Generic DataInst

Defined in TH.ReifySimple

Associated Types

type Rep DataInst :: Type -> Type

Methods

from :: DataInst -> Rep DataInst x

to :: Rep DataInst x -> DataInst

Show DataInst

Defined in TH.ReifySimple

Methods

showsPrec :: Int -> DataInst -> ShowS

show :: DataInst -> String

showList :: [DataInst] -> ShowS

Eq DataInst

Defined in TH.ReifySimple

Methods

(==) :: DataInst -> DataInst -> Bool

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

Ord DataInst

Defined in TH.ReifySimple

Methods

compare :: DataInst -> DataInst -> Ordering

(<) :: DataInst -> DataInst -> Bool

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

(>) :: DataInst -> DataInst -> Bool

(>=) :: DataInst -> DataInst -> Bool

max :: DataInst -> DataInst -> DataInst

min :: DataInst -> DataInst -> DataInst

type Rep DataInst

Defined in TH.ReifySimple

type Rep DataInst = D1 ('MetaData "DataInst" "TH.ReifySimple" "th-utilities-0.2.5.0-K0RNPnbhjz1AzY6uzY221h" 'False) (C1 ('MetaCons "DataInst" 'PrefixI 'True) ((S1 ('MetaSel ('Just "diName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Just "diCxt") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cxt)) :*: (S1 ('MetaSel ('Just "diParams") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type]) :*: S1 ('MetaSel ('Just "diCons") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DataCon]))))

reifyDataFamily :: Name -> Q DataFamily

Reify the given data family, and yield its DataFamily representation.

infoToDataFamily :: Info -> Maybe DataFamily

Type family info

data TypeFamily

Simplified info about a type family. Omits kind info and injectivity info.

Constructors

TypeFamily

Fields

• tfName :: Name
• tfTvs :: [Name]
• tfInsts :: [TypeInst]

Instances

Data TypeFamily

Defined in TH.ReifySimple

Methods

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

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

toConstr :: TypeFamily -> Constr

dataTypeOf :: TypeFamily -> DataType

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

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

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

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

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

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

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

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

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

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

Generic TypeFamily

Defined in TH.ReifySimple

Associated Types

type Rep TypeFamily :: Type -> Type

Methods

from :: TypeFamily -> Rep TypeFamily x

to :: Rep TypeFamily x -> TypeFamily

Show TypeFamily

Defined in TH.ReifySimple

Methods

showsPrec :: Int -> TypeFamily -> ShowS

show :: TypeFamily -> String

showList :: [TypeFamily] -> ShowS

Eq TypeFamily

Defined in TH.ReifySimple

Methods

(==) :: TypeFamily -> TypeFamily -> Bool

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

Ord TypeFamily

Defined in TH.ReifySimple

Methods

compare :: TypeFamily -> TypeFamily -> Ordering

(<) :: TypeFamily -> TypeFamily -> Bool

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

(>) :: TypeFamily -> TypeFamily -> Bool

(>=) :: TypeFamily -> TypeFamily -> Bool

max :: TypeFamily -> TypeFamily -> TypeFamily

min :: TypeFamily -> TypeFamily -> TypeFamily

type Rep TypeFamily

Defined in TH.ReifySimple

type Rep TypeFamily = D1 ('MetaData "TypeFamily" "TH.ReifySimple" "th-utilities-0.2.5.0-K0RNPnbhjz1AzY6uzY221h" 'False) (C1 ('MetaCons "TypeFamily" 'PrefixI 'True) (S1 ('MetaSel ('Just "tfName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Just "tfTvs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Just "tfInsts") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TypeInst]))))

data TypeInst

Simplified info about a type family instance. Omits nothing.

Constructors

TypeInst

Fields

• tiName :: Name
• tiParams :: [Type]
• tiType :: Type

Instances

Data TypeInst

Defined in TH.ReifySimple

Methods

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

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

toConstr :: TypeInst -> Constr

dataTypeOf :: TypeInst -> DataType

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

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

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

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

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

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

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

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

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

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

Generic TypeInst

Defined in TH.ReifySimple

Associated Types

type Rep TypeInst :: Type -> Type

Methods

from :: TypeInst -> Rep TypeInst x

to :: Rep TypeInst x -> TypeInst

Show TypeInst

Defined in TH.ReifySimple

Methods

showsPrec :: Int -> TypeInst -> ShowS

show :: TypeInst -> String

showList :: [TypeInst] -> ShowS

Eq TypeInst

Defined in TH.ReifySimple

Methods

(==) :: TypeInst -> TypeInst -> Bool

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

Ord TypeInst

Defined in TH.ReifySimple

Methods

compare :: TypeInst -> TypeInst -> Ordering

(<) :: TypeInst -> TypeInst -> Bool

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

(>) :: TypeInst -> TypeInst -> Bool

(>=) :: TypeInst -> TypeInst -> Bool

max :: TypeInst -> TypeInst -> TypeInst

min :: TypeInst -> TypeInst -> TypeInst

type Rep TypeInst

Defined in TH.ReifySimple

type Rep TypeInst = D1 ('MetaData "TypeInst" "TH.ReifySimple" "th-utilities-0.2.5.0-K0RNPnbhjz1AzY6uzY221h" 'False) (C1 ('MetaCons "TypeInst" 'PrefixI 'True) (S1 ('MetaSel ('Just "tiName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Just "tiParams") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type]) :*: S1 ('MetaSel ('Just "tiType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))

reifyTypeFamily :: Name -> Q TypeFamily

Reify the given type family instance declaration, and yields its TypeInst representation.

infoToTypeFamily :: Info -> Maybe TypeFamily

Other utilities

conToDataCons :: Con -> [DataCon]

Convert a Con to a list of DataCon. The result is a list because GadtC and RecGadtC can define multiple constructors.

reifyDataTypeSubstituted :: Type -> Q DataType

Like reifyDataType, but takes a Type instead of just the Name of the datatype. It expects a normal datatype argument (see typeToNamedCon).