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

class GEnum opts f

Generic representation of Enum types.

The opts parameter is a type-level option to select different implementations.

Minimal complete definition

gCardinality, gFromEnum, gToEnum

Instances

GEnum opts (U1 :: Type -> Type)

Defined in Generic.Data.Internal.Enum

Methods

gCardinality :: Int

gFromEnum :: U1 p -> Int

gToEnum :: Int -> U1 p

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

Defined in Generic.Data.Internal.Enum

Methods

gCardinality :: Int

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

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

(Bounded c, Enum c) => GEnum FiniteEnum (K1 i c :: Type -> Type)

Defined in Generic.Data.Internal.Enum

Methods

gCardinality :: Int

gFromEnum :: K1 i c p -> Int

gToEnum :: Int -> K1 i c p

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

Defined in Generic.Data.Internal.Enum

Methods

gCardinality :: Int

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

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

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

Defined in Generic.Data.Internal.Enum

Methods

gCardinality :: Int

gFromEnum :: M1 i c f p -> Int

gToEnum :: Int -> M1 i c f p

StandardEnum option

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

data StandardEnum

Standard option for GEnum: derive Enum for types with only nullary constructors (the same restrictions as in the Haskell 2010 report).

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

Generic toEnum generated with the StandardEnum option.

instance Enum MyType where
  toEnum = gtoEnum
  fromEnum = gfromEnum
  enumFrom = genumFrom
  enumFromThen = genumFromThen
  enumFromTo = genumFromTo
  enumFromThenTo = genumFromThenTo

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

Generic fromEnum generated with the StandardEnum option.

See also gtoEnum.

genumFrom :: (Generic a, GEnum StandardEnum (Rep a)) => a -> [a]

Generic enumFrom generated with the StandardEnum option.

See also gtoEnum.

genumFromThen :: (Generic a, GEnum StandardEnum (Rep a)) => a -> a -> [a]

Generic enumFromThen generated with the StandardEnum option.

See also gtoEnum.

genumFromTo :: (Generic a, GEnum StandardEnum (Rep a)) => a -> a -> [a]

Generic enumFromTo generated with the StandardEnum option.

See also gtoEnum.

genumFromThenTo :: (Generic a, GEnum StandardEnum (Rep a)) => a -> a -> a -> [a]

Generic enumFromThenTo generated with the StandardEnum option.

See also gtoEnum.

FiniteEnum option

data FiniteEnum

Extends the StandardEnum option for GEnum to allow all constructors to have arbitrary many fields. Each field type must be an instance of both Enum and Bounded. Two restrictions require the user's caution:

• The Enum instances of the field types need to start enumerating from 0. Particularly Int is an unfit field type, because the enumeration of the negative values starts before 0.
• There can only be up to maxBound :: Int values (because the implementation represents the cardinality explicitly as an Int). This restriction makes Word an invalid field type. Notably, it is insufficient for each individual field types to stay below this limit. Instead it applies to the generic type as a whole.

The resulting GEnum instance starts enumerating from 0 up to (cardinality - 1) and respects the generic Ord instance (defined by gcompare). The values from different constructors are enumerated sequentially; they are not interleaved.

data Example = C0 Bool Bool | C1 Bool
  deriving (Eq, Ord, Show, Generic)

cardinality = 6  -- 2    * 2    + 2
                 -- Bool * Bool | Bool

enumeration =
    [ C0 False False
    , C0 False  True
    , C0  True False
    , C0  True  True
    , C1 False
    , C1 True
    ]

enumeration == map gtoFiniteEnum [0 .. 5]
[0 .. 5] == map gfromFiniteEnum enumeration

Instances

(Bounded c, Enum c) => GEnum FiniteEnum (K1 i c :: Type -> Type)

Defined in Generic.Data.Internal.Enum

Methods

gCardinality :: Int

gFromEnum :: K1 i c p -> Int

gToEnum :: Int -> K1 i c p

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

Defined in Generic.Data.Internal.Enum

Methods

gCardinality :: Int

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

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

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

Generic toEnum generated with the FiniteEnum option.

instance Enum MyType where
  toEnum = gtoFiniteEnum
  fromEnum = gfromFiniteEnum
  enumFrom = gfiniteEnumFrom
  enumFromThen = gfiniteEnumFromThen
  enumFromTo = gfiniteEnumFromTo
  enumFromThenTo = gfiniteEnumFromThenTo

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

Generic fromEnum generated with the FiniteEnum option.

See also gtoFiniteEnum.

gfiniteEnumFrom :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> [a]

Generic enumFrom generated with the FiniteEnum option.

See also gtoFiniteEnum.

gfiniteEnumFromThen :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> a -> [a]

Generic enumFromThen generated with the FiniteEnum option.

See also gtoFiniteEnum.

gfiniteEnumFromTo :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> a -> [a]

Generic enumFromTo generated with the FiniteEnum option.

See also gtoFiniteEnum.

gfiniteEnumFromThenTo :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> a -> a -> [a]

Generic enumFromThenTo generated with the FiniteEnum option.

See also gtoFiniteEnum.

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 :: Type -> Type)

Defined in Generic.Data.Internal.Enum

Methods

gMinBound :: U1 p

gMaxBound :: U1 p

Bounded c => GBounded (K1 i c :: Type -> Type)

Defined in Generic.Data.Internal.Enum

Methods

gMinBound :: K1 i c p

gMaxBound :: K1 i c p

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

Defined in Generic.Data.Internal.Enum

Methods

gMinBound :: (f :+: g) p

gMaxBound :: (f :+: g) p

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

Defined in Generic.Data.Internal.Enum

Methods

gMinBound :: (f :*: g) p

gMaxBound :: (f :*: g) p

GBounded f => GBounded (M1 i c f)

Defined in Generic.Data.Internal.Enum

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

Generic liftShowsPrec.

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)

Defined in Generic.Data.Internal.Resolvers

Methods

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

Ord1 f => Ord1 (Id1 f)

Defined in Generic.Data.Internal.Resolvers

Methods

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

Read1 f => Read1 (Id1 f)

Defined in Generic.Data.Internal.Resolvers

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)

Defined in Generic.Data.Internal.Resolvers

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)

Defined in Generic.Data.Internal.Resolvers

Methods

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

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

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

Defined in Generic.Data.Internal.Resolvers

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)

Defined in Generic.Data.Internal.Resolvers

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)

Defined in Generic.Data.Internal.Resolvers

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.

Defined in Generic.Data.Internal.Resolvers

Methods

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

Ord1 Opaque

All equal.

Defined in Generic.Data.Internal.Resolvers

Methods

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

Show1 Opaque

Shown as "_".

Defined in Generic.Data.Internal.Resolvers

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.

Defined in Generic.Data.Internal.Resolvers

Methods

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

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

Ord (Opaque a)

All equal.

Defined in Generic.Data.Internal.Resolvers

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 "_".

Defined in Generic.Data.Internal.Resolvers

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.

Defined in Generic.Data.Internal.Resolvers

Methods

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

Ord1 (Opaque1 f)

All equal.

Defined in Generic.Data.Internal.Resolvers

Methods

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

Show1 (Opaque1 f)

Shown as "_".

Defined in Generic.Data.Internal.Resolvers

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.

Defined in Generic.Data.Internal.Resolvers

Methods

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

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

Ord (Opaque1 f a)

All equal.

Defined in Generic.Data.Internal.Resolvers

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 "_".

Defined in Generic.Data.Internal.Resolvers

Methods

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

show :: Opaque1 f a -> String

showList :: [Opaque1 f a] -> ShowS

Carriers of generic instances

newtype Generically a

Type with instances derived via Generic.

Constructors

Generically

Fields

• unGenerically :: a

Instances

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

Defined in Generic.Data.Internal.Generically

Methods

minBound :: Generically a

maxBound :: Generically a

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

Defined in Generic.Data.Internal.Generically

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)

Defined in Generic.Data.Internal.Generically

Methods

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

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

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

Defined in Generic.Data.Internal.Generically

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)

Defined in Generic.Data.Internal.Generically

Methods

showsPrec :: Int -> Generically a -> ShowS

show :: Generically a -> String

showList :: [Generically a] -> ShowS

Generic a => Generic (Generically a)

Defined in Generic.Data.Internal.Generically

Associated Types

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

Methods

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

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

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

Defined in Generic.Data.Internal.Generically

Methods

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

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

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

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

This uses the Semigroup instance of the wrapped type a to define mappend. The purpose of this instance is to derive mempty, while remaining consistent with possibly custom Semigroup instances.

Defined in Generic.Data.Internal.Generically

Methods

mempty :: Generically a

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

mconcat :: [Generically a] -> Generically a

type Rep (Generically a)

Defined in Generic.Data.Internal.Generically

type Rep (Generically a) = Rep a

newtype FiniteEnumeration a

Type with Enum instance derived via Generic with FiniteEnum option.

Constructors

FiniteEnumeration

Fields

• unFiniteEnumeration :: a

Instances

(Generic a, GEnum FiniteEnum (Rep a)) => Enum (FiniteEnumeration a)

Defined in Generic.Data.Internal.Generically

Methods

succ :: FiniteEnumeration a -> FiniteEnumeration a

pred :: FiniteEnumeration a -> FiniteEnumeration a

toEnum :: Int -> FiniteEnumeration a

fromEnum :: FiniteEnumeration a -> Int

enumFrom :: FiniteEnumeration a -> [FiniteEnumeration a]

enumFromThen :: FiniteEnumeration a -> FiniteEnumeration a -> [FiniteEnumeration a]

enumFromTo :: FiniteEnumeration a -> FiniteEnumeration a -> [FiniteEnumeration a]

enumFromThenTo :: FiniteEnumeration a -> FiniteEnumeration a -> FiniteEnumeration a -> [FiniteEnumeration a]

Generic a => Generic (FiniteEnumeration a)

Defined in Generic.Data.Internal.Generically

Associated Types

type Rep (FiniteEnumeration a) :: Type -> Type

Methods

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

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

type Rep (FiniteEnumeration a)

Defined in Generic.Data.Internal.Generically

type Rep (FiniteEnumeration 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)

Defined in Generic.Data.Internal.Generically

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)

Defined in Generic.Data.Internal.Generically

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)

Defined in Generic.Data.Internal.Generically

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)

Defined in Generic.Data.Internal.Generically

Methods

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

sequenceA :: Applicative f0 => Generically1 f (f0 a) -> f0 (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)

Defined in Generic.Data.Internal.Generically

Methods

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

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

Defined in Generic.Data.Internal.Generically

Methods

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

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

Defined in Generic.Data.Internal.Generically

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)

Defined in Generic.Data.Internal.Generically

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 :: Type -> Type)

Defined in Generic.Data.Internal.Generically

Associated Types

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

Methods

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

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

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

Defined in Generic.Data.Internal.Generically

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)

Defined in Generic.Data.Internal.Generically

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)

Defined in Generic.Data.Internal.Generically

Methods

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

show :: Generically1 f a -> String

showList :: [Generically1 f a] -> ShowS

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

Defined in Generic.Data.Internal.Generically

Associated Types

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

Methods

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

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

type Rep1 (Generically1 f :: Type -> Type)

Defined in Generic.Data.Internal.Generically

type Rep1 (Generically1 f :: Type -> Type) = Rep1 f

type Rep (Generically1 f a)

Defined in Generic.Data.Internal.Generically

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

Newtype

Generic pack/unpack.

class (Generic a, Coercible a (Old a), Newtype' a) => Newtype a

Class of newtypes. There is an instance Newtype a if and only if a is a newtype and an instance of Generic.

Instances

(Generic a, Coercible a (Old a), Newtype' a) => Newtype a

Defined in Generic.Data.Internal.Newtype

pack :: Newtype a => Old a -> a

Generic newtype constructor.

unpack :: Newtype a => a -> Old a

Generic newtype destructor.

Generic coercions

gcoerce :: (Generic a, Generic b, Coercible (Rep a) (Rep b)) => a -> b

Convert between types with representationally equivalent generic representations.

gcoerceBinop :: (Generic a, Generic b, Coercible (Rep a) (Rep b)) => (a -> a -> a) -> b -> b -> b

Compose gcoerce with a binary operation.

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 d => GDatatype (M1 D d f :: k -> Type)

Defined in Generic.Data.Internal.Meta

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

gconIndex :: forall a. Constructors a => a -> Int

Index of a constructor.

gconIndex Nothing = 0
gconIndex (Just "test") = 1

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

Constraint synonym for Generic and GConstructors.

Instances

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

Defined in Generic.Data.Internal.Meta

class GConstructors r

Generic representations that contain constructor metadata.

Minimal complete definition

gConIdToString, gConId, gConNum, gConFixity, gConIsRecord

Instances

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

Defined in Generic.Data.Internal.Meta

Methods

gConIdToString :: GConId (f :+: g) -> String

gConId :: (f :+: g) p -> GConId (f :+: g)

gConNum :: Int

gConFixity :: (f :+: g) p -> Fixity

gConIsRecord :: (f :+: g) p -> Bool

Constructor c => GConstructors (M1 C c f :: k -> Type)

Defined in Generic.Data.Internal.Meta

Methods

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

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

gConNum :: Int

gConFixity :: M1 C c f p -> Fixity

gConIsRecord :: M1 C c f p -> Bool

GConstructors f => GConstructors (M1 D c f :: k -> Type)

Defined in Generic.Data.Internal.Meta

Methods

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

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

gConNum :: Int

gConFixity :: M1 D c f p -> Fixity

gConIsRecord :: M1 D c f p -> Bool

Constructor tags

data ConId a

An opaque identifier for a constructor.

Instances

Eq (ConId a)

Defined in Generic.Data.Internal.Meta

Methods

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

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

Ord (ConId a)

Defined in Generic.Data.Internal.Meta

Methods

compare :: ConId a -> ConId a -> Ordering

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

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

(>) :: ConId a -> ConId a -> Bool

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

max :: ConId a -> ConId a -> ConId a

min :: ConId a -> ConId a -> ConId a

conId :: forall a. Constructors a => a -> ConId a

Identifier of a constructor.

conIdToInt :: forall a. ConId a -> Int

Index of a constructor, given its identifier. See also gconIndex.

conIdToString :: forall a. Constructors a => ConId a -> String

Name of a constructor. See also gconName.

conIdEnum :: forall a. Constructors a => [ConId a]

All constructor identifiers.

gconNum @a = length (conIdEnum @a)

Using type families

type family MetaOf (f :: * -> *) :: Meta where ...

Meta field of the M1 type constructor.

Equations

MetaOf (M1 i d f) = d

type family MetaDataName (m :: Meta) :: Symbol where ...

Name of the data type (MetaData).

Equations

MetaDataName (MetaData n _m _p _nt) = n

type family MetaDataModule (m :: Meta) :: Symbol where ...

Name of the module where the data type is defined (MetaData)

Equations

MetaDataModule (MetaData _n m _p _nt) = m

type family MetaDataPackage (m :: Meta) :: Symbol where ...

Name of the package where the data type is defined (MetaData)

Equations

MetaDataPackage (MetaData _n _m p _nt) = p

type family MetaDataNewtype (m :: Meta) :: Bool where ...

True if the data type is a newtype (MetaData).

Equations

MetaDataNewtype (MetaData _n _m _p nt) = nt

type family MetaConsName (m :: Meta) :: Symbol where ...

Name of the constructor (MetaCons).

Equations

MetaConsName (MetaCons n _f _s) = n

type family MetaConsFixity (m :: Meta) :: FixityI where ...

Fixity of the constructor (MetaCons).

Equations

MetaConsFixity (MetaCons _n f s) = f

type family MetaConsRecord (m :: Meta) :: Bool where ...

True for a record constructor (MetaCons).

Equations

MetaConsRecord (MetaCons _n _f s) = s

type family MetaSelNameM (m :: Meta) :: Maybe Symbol where ...

Just the name of the record field, if it is one (MetaSel).

Equations

MetaSelNameM (MetaSel mn _su _ss _ds) = mn

type family MetaSelName (m :: Meta) :: Symbol where ...

Name of the record field; undefined for non-record fields (MetaSel).

Equations

MetaSelName (MetaSel (Just n) _su _ss _ds) = n

type family MetaSelUnpack (m :: Meta) :: SourceUnpackedness where ...

Unpackedness annotation of a field (MetaSel).

Equations

MetaSelUnpack (MetaSel _mn su _ss _ds) = su

type family MetaSelSourceStrictness (m :: Meta) :: SourceStrictness where ...

Strictness annotation of a field (MetaSel).

Equations

MetaSelSourceStrictness (MetaSel _mn _su ss _ds) = ss

type family MetaSelStrictness (m :: Meta) :: DecidedStrictness where ...

Inferred strictness of a field (MetaSel).

Equations

MetaSelStrictness (MetaSel _mn _su _ss ds) = ds