Generic.Data

Generic combinators to derive type class instances.

base classes that GHC can not derive instances for, as of version 8.2:

• Semigroup, Monoid, Applicative, Alternative, Eq1, Ord1, Show1.

On base < 4.12 (i.e., GHC < 8.6), import Generic.Data.Orphans to obtain instances needed internally to derive those.

GHC can derive instances for other classes here, although there may be types supported by one method but not the other or vice versa.

Regular classes

Semigroup

gmappend :: (Generic a, Semigroup (Rep a ())) => a -> a -> a

Generic (<>) (or mappend).

instance Semigroup MyType where
  (<>) = gmappend

See also gmempty.

Monoid

gmempty :: (Generic a, Monoid (Rep a ())) => a

Generic mempty.

instance Monoid MyType where
  mempty = gmempty

gmappend' :: (Generic a, Monoid (Rep a ())) => a -> a -> a

Generic (<>) (or mappend).

The difference from gmappend is the Monoid constraint instead of Semigroup, for older versions of base where Semigroup is not a superclass of Monoid.

Eq

Can also be derived by GHC as part of the standard.

geq :: (Generic a, Eq (Rep a ())) => a -> a -> Bool

Generic (==).

instance Eq MyType where
  (==) = geq

Ord

Can also be derived by GHC as part of the standard.

gcompare :: (Generic a, Ord (Rep a ())) => a -> a -> Ordering

Generic compare.

instance Ord MyType where
  compare = gcompare

Show

Can also be derived by GHC as part of the standard.

gshowsPrec :: (Generic a, GShow0 (Rep a)) => Int -> a -> ShowS

Generic showsPrec.

instance Show MyType where
  showsPrec = gshowsPrec

type GShow0 = GShow Proxy

Generic representation of Show types.

Enum

Can also be derived by GHC as part of the standard.

gfromEnum :: (Generic a, GEnum (Rep a)) => a -> Int

Generic fromEnum.

See also gtoEnum.

gtoEnum :: forall a. (Generic a, GEnum (Rep a)) => Int -> a

Generic toEnum.

instance Enum MyType where
  toEnum = gtoEnum
  fromEnum = gfromEnum

class GEnum f

Generic representation of Enum types.

Minimal complete definition

gCardinality, gFromEnum, gToEnum

Instances

GEnum (U1 *)

Methods

gCardinality :: proxy (U1 *) -> Int

gFromEnum :: U1 * p -> Int

gToEnum :: Int -> U1 * p

(GEnum f, GEnum g) => GEnum ((:+:) * f g)

Methods

gCardinality :: proxy ((* :+: f) g) -> Int

gFromEnum :: (* :+: f) g p -> Int

gToEnum :: Int -> (* :+: f) g p

GEnum f => GEnum (M1 * i c f)

Methods

gCardinality :: proxy (M1 * i c f) -> Int

gFromEnum :: M1 * i c f p -> Int

gToEnum :: Int -> M1 * i c f p

Bounded

Can also be derived by GHC as part of the standard.

gminBound :: (Generic a, GBounded (Rep a)) => a

Generic minBound.

instance Bounded MyType where
  minBound = gminBound
  maxBound = gmaxBound

gmaxBound :: (Generic a, GBounded (Rep a)) => a

Generic maxBound.

See also gminBound.

class GBounded f

Generic representation of Bounded types.

Minimal complete definition

gMinBound, gMaxBound

Instances

GBounded (U1 *)

Methods

gMinBound :: U1 * p

gMaxBound :: U1 * p

Bounded c => GBounded (K1 * i c)

Methods

gMinBound :: K1 * i c p

gMaxBound :: K1 * i c p

(GBounded f, GBounded g) => GBounded ((:+:) * f g)

Methods

gMinBound :: (* :+: f) g p

gMaxBound :: (* :+: f) g p

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

Methods

gMinBound :: (* :*: f) g p

gMaxBound :: (* :*: f) g p

GBounded f => GBounded (M1 * i c f)

Methods

gMinBound :: M1 * i c f p

gMaxBound :: M1 * i c f p

Higher-kinded classes

Functor

Can also be derived by GHC (DeriveFunctor extension).

gfmap :: (Generic1 f, Functor (Rep1 f)) => (a -> b) -> f a -> f b

Generic fmap.

instance Functor MyTypeF where
  fmap = gfmap

gconstmap :: (Generic1 f, Functor (Rep1 f)) => a -> f b -> f a

Generic (<$).

See also gfmap.

Foldable

Can also be derived by GHC (DeriveFoldable extension).

gfoldMap :: (Generic1 f, Foldable (Rep1 f), Monoid m) => (a -> m) -> f a -> m

Generic foldMap.

instance Foldable MyTypeF where
  foldMap = gfoldMap

gfoldr :: (Generic1 f, Foldable (Rep1 f)) => (a -> b -> b) -> b -> f a -> b

Generic foldr.

instance Foldable MyTypeF where
  foldr = gfoldr

See also gfoldMap.

Traversable

Can also be derived by GHC (DeriveTraversable extension).

gtraverse :: (Generic1 f, Traversable (Rep1 f), Applicative m) => (a -> m b) -> f a -> m (f b)

Generic traverse.

instance Traversable MyTypeF where
  traverse = gtraverse

gsequenceA :: (Generic1 f, Traversable (Rep1 f), Applicative m) => f (m a) -> m (f a)

Generic sequenceA.

instance Traversable MyTypeF where
  sequenceA = gsequenceA

See also gtraverse.

Applicative

gpure :: (Generic1 f, Applicative (Rep1 f)) => a -> f a

Generic pure.

instance Applicative MyTypeF where
  pure = gpure
  (<*>) = gap

gap :: (Generic1 f, Applicative (Rep1 f)) => f (a -> b) -> f a -> f b

Generic (<*>) (or ap).

See also gpure.

gliftA2 :: (Generic1 f, Applicative (Rep1 f)) => (a -> b -> c) -> f a -> f b -> f c

Generic liftA2.

See also gpure.

Alternative

gempty :: (Generic1 f, Alternative (Rep1 f)) => f a

Generic empty.

instance Alternative MyTypeF where
  empty = gempty
  (<|>) = galt

galt :: (Generic1 f, Alternative (Rep1 f)) => f a -> f a -> f a

Generic (<|>).

See also gempty.

Eq1

gliftEq :: (Generic1 f, Eq1 (Rep1 f)) => (a -> b -> Bool) -> f a -> f b -> Bool

Generic liftEq.

Ord1

gliftCompare :: (Generic1 f, Ord1 (Rep1 f)) => (a -> b -> Ordering) -> f a -> f b -> Ordering

Generic liftCompare.

Show1

gliftShowsPrec :: (Generic1 f, GShow1 (Rep1 f)) => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS

type GShow1 = GShow Identity

Generic representation of Show1 types.

Fields wrappers for deriving

newtype Id1 f a

A newtype whose instances for simple classes (Eq, Ord, Read, Show) use higher-kinded class instances for f (Eq1, Ord1, Read1, Show1).

Constructors

Id1

Fields

• unId1 :: f a

Instances

Eq1 f => Eq1 (Id1 f)

Methods

liftEq :: (a -> b -> Bool) -> Id1 f a -> Id1 f b -> Bool

Ord1 f => Ord1 (Id1 f)

Methods

liftCompare :: (a -> b -> Ordering) -> Id1 f a -> Id1 f b -> Ordering

Read1 f => Read1 (Id1 f)

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Id1 f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Id1 f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Id1 f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Id1 f a]

Show1 f => Show1 (Id1 f)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Id1 f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Id1 f a] -> ShowS

(Eq1 f, Eq a) => Eq (Id1 f a)

Methods

(==) :: Id1 f a -> Id1 f a -> Bool

(/=) :: Id1 f a -> Id1 f a -> Bool

(Ord1 f, Ord a) => Ord (Id1 f a)

Methods

compare :: Id1 f a -> Id1 f a -> Ordering

(<) :: Id1 f a -> Id1 f a -> Bool

(<=) :: Id1 f a -> Id1 f a -> Bool

(>) :: Id1 f a -> Id1 f a -> Bool

(>=) :: Id1 f a -> Id1 f a -> Bool

max :: Id1 f a -> Id1 f a -> Id1 f a

min :: Id1 f a -> Id1 f a -> Id1 f a

(Read1 f, Read a) => Read (Id1 f a)

Methods

readsPrec :: Int -> ReadS (Id1 f a)

readList :: ReadS [Id1 f a]

readPrec :: ReadPrec (Id1 f a)

readListPrec :: ReadPrec [Id1 f a]

(Show1 f, Show a) => Show (Id1 f a)

Methods

showsPrec :: Int -> Id1 f a -> ShowS

show :: Id1 f a -> String

showList :: [Id1 f a] -> ShowS

newtype Opaque a

A newtype with trivial instances, that considers every value equivalent to every other one, and shows as just "_".

Constructors

Opaque

Fields

• unOpaque :: a

Instances

Eq1 Opaque

All equal.

Methods

liftEq :: (a -> b -> Bool) -> Opaque a -> Opaque b -> Bool

Ord1 Opaque

All equal.

Methods

liftCompare :: (a -> b -> Ordering) -> Opaque a -> Opaque b -> Ordering

Show1 Opaque

Shown as "_".

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Opaque a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Opaque a] -> ShowS

Eq (Opaque a)

All equal.

Methods

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

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

Ord (Opaque a)

All equal.

Methods

compare :: Opaque a -> Opaque a -> Ordering

(<) :: Opaque a -> Opaque a -> Bool

(<=) :: Opaque a -> Opaque a -> Bool

(>) :: Opaque a -> Opaque a -> Bool

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

max :: Opaque a -> Opaque a -> Opaque a

min :: Opaque a -> Opaque a -> Opaque a

Show (Opaque a)

Shown as "_".

Methods

showsPrec :: Int -> Opaque a -> ShowS

show :: Opaque a -> String

showList :: [Opaque a] -> ShowS

newtype Opaque1 f a

A higher-kinded version of Opaque.

Constructors

Opaque1

Fields

• unOpaque1 :: f a

Instances

Eq1 (Opaque1 f)

All equal.

Methods

liftEq :: (a -> b -> Bool) -> Opaque1 f a -> Opaque1 f b -> Bool

Ord1 (Opaque1 f)

All equal.

Methods

liftCompare :: (a -> b -> Ordering) -> Opaque1 f a -> Opaque1 f b -> Ordering

Show1 (Opaque1 f)

Shown as "_".

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Opaque1 f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Opaque1 f a] -> ShowS

Eq (Opaque1 f a)

All equal.

Methods

(==) :: Opaque1 f a -> Opaque1 f a -> Bool

(/=) :: Opaque1 f a -> Opaque1 f a -> Bool

Ord (Opaque1 f a)

All equal.

Methods

compare :: Opaque1 f a -> Opaque1 f a -> Ordering

(<) :: Opaque1 f a -> Opaque1 f a -> Bool

(<=) :: Opaque1 f a -> Opaque1 f a -> Bool

(>) :: Opaque1 f a -> Opaque1 f a -> Bool

(>=) :: Opaque1 f a -> Opaque1 f a -> Bool

max :: Opaque1 f a -> Opaque1 f a -> Opaque1 f a

min :: Opaque1 f a -> Opaque1 f a -> Opaque1 f a

Show (Opaque1 f a)

Shown as "_".

Methods

showsPrec :: Int -> Opaque1 f a -> ShowS

show :: Opaque1 f a -> String

showList :: [Opaque1 f a] -> ShowS

Newtypes

newtype Generically a

Type with instances derived via Generic.

Constructors

Generically

Fields

• unGenerically :: a

Instances

(Generic a, GBounded (Rep a)) => Bounded (Generically a)

Methods

minBound :: Generically a

maxBound :: Generically a

(Generic a, GEnum (Rep a)) => Enum (Generically a)

Methods

succ :: Generically a -> Generically a

pred :: Generically a -> Generically a

toEnum :: Int -> Generically a

fromEnum :: Generically a -> Int

enumFrom :: Generically a -> [Generically a]

enumFromThen :: Generically a -> Generically a -> [Generically a]

enumFromTo :: Generically a -> Generically a -> [Generically a]

enumFromThenTo :: Generically a -> Generically a -> Generically a -> [Generically a]

(Generic a, Eq (Rep a ())) => Eq (Generically a)

Methods

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

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

(Generic a, Ord (Rep a ())) => Ord (Generically a)

Methods

compare :: Generically a -> Generically a -> Ordering

(<) :: Generically a -> Generically a -> Bool

(<=) :: Generically a -> Generically a -> Bool

(>) :: Generically a -> Generically a -> Bool

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

max :: Generically a -> Generically a -> Generically a

min :: Generically a -> Generically a -> Generically a

(Generic a, GShow0 (Rep a)) => Show (Generically a)

Methods

showsPrec :: Int -> Generically a -> ShowS

show :: Generically a -> String

showList :: [Generically a] -> ShowS

Generic a => Generic (Generically a)

Associated Types

type Rep (Generically a) :: * -> *

Methods

from :: Generically a -> Rep (Generically a) x

to :: Rep (Generically a) x -> Generically a

(Generic a, Semigroup (Rep a ())) => Semigroup (Generically a)

Methods

(<>) :: Generically a -> Generically a -> Generically a

sconcat :: NonEmpty (Generically a) -> Generically a

stimes :: Integral b => b -> Generically a -> Generically a

(Generic a, Monoid (Rep a ())) => Monoid (Generically a)

Methods

mempty :: Generically a

mappend :: Generically a -> Generically a -> Generically a

mconcat :: [Generically a] -> Generically a

type Rep (Generically a)

type Rep (Generically a) = Rep a

newtype Generically1 f a

Type with instances derived via Generic1.

Constructors

Generically1

Fields

• unGenerically1 :: f a

Instances

(Generic1 * f, Functor (Rep1 * f)) => Functor (Generically1 f)

Methods

fmap :: (a -> b) -> Generically1 f a -> Generically1 f b

(<$) :: a -> Generically1 f b -> Generically1 f a

(Generic1 * f, Applicative (Rep1 * f)) => Applicative (Generically1 f)

Methods

pure :: a -> Generically1 f a

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

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

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

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

(Generic1 * f, Foldable (Rep1 * f)) => Foldable (Generically1 f)

Methods

fold :: Monoid m => Generically1 f m -> m

foldMap :: Monoid m => (a -> m) -> Generically1 f a -> m

foldr :: (a -> b -> b) -> b -> Generically1 f a -> b

foldr' :: (a -> b -> b) -> b -> Generically1 f a -> b

foldl :: (b -> a -> b) -> b -> Generically1 f a -> b

foldl' :: (b -> a -> b) -> b -> Generically1 f a -> b

foldr1 :: (a -> a -> a) -> Generically1 f a -> a

foldl1 :: (a -> a -> a) -> Generically1 f a -> a

toList :: Generically1 f a -> [a]

null :: Generically1 f a -> Bool

length :: Generically1 f a -> Int

elem :: Eq a => a -> Generically1 f a -> Bool

maximum :: Ord a => Generically1 f a -> a

minimum :: Ord a => Generically1 f a -> a

sum :: Num a => Generically1 f a -> a

product :: Num a => Generically1 f a -> a

(Generic1 * f, Traversable (Rep1 * f)) => Traversable (Generically1 f)

Methods

traverse :: Applicative f => (a -> f b) -> Generically1 f a -> f (Generically1 f b)

sequenceA :: Applicative f => Generically1 f (f a) -> f (Generically1 f a)

mapM :: Monad m => (a -> m b) -> Generically1 f a -> m (Generically1 f b)

sequence :: Monad m => Generically1 f (m a) -> m (Generically1 f a)

(Generic1 * f, Eq1 (Rep1 * f)) => Eq1 (Generically1 f)

Methods

liftEq :: (a -> b -> Bool) -> Generically1 f a -> Generically1 f b -> Bool

(Generic1 * f, Ord1 (Rep1 * f)) => Ord1 (Generically1 f)

Methods

liftCompare :: (a -> b -> Ordering) -> Generically1 f a -> Generically1 f b -> Ordering

(Generic1 * f, GShow1 (Rep1 * f)) => Show1 (Generically1 f)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Generically1 f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Generically1 f a] -> ShowS

(Generic1 * f, Alternative (Rep1 * f)) => Alternative (Generically1 f)

Methods

empty :: Generically1 f a

(<|>) :: Generically1 f a -> Generically1 f a -> Generically1 f a

some :: Generically1 f a -> Generically1 f [a]

many :: Generically1 f a -> Generically1 f [a]

Generic1 * f => Generic1 * (Generically1 f)

Associated Types

type Rep1 (Generically1 f) (f :: Generically1 f -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (Generically1 f) f a

to1 :: Rep1 (Generically1 f) f a -> f a

(Generic1 * f, Eq1 (Rep1 * f), Eq a) => Eq (Generically1 f a)

Methods

(==) :: Generically1 f a -> Generically1 f a -> Bool

(/=) :: Generically1 f a -> Generically1 f a -> Bool

(Generic1 * f, Ord1 (Rep1 * f), Ord a) => Ord (Generically1 f a)

Methods

compare :: Generically1 f a -> Generically1 f a -> Ordering

(<) :: Generically1 f a -> Generically1 f a -> Bool

(<=) :: Generically1 f a -> Generically1 f a -> Bool

(>) :: Generically1 f a -> Generically1 f a -> Bool

(>=) :: Generically1 f a -> Generically1 f a -> Bool

max :: Generically1 f a -> Generically1 f a -> Generically1 f a

min :: Generically1 f a -> Generically1 f a -> Generically1 f a

(Generic1 * f, GShow1 (Rep1 * f), Show a) => Show (Generically1 f a)

Methods

showsPrec :: Int -> Generically1 f a -> ShowS

show :: Generically1 f a -> String

showList :: [Generically1 f a] -> ShowS

Generic (f a) => Generic (Generically1 f a)

Associated Types

type Rep (Generically1 f a) :: * -> *

Methods

from :: Generically1 f a -> Rep (Generically1 f a) x

to :: Rep (Generically1 f a) x -> Generically1 f a

type Rep1 * (Generically1 f)

type Rep1 * (Generically1 f) = Rep1 * f

type Rep (Generically1 f a)

type Rep (Generically1 f a) = Rep (f a)

Accessing metadata

Using TypeApplications.

Datatype

gdatatypeName :: forall a. (Generic a, GDatatype (Rep a)) => String

Name of the first data constructor in a type as a string.

gdatatypeName @(Maybe AnyType) = "Maybe"

gmoduleName :: forall a. (Generic a, GDatatype (Rep a)) => String

Name of the module where the first type constructor is defined.

gmoduleName @(Maybe AnyType) = "GHC.Base"

gpackageName :: forall a. (Generic a, GDatatype (Rep a)) => String

Name of the package where the first type constructor is defined.

gpackageName @(Maybe AnyType) = "base"

gisNewtype :: forall a. (Generic a, GDatatype (Rep a)) => Bool

True if the first type constructor is a newtype.

class GDatatype f

Generic representations that contain datatype metadata.

Minimal complete definition

gDatatypeName, gModuleName, gPackageName, gIsNewtype

Instances

Datatype Meta d => GDatatype (k -> *) (M1 k D d f)

Methods

gDatatypeName :: String

gModuleName :: String

gPackageName :: String

gIsNewtype :: Bool

Constructor

gconName :: forall a. Constructors a => a -> String

Name of the first constructor in a value.

gconName (Just 0) = "Just"

gconFixity :: forall a. Constructors a => a -> Fixity

The fixity of the first constructor.

gconFixity (Just 0) = Prefix
gconFixity ([] :*: id) = Infix RightAssociative 6

gconIsRecord :: forall a. Constructors a => a -> Bool

True if the constructor is a record.

gconIsRecord (Just 0) = False
gconIsRecord (Sum 0) = True
-- newtype Sum a = Sum { getSum :: a }

gconNum :: forall a. Constructors a => Int

Number of constructors.

gconNum @(Maybe AnyType) = 2

class (Generic a, GConstructors (Rep a)) => Constructors a

Constraint synonym for Generic and GConstructor.

Instances

(Generic a, GConstructors * (Rep a)) => Constructors a

class GConstructors r

Generic representations that contain constructor metadata.

Minimal complete definition

gConIdToString, gConId, gConNum, gConFixity, gConIsRecord

Instances

(GConstructors k f, GConstructors k g) => GConstructors k ((:+:) k f g)

Methods

gConIdToString :: GConId ((k :+: f) g -> *) r -> String

gConId :: r p -> GConId ((k :+: f) g -> *) r

gConNum :: Int

gConFixity :: r p -> Fixity

gConIsRecord :: r p -> Bool

Constructor Meta c => GConstructors k (M1 k C c f)

Methods

gConIdToString :: GConId (M1 k C c f -> *) r -> String

gConId :: r p -> GConId (M1 k C c f -> *) r

gConNum :: Int

gConFixity :: r p -> Fixity

gConIsRecord :: r p -> Bool

GConstructors k f => GConstructors k (M1 k D c f)

Methods

gConIdToString :: GConId (M1 k D c f -> *) r -> String

gConId :: r p -> GConId (M1 k D c f -> *) r

gConNum :: Int

gConFixity :: r p -> Fixity

gConIsRecord :: r p -> Bool