Generic.Data

Generic combinators to derive type class instances.

Orphans

The Orphans module should be imported to derive the following classes using this library:

• Eq1 and Ord1
• Semigroup and Monoid on GHC 8.4 or older (base <= 4.11)

Minor discrepancies

Here are documented some corner cases of deriving, both by GHC and generic-data. They are all minor and unlikely to cause problems in practice.

Empty types

• Some of the derived methods are lazy, which might result in errors being silenced, though unlikely.
• The only generic-data implementation which differs from GHC stock instances is gfoldMap.

Class method	GHC stock	generic-data	Comment
(==)	lazy	lazy	True
compare	lazy	lazy	EQ
fmap	strict	strict	must be bottom anyway
foldMap	lazy	strict	mempty if lazy
foldr	lazy	lazy	returns accumulator
traverse	strict	strict
sequenceA	strict	strict

Single-constructor single-field types

data types with one constructor and one field are extremely rare. newtype is almost always more appropriate (for which there is no issue).

That said, for data types both strict and lazy, all generic-data implementations are lazy (they don't even force the constructor), whereas GHC stock implementations, when they exist, are strict.

Functor composition

Fields of functors involving the composition of two or more functors f (g (h a)) result in some overhead using GHC.Generics.Generic1.

This is due to a particular encoding choice of GHC.Generics, where composition are nested to the right instead of to the left. f (g (h _)) is represented by the functor f :.: (g :.: Rec1 h), so one must use fmap on f to convert that back to f (g (h _)). A better choice would have been to encode it as (Rec1 f :.: g) :.: h, because that is coercible back to f (g (h _)).

Newtypes for Deriving Via

newtype Generically a

A datatype whose instances are defined generically, using the Generic representation. Generically1 is a higher-kinded version of Generically that uses Generic1.

Generic instances can be derived via Generically A using -XDerivingVia.

{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia        #-}

import GHC.Generics (Generic)

data V4 a = V4 a a a a
  deriving stock Generic

  deriving (Semigroup, Monoid)
  via Generically (V4 a)

This corresponds to Semigroup and Monoid instances defined by pointwise lifting:

instance Semigroup a => Semigroup (V4 a) where
  (<>) :: V4 a -> V4 a -> V4 a
  V4 a1 b1 c1 d1 <> V4 a2 b2 c2 d2 =
    V4 (a1 <> a2) (b1 <> b2) (c1 <> c2) (d1 <> d2)

instance Monoid a => Monoid (V4 a) where
  mempty :: V4 a
  mempty = V4 mempty mempty mempty mempty

Historically this required modifying the type class to include generic method definitions (-XDefaultSignatures) and deriving it with the anyclass strategy (-XDeriveAnyClass). Having a /via type/ like Generically decouples the instance from the type class.

Since: base-4.17.0.0

Constructors

Generically a

Instances

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

Since: base-4.17.0.0

Defined in GHC.Generics

Methods

mempty :: Generically a

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

mconcat :: [Generically a] -> Generically a

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

Since: base-4.17.0.0

Defined in GHC.Generics

Methods

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

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

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

(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 => Generic (Generically a)

This is a hack to implicitly wrap/unwrap in the instances of Generically.

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, Ord (Rep a ()), GIx (Rep a)) => Ix (Generically a)

Defined in Generic.Data.Internal.Generically

Methods

range :: (Generically a, Generically a) -> [Generically a]

index :: (Generically a, Generically a) -> Generically a -> Int

unsafeIndex :: (Generically a, Generically a) -> Generically a -> Int

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

rangeSize :: (Generically a, Generically a) -> Int

unsafeRangeSize :: (Generically a, Generically a) -> Int

(Generic a, GRead0 (Rep a)) => Read (Generically a)

Defined in Generic.Data.Internal.Generically

Methods

readsPrec :: Int -> ReadS (Generically a)

readList :: ReadS [Generically a]

readPrec :: ReadPrec (Generically a)

readListPrec :: ReadPrec [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, 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

type Rep (Generically a)

Defined in Generic.Data.Internal.Generically

type Rep (Generically a) = Rep a

newtype GenericProduct a

Product type with generic instances of Semigroup and Monoid.

This is similar to Generically in most cases, but GenericProduct also works for types T with deriving via GenericProduct U, where U is a generic product type coercible to, but distinct from T. In particular, U may not have an instance of Semigroup, which Generically requires.

Example

>>> import Data.Monoid (Sum(..))
>>> data Point a = Point a a deriving Generic
>>> :{
  newtype Vector a = Vector (Point a)
    deriving (Semigroup, Monoid)
      via GenericProduct (Point (Sum a))
:}

If it were via Generically (Point (Sum a)) instead, then Vector's mappend (the Monoid method) would be defined as Point's (<>) (the Semigroup method), which might not exist, or might not be equivalent to Vector's generic Semigroup instance, which would be unlawful.

Constructors

GenericProduct a

Instances

(AssertNoSum Semigroup a, Generic a, Monoid (Rep a ())) => Monoid (GenericProduct a)

Defined in Generic.Data.Internal.Generically

Methods

mempty :: GenericProduct a

mappend :: GenericProduct a -> GenericProduct a -> GenericProduct a

mconcat :: [GenericProduct a] -> GenericProduct a

(AssertNoSum Semigroup a, Generic a, Semigroup (Rep a ())) => Semigroup (GenericProduct a)

Defined in Generic.Data.Internal.Generically

Methods

(<>) :: GenericProduct a -> GenericProduct a -> GenericProduct a

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

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

Generic a => Generic (GenericProduct a)

Defined in Generic.Data.Internal.Generically

Associated Types

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

Methods

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

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

type Rep (GenericProduct a)

Defined in Generic.Data.Internal.Generically

type Rep (GenericProduct a) = Rep a

newtype FiniteEnumeration a

Type with Enum instance derived via Generic with FiniteEnum option. This allows deriving Enum for types whose constructors have fields.

Some caution is advised; see details in FiniteEnum.

Example

>>> :{
data Booool = Booool Bool Bool
  deriving Generic
  deriving (Enum, Bounded) via (FiniteEnumeration Booool)
:}

Constructors

FiniteEnumeration a

Instances

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

The same instance as Generically, for convenience.

Defined in Generic.Data.Internal.Generically

Methods

minBound :: FiniteEnumeration a

maxBound :: FiniteEnumeration a

(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 :: k -> Type) (a :: k) where

A type whose instances are defined generically, using the Generic1 representation. Generically1 is a higher-kinded version of Generically that uses Generic.

Generic instances can be derived for type constructors via Generically1 F using -XDerivingVia.

{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia        #-}

import GHC.Generics (Generic)

data V4 a = V4 a a a a
  deriving stock (Functor, Generic1)

  deriving Applicative
  via Generically1 V4

This corresponds to Applicative instances defined by pointwise lifting:

instance Applicative V4 where
  pure :: a -> V4 a
  pure a = V4 a a a a

  liftA2 :: (a -> b -> c) -> (V4 a -> V4 b -> V4 c)
  liftA2 (·) (V4 a1 b1 c1 d1) (V4 a2 b2 c2 d2) =
    V4 (a1 · a2) (b1 · b2) (c1 · c2) (d1 · d2)

Historically this required modifying the type class to include generic method definitions (-XDefaultSignatures) and deriving it with the anyclass strategy (-XDeriveAnyClass). Having a /via type/ like Generically1 decouples the instance from the type class.

Since: base-4.17.0.0

Constructors

Generically1 :: forall {k} (f :: k -> Type) (a :: k). f a -> Generically1 f a

Instances

Generic1 f => Generic1 (Generically1 f :: Type -> Type)

This is a hack to implicitly wrap/unwrap in the instances of Generically1.

Defined in Generic.Data.Internal.Generically

Associated Types

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

Methods

from1 :: forall (a :: k). Generically1 f a -> Rep1 (Generically1 f) a

to1 :: forall (a :: k). Rep1 (Generically1 f) a -> Generically1 f a

(Generic1 f, GFoldable (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

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, Eq1 (Rep1 f)) => Eq1 (Generically1 f)

Since: base-4.17.0.0

Defined in Data.Functor.Classes

Methods

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

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

Since: base-4.17.0.0

Defined in Data.Functor.Classes

Methods

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

(Generic1 f, GRead1 (Rep1 f)) => Read1 (Generically1 f)

Defined in Generic.Data.Internal.Generically

Methods

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

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

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

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

(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, Functor (Rep1 f), GFoldable (Rep1 f), GTraversable (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, Alternative (Rep1 f)) => Alternative (Generically1 f)

Since: base-4.17.0.0

Defined in GHC.Generics

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, Applicative (Rep1 f)) => Applicative (Generically1 f)

Since: base-4.17.0.0

Defined in GHC.Generics

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, Functor (Rep1 f)) => Functor (Generically1 f)

Since: base-4.17.0.0

Defined in GHC.Generics

Methods

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

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

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

This is a hack to implicitly wrap/unwrap in the instances of Generically1.

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

(Generic1 f, GRead1 (Rep1 f), Read a) => Read (Generically1 f a)

Defined in Generic.Data.Internal.Generically

Methods

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

readList :: ReadS [Generically1 f a]

readPrec :: ReadPrec (Generically1 f a)

readListPrec :: ReadPrec [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

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

Since: base-4.18.0.0

Defined in GHC.Generics

Methods

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

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

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

Since: base-4.18.0.0

Defined in GHC.Generics

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

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)

Regular classes

Default implementations for classes indexed by types (kind Type).

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

Read

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

greadPrec :: (Generic a, GRead0 (Rep a)) => ReadPrec a

Generic readPrec.

instance Read MyType where
  readPrec = greadPrec
  readListPrec = readListPrecDefault

type GRead0 = GRead Proxy

Generic representation of Read types.

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 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

(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 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

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 :: (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. Avoid fields of types Int and Word.

Details

Two restrictions require the user's attention:

• The Enum instances of the field types need to start enumerating from 0. In particular, 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 as well. Notably, it is insufficient for each individual field types to stay below this limit. Instead it applies to the generic type as a whole.

Elements are numbered by toEnum, from 0 up to (cardinality - 1). The resulting ordering matches the generic Ord instance defined by gcompare. The values from different constructors are enumerated sequentially.

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

(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

(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

gtoFiniteEnum :: (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

(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

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 (M1 i c f)

Defined in Generic.Data.Internal.Enum

Methods

gMinBound :: M1 i c f p

gMaxBound :: M1 i c f p

Ix

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

grange :: (Generic a, GIx (Rep a)) => (a, a) -> [a]

Generic range.

import Data.Ix
instance Ix MyType where
  range = grange
  index = gindex
  inRange = ginRange

gindex :: (Generic a, GIx (Rep a)) => (a, a) -> a -> Int

Generic index.

See also grange.

ginRange :: (Generic a, GIx (Rep a)) => (a, a) -> a -> Bool

Generic inRange.

See also grange.

class GIx f

Generic representation of Ix types.

Minimal complete definition

gRange, gUnsafeIndex, gInRange

Instances

GIx (U1 :: Type -> Type)

Defined in Generic.Data.Internal.Enum

Methods

gRange :: (U1 p, U1 p) -> [U1 p]

gUnsafeIndex :: (U1 p, U1 p) -> U1 p -> Int

gInRange :: (U1 p, U1 p) -> U1 p -> Bool

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

Defined in Generic.Data.Internal.Enum

Methods

gRange :: ((f :*: g) p, (f :*: g) p) -> [(f :*: g) p]

gUnsafeIndex :: ((f :*: g) p, (f :*: g) p) -> (f :*: g) p -> Int

gInRange :: ((f :*: g) p, (f :*: g) p) -> (f :*: g) p -> Bool

(GEnum StandardEnum f, GEnum StandardEnum g) => GIx (f :+: g)

Defined in Generic.Data.Internal.Enum

Methods

gRange :: ((f :+: g) p, (f :+: g) p) -> [(f :+: g) p]

gUnsafeIndex :: ((f :+: g) p, (f :+: g) p) -> (f :+: g) p -> Int

gInRange :: ((f :+: g) p, (f :+: g) p) -> (f :+: g) p -> Bool

Ix c => GIx (K1 i c :: Type -> Type)

Defined in Generic.Data.Internal.Enum

Methods

gRange :: (K1 i c p, K1 i c p) -> [K1 i c p]

gUnsafeIndex :: (K1 i c p, K1 i c p) -> K1 i c p -> Int

gInRange :: (K1 i c p, K1 i c p) -> K1 i c p -> Bool

GIx f => GIx (M1 i c f)

Defined in Generic.Data.Internal.Enum

Methods

gRange :: (M1 i c f p, M1 i c f p) -> [M1 i c f p]

gUnsafeIndex :: (M1 i c f p, M1 i c f p) -> M1 i c f p -> Int

gInRange :: (M1 i c f p, M1 i c f p) -> M1 i c f p -> Bool

gunsafeIndex :: (Generic a, GIx (Rep a)) => (a, a) -> a -> Int

Generic unsafeIndex.

Details

The functions unsafeIndex and unsafeRangeSize belong to Ix but are internal to GHC and hence not exported from the module Data.Ix. However they are exported from the module GHC.Arr. See grange for how to define an instance of Ix such that it does not depend on the stability of GHCs internal API. Unfortunately this results in additional (unnecessary) bound checks. With the danger of having no stability guarantees for GHC's internal API one can alternatively define an instance of Ix as

import GHC.Arr
instance Ix MyType where
  range = grange
  unsafeIndex = gunsafeIndex
  inRange = ginRange

Higher-kinded classes

Default implementations for classes indexed by type constructors (kind Type -> Type).

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, GFoldable (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.

class GFoldable_ t => GFoldable t

Class of generic representations for which Foldable can be derived.

Instances

GFoldable_ t => GFoldable t

Defined in Generic.Data.Internal.Traversable

Traversable

Can also be derived by GHC (DeriveTraversable extension).

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

Generic traverse.

instance Traversable MyTypeF where
  traverse = gtraverse

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

Generic sequenceA.

instance Traversable MyTypeF where
  sequenceA = gsequenceA

See also gtraverse.

class GTraversable_ t => GTraversable t

Class of generic representations for which Traversable can be derived.

Instances

GTraversable_ t => GTraversable t

Defined in Generic.Data.Internal.Traversable

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.

Read1

gliftReadPrec :: (Generic1 f, GRead1 (Rep1 f)) => ReadPrec a -> ReadPrec [a] -> ReadPrec (f a)

Generic liftReadPrec.

type GRead1 = GRead Identity

Generic representation of Read1 types.

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

(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

(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

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

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

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

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

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

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

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

type Old a = GOld (Rep a)

The type wrapped by a newtype.

newtype Foo = Foo { bar :: Bar } deriving Generic
-- Old Foo ~ Bar

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 Int)
"Maybe"

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

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

>>> gmoduleName @(ZipList Int)
"Control.Applicative"

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

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

>>> gpackageName @(Maybe Int)
"base"

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

True if the first type constructor is a newtype.

>>> gisNewtype @[Int]
False
>>> gisNewtype @(ZipList Int)
True

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.

>>> import GHC.Generics ((:*:)(..))
>>> 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)   -- Note:  newtype Sum a = Sum { getSum :: a }
True

gconNum :: forall a. Constructors a => Int

Number of constructors.

>>> gconNum @(Maybe Int)
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 (V1 :: k -> Type)

Defined in Generic.Data.Internal.Meta

Methods

gConIdToString :: GConId V1 -> String

gConId :: forall (p :: k0). V1 p -> GConId V1

gConNum :: Int

gConFixity :: forall (p :: k0). V1 p -> Fixity

gConIsRecord :: forall (p :: k0). V1 p -> Bool

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

Defined in Generic.Data.Internal.Meta

Methods

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

gConId :: forall (p :: k0). (f :+: g) p -> GConId (f :+: g)

gConNum :: Int

gConFixity :: forall (p :: k0). (f :+: g) p -> Fixity

gConIsRecord :: forall (p :: k0). (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 :: forall (p :: k0). M1 C c f p -> GConId (M1 C c f)

gConNum :: Int

gConFixity :: forall (p :: k0). M1 C c f p -> Fixity

gConIsRecord :: forall (p :: k0). 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 :: forall (p :: k0). M1 D c f p -> GConId (M1 D c f)

gConNum :: Int

gConFixity :: forall (p :: k0). M1 D c f p -> Fixity

gConIsRecord :: forall (p :: k0). M1 D c f p -> Bool

Constructor tags

data ConId a

An opaque identifier for a constructor.

Instances

Show (ConId a)

Defined in Generic.Data.Internal.Meta

Methods

showsPrec :: Int -> ConId a -> ShowS

show :: ConId a -> String

showList :: [ConId a] -> ShowS

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)

conIdNamed :: forall s a. ConIdNamed s a => ConId a

Get a ConId by name.

>>> conIdNamed @"Nothing" :: ConId (Maybe Int)
ConId 0
>>> conIdNamed @"Just"    :: ConId (Maybe Int)
ConId 1

class (Generic a, KnownNat (ConIdNamed' n a)) => ConIdNamed n a

Constraint synonym for generic types a with a constructor named n.

Instances

(Generic a, KnownNat (ConIdNamed' n a)) => ConIdNamed n a

Defined in Generic.Data.Internal.Meta

conIdMin :: forall a. (Constructors a, NonEmptyType "conIdMin" a) => ConId a

The first constructor. This must not be called on an empty type.

conIdMax :: forall a. (Constructors a, NonEmptyType "conIdMax" a) => ConId a

The last constructor. This must not be called on an empty type.

class NonEmptyType_ fname a => NonEmptyType fname a

Constraint that a generic type a is not empty. Producing an error message otherwise.

The Symbol parameter fname is used only for error messages.

It is implied by the simpler constraint IsEmptyType a ~ 'False

Instances

NonEmptyType_ fname a => NonEmptyType fname a

Defined in Generic.Data.Internal.Meta

type IsEmptyType a = IsEmptyType_ a

True if the generic type a is empty.

Using type families

type family MetaOf (f :: Type -> Type) :: 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

The Generic class

Reexported from GHC.Generics.

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Generic All

Defined in Data.Semigroup.Internal

Associated Types

type Rep All :: Type -> Type

Methods

from :: All -> Rep All x

to :: Rep All x -> All

Generic Any

Defined in Data.Semigroup.Internal

Associated Types

type Rep Any :: Type -> Type

Methods

from :: Any -> Rep Any x

to :: Rep Any x -> Any

Generic Version

Defined in Data.Version

Associated Types

type Rep Version :: Type -> Type

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

Generic Void

Defined in GHC.Generics

Associated Types

type Rep Void :: Type -> Type

Methods

from :: Void -> Rep Void x

to :: Rep Void x -> Void

Generic Fingerprint

Defined in GHC.Generics

Associated Types

type Rep Fingerprint :: Type -> Type

Methods

from :: Fingerprint -> Rep Fingerprint x

to :: Rep Fingerprint x -> Fingerprint

Generic Associativity

Defined in GHC.Generics

Associated Types

type Rep Associativity :: Type -> Type

Methods

from :: Associativity -> Rep Associativity x

to :: Rep Associativity x -> Associativity

Generic DecidedStrictness

Defined in GHC.Generics

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Fixity

Defined in GHC.Generics

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic SourceStrictness

Defined in GHC.Generics

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic SourceUnpackedness

Defined in GHC.Generics

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic ExitCode

Defined in GHC.IO.Exception

Associated Types

type Rep ExitCode :: Type -> Type

Methods

from :: ExitCode -> Rep ExitCode x

to :: Rep ExitCode x -> ExitCode

Generic CCFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep CCFlags :: Type -> Type

Methods

from :: CCFlags -> Rep CCFlags x

to :: Rep CCFlags x -> CCFlags

Generic ConcFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep ConcFlags :: Type -> Type

Methods

from :: ConcFlags -> Rep ConcFlags x

to :: Rep ConcFlags x -> ConcFlags

Generic DebugFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep DebugFlags :: Type -> Type

Methods

from :: DebugFlags -> Rep DebugFlags x

to :: Rep DebugFlags x -> DebugFlags

Generic DoCostCentres

Defined in GHC.RTS.Flags

Associated Types

type Rep DoCostCentres :: Type -> Type

Methods

from :: DoCostCentres -> Rep DoCostCentres x

to :: Rep DoCostCentres x -> DoCostCentres

Generic DoHeapProfile

Defined in GHC.RTS.Flags

Associated Types

type Rep DoHeapProfile :: Type -> Type

Methods

from :: DoHeapProfile -> Rep DoHeapProfile x

to :: Rep DoHeapProfile x -> DoHeapProfile

Generic DoTrace

Defined in GHC.RTS.Flags

Associated Types

type Rep DoTrace :: Type -> Type

Methods

from :: DoTrace -> Rep DoTrace x

to :: Rep DoTrace x -> DoTrace

Generic GCFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep GCFlags :: Type -> Type

Methods

from :: GCFlags -> Rep GCFlags x

to :: Rep GCFlags x -> GCFlags

Generic GiveGCStats

Defined in GHC.RTS.Flags

Associated Types

type Rep GiveGCStats :: Type -> Type

Methods

from :: GiveGCStats -> Rep GiveGCStats x

to :: Rep GiveGCStats x -> GiveGCStats

Generic MiscFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep MiscFlags :: Type -> Type

Methods

from :: MiscFlags -> Rep MiscFlags x

to :: Rep MiscFlags x -> MiscFlags

Generic ParFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep ParFlags :: Type -> Type

Methods

from :: ParFlags -> Rep ParFlags x

to :: Rep ParFlags x -> ParFlags

Generic ProfFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep ProfFlags :: Type -> Type

Methods

from :: ProfFlags -> Rep ProfFlags x

to :: Rep ProfFlags x -> ProfFlags

Generic RTSFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep RTSFlags :: Type -> Type

Methods

from :: RTSFlags -> Rep RTSFlags x

to :: Rep RTSFlags x -> RTSFlags

Generic TickyFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep TickyFlags :: Type -> Type

Methods

from :: TickyFlags -> Rep TickyFlags x

to :: Rep TickyFlags x -> TickyFlags

Generic TraceFlags

Defined in GHC.RTS.Flags

Associated Types

type Rep TraceFlags :: Type -> Type

Methods

from :: TraceFlags -> Rep TraceFlags x

to :: Rep TraceFlags x -> TraceFlags

Generic SrcLoc

Defined in GHC.Generics

Associated Types

type Rep SrcLoc :: Type -> Type

Methods

from :: SrcLoc -> Rep SrcLoc x

to :: Rep SrcLoc x -> SrcLoc

Generic GCDetails

Defined in GHC.Stats

Associated Types

type Rep GCDetails :: Type -> Type

Methods

from :: GCDetails -> Rep GCDetails x

to :: Rep GCDetails x -> GCDetails

Generic RTSStats

Defined in GHC.Stats

Associated Types

type Rep RTSStats :: Type -> Type

Methods

from :: RTSStats -> Rep RTSStats x

to :: Rep RTSStats x -> RTSStats

Generic GeneralCategory

Defined in GHC.Generics

Associated Types

type Rep GeneralCategory :: Type -> Type

Methods

from :: GeneralCategory -> Rep GeneralCategory x

to :: Rep GeneralCategory x -> GeneralCategory

Generic Ordering

Defined in GHC.Generics

Associated Types

type Rep Ordering :: Type -> Type

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Generic ()

Defined in GHC.Generics

Associated Types

type Rep () :: Type -> Type

Methods

from :: () -> Rep () x

to :: Rep () x -> ()

Generic Bool

Defined in GHC.Generics

Associated Types

type Rep Bool :: Type -> Type

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Generic (ZipList a)

Defined in Control.Applicative

Associated Types

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

Methods

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

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

Generic (Complex a)

Defined in Data.Complex

Associated Types

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

Methods

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

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

Generic (Identity a)

Defined in Data.Functor.Identity

Associated Types

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

Methods

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

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

Generic (First a)

Defined in Data.Monoid

Associated Types

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

Methods

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

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

Generic (Last a)

Defined in Data.Monoid

Associated Types

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

Methods

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

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

Generic (Down a)

Defined in GHC.Generics

Associated Types

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

Methods

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

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

Generic (First a)

Defined in Data.Semigroup

Associated Types

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

Methods

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

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

Generic (Last a)

Defined in Data.Semigroup

Associated Types

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

Methods

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

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

Generic (Max a)

Defined in Data.Semigroup

Associated Types

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

Methods

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

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

Generic (Min a)

Defined in Data.Semigroup

Associated Types

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

Methods

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

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

Generic (WrappedMonoid m)

Defined in Data.Semigroup

Associated Types

type Rep (WrappedMonoid m) :: Type -> Type

Methods

from :: WrappedMonoid m -> Rep (WrappedMonoid m) x

to :: Rep (WrappedMonoid m) x -> WrappedMonoid m

Generic (Dual a)

Defined in Data.Semigroup.Internal

Associated Types

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

Methods

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

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

Generic (Endo a)

Defined in Data.Semigroup.Internal

Associated Types

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

Methods

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

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

Generic (Product a)

Defined in Data.Semigroup.Internal

Associated Types

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

Methods

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

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

Generic (Sum a)

Defined in Data.Semigroup.Internal

Associated Types

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

Methods

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

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

Generic (NonEmpty a)

Defined in GHC.Generics

Associated Types

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

Methods

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

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

Generic a => Generic (Generically a)

This is a hack to implicitly wrap/unwrap in the instances of Generically.

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 (Par1 p)

Defined in GHC.Generics

Associated Types

type Rep (Par1 p) :: Type -> Type

Methods

from :: Par1 p -> Rep (Par1 p) x

to :: Rep (Par1 p) x -> Par1 p

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

Generic a => Generic (GenericProduct a)

Defined in Generic.Data.Internal.Generically

Associated Types

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

Methods

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

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

Generic (Maybe a)

Defined in GHC.Generics

Associated Types

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

Methods

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

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

Generic (a)

Defined in GHC.Generics

Associated Types

type Rep (a) :: Type -> Type

Methods

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

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

Generic [a]

Defined in GHC.Generics

Associated Types

type Rep [a] :: Type -> Type

Methods

from :: [a] -> Rep [a] x

to :: Rep [a] x -> [a]

Generic (WrappedMonad m a)

Defined in Control.Applicative

Associated Types

type Rep (WrappedMonad m a) :: Type -> Type

Methods

from :: WrappedMonad m a -> Rep (WrappedMonad m a) x

to :: Rep (WrappedMonad m a) x -> WrappedMonad m a

Generic (Either a b)

Defined in GHC.Generics

Associated Types

type Rep (Either a b) :: Type -> Type

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Generic (Proxy t)

Defined in GHC.Generics

Associated Types

type Rep (Proxy t) :: Type -> Type

Methods

from :: Proxy t -> Rep (Proxy t) x

to :: Rep (Proxy t) x -> Proxy t

Generic (Arg a b)

Defined in Data.Semigroup

Associated Types

type Rep (Arg a b) :: Type -> Type

Methods

from :: Arg a b -> Rep (Arg a b) x

to :: Rep (Arg a b) x -> Arg a b

Generic (U1 p)

Defined in GHC.Generics

Associated Types

type Rep (U1 p) :: Type -> Type

Methods

from :: U1 p -> Rep (U1 p) x

to :: Rep (U1 p) x -> U1 p

Generic (V1 p)

Defined in GHC.Generics

Associated Types

type Rep (V1 p) :: Type -> Type

Methods

from :: V1 p -> Rep (V1 p) x

to :: Rep (V1 p) x -> V1 p

(Functor r, Contravariant r) => Generic (Data r p)

Defined in Generic.Data.Internal.Data

Associated Types

type Rep (Data r p) :: Type -> Type

Methods

from :: Data r p -> Rep (Data r p) x

to :: Rep (Data r p) x -> Data r p

(Generic a, Coercible (GSurgery s (Rep a)) (Rep a)) => Generic (Surgery' s a)

Defined in Generic.Data.Internal.Microsurgery

Associated Types

type Rep (Surgery' s a) :: Type -> Type

Methods

from :: Surgery' s a -> Rep (Surgery' s a) x

to :: Rep (Surgery' s a) x -> Surgery' s a

Generic (a, b)

Defined in GHC.Generics

Associated Types

type Rep (a, b) :: Type -> Type

Methods

from :: (a, b) -> Rep (a, b) x

to :: Rep (a, b) x -> (a, b)

Generic (WrappedArrow a b c)

Defined in Control.Applicative

Associated Types

type Rep (WrappedArrow a b c) :: Type -> Type

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c

Generic (Kleisli m a b)

Defined in Control.Arrow

Associated Types

type Rep (Kleisli m a b) :: Type -> Type

Methods

from :: Kleisli m a b -> Rep (Kleisli m a b) x

to :: Rep (Kleisli m a b) x -> Kleisli m a b

Generic (Const a b)

Defined in Data.Functor.Const

Associated Types

type Rep (Const a b) :: Type -> Type

Methods

from :: Const a b -> Rep (Const a b) x

to :: Rep (Const a b) x -> Const a b

Generic (Ap f a)

Defined in Data.Monoid

Associated Types

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

Methods

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

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

Generic (Alt f a)

Defined in Data.Semigroup.Internal

Associated Types

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

Methods

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

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

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

This is a hack to implicitly wrap/unwrap in the instances of Generically1.

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

Generic (Rec1 f p)

Defined in GHC.Generics

Associated Types

type Rep (Rec1 f p) :: Type -> Type

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x

to :: Rep (Rec1 f p) x -> Rec1 f p

Generic (URec (Ptr ()) p)

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Generic (URec Char p)

Defined in GHC.Generics

Associated Types

type Rep (URec Char p) :: Type -> Type

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

Generic (URec Double p)

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: Type -> Type

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

Generic (URec Float p)

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: Type -> Type

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

Generic (URec Int p)

Defined in GHC.Generics

Associated Types

type Rep (URec Int p) :: Type -> Type

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

Generic (URec Word p)

Defined in GHC.Generics

Associated Types

type Rep (URec Word p) :: Type -> Type

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

Generic (a, b, c)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c) :: Type -> Type

Methods

from :: (a, b, c) -> Rep (a, b, c) x

to :: Rep (a, b, c) x -> (a, b, c)

Generic (Product f g a)

Defined in Data.Functor.Product

Associated Types

type Rep (Product f g a) :: Type -> Type

Methods

from :: Product f g a -> Rep (Product f g a) x

to :: Rep (Product f g a) x -> Product f g a

Generic (Sum f g a)

Defined in Data.Functor.Sum

Associated Types

type Rep (Sum f g a) :: Type -> Type

Methods

from :: Sum f g a -> Rep (Sum f g a) x

to :: Rep (Sum f g a) x -> Sum f g a

Generic ((f :*: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :*: g) p) :: Type -> Type

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x

to :: Rep ((f :*: g) p) x -> (f :*: g) p

Generic ((f :+: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :+: g) p) :: Type -> Type

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x

to :: Rep ((f :+: g) p) x -> (f :+: g) p

Generic (K1 i c p)

Defined in GHC.Generics

Associated Types

type Rep (K1 i c p) :: Type -> Type

Methods

from :: K1 i c p -> Rep (K1 i c p) x

to :: Rep (K1 i c p) x -> K1 i c p

Generic (a, b, c, d)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d) :: Type -> Type

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x

to :: Rep (a, b, c, d) x -> (a, b, c, d)

Generic (Compose f g a)

Defined in Data.Functor.Compose

Associated Types

type Rep (Compose f g a) :: Type -> Type

Methods

from :: Compose f g a -> Rep (Compose f g a) x

to :: Rep (Compose f g a) x -> Compose f g a

Generic ((f :.: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :.: g) p) :: Type -> Type

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x

to :: Rep ((f :.: g) p) x -> (f :.: g) p

Generic (M1 i c f p)

Defined in GHC.Generics

Associated Types

type Rep (M1 i c f p) :: Type -> Type

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x

to :: Rep (M1 i c f p) x -> M1 i c f p

Generic (a, b, c, d, e)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e) :: Type -> Type

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e)

Generic (a, b, c, d, e, f)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f) :: Type -> Type

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f)

Generic (a, b, c, d, e, f, g)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g)

Generic (a, b, c, d, e, f, g, h)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h) -> Rep (a, b, c, d, e, f, g, h) x

to :: Rep (a, b, c, d, e, f, g, h) x -> (a, b, c, d, e, f, g, h)

Generic (a, b, c, d, e, f, g, h, i)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i) -> Rep (a, b, c, d, e, f, g, h, i) x

to :: Rep (a, b, c, d, e, f, g, h, i) x -> (a, b, c, d, e, f, g, h, i)

Generic (a, b, c, d, e, f, g, h, i, j)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j) -> Rep (a, b, c, d, e, f, g, h, i, j) x

to :: Rep (a, b, c, d, e, f, g, h, i, j) x -> (a, b, c, d, e, f, g, h, i, j)

Generic (a, b, c, d, e, f, g, h, i, j, k)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k) -> Rep (a, b, c, d, e, f, g, h, i, j, k) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k) x -> (a, b, c, d, e, f, g, h, i, j, k)

Generic (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l) x -> (a, b, c, d, e, f, g, h, i, j, k, l)

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Generic1 (f :: k -> Type)

Representable types of kind * -> * (or kind k -> *, when PolyKinds is enabled). This class is derivable in GHC with the DeriveGeneric flag on.

A Generic1 instance must satisfy the following laws:

from1 . to1 ≡ id
to1 . from1 ≡ id

Minimal complete definition

from1, to1

Instances

Generic1 ZipList

Defined in Control.Applicative

Associated Types

type Rep1 ZipList :: k -> Type

Methods

from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a

to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a

Generic1 Complex

Defined in Data.Complex

Associated Types

type Rep1 Complex :: k -> Type

Methods

from1 :: forall (a :: k). Complex a -> Rep1 Complex a

to1 :: forall (a :: k). Rep1 Complex a -> Complex a

Generic1 Identity

Defined in Data.Functor.Identity

Associated Types

type Rep1 Identity :: k -> Type

Methods

from1 :: forall (a :: k). Identity a -> Rep1 Identity a

to1 :: forall (a :: k). Rep1 Identity a -> Identity a

Generic1 First

Defined in Data.Monoid

Associated Types

type Rep1 First :: k -> Type

Methods

from1 :: forall (a :: k). First a -> Rep1 First a

to1 :: forall (a :: k). Rep1 First a -> First a

Generic1 Last

Defined in Data.Monoid

Associated Types

type Rep1 Last :: k -> Type

Methods

from1 :: forall (a :: k). Last a -> Rep1 Last a

to1 :: forall (a :: k). Rep1 Last a -> Last a

Generic1 Down

Defined in GHC.Generics

Associated Types

type Rep1 Down :: k -> Type

Methods

from1 :: forall (a :: k). Down a -> Rep1 Down a

to1 :: forall (a :: k). Rep1 Down a -> Down a

Generic1 First

Defined in Data.Semigroup

Associated Types

type Rep1 First :: k -> Type

Methods

from1 :: forall (a :: k). First a -> Rep1 First a

to1 :: forall (a :: k). Rep1 First a -> First a

Generic1 Last

Defined in Data.Semigroup

Associated Types

type Rep1 Last :: k -> Type

Methods

from1 :: forall (a :: k). Last a -> Rep1 Last a

to1 :: forall (a :: k). Rep1 Last a -> Last a

Generic1 Max

Defined in Data.Semigroup

Associated Types

type Rep1 Max :: k -> Type

Methods

from1 :: forall (a :: k). Max a -> Rep1 Max a

to1 :: forall (a :: k). Rep1 Max a -> Max a

Generic1 Min

Defined in Data.Semigroup

Associated Types

type Rep1 Min :: k -> Type

Methods

from1 :: forall (a :: k). Min a -> Rep1 Min a

to1 :: forall (a :: k). Rep1 Min a -> Min a

Generic1 WrappedMonoid

Defined in Data.Semigroup

Associated Types

type Rep1 WrappedMonoid :: k -> Type

Methods

from1 :: forall (a :: k). WrappedMonoid a -> Rep1 WrappedMonoid a

to1 :: forall (a :: k). Rep1 WrappedMonoid a -> WrappedMonoid a

Generic1 Dual

Defined in Data.Semigroup.Internal

Associated Types

type Rep1 Dual :: k -> Type

Methods

from1 :: forall (a :: k). Dual a -> Rep1 Dual a

to1 :: forall (a :: k). Rep1 Dual a -> Dual a

Generic1 Product

Defined in Data.Semigroup.Internal

Associated Types

type Rep1 Product :: k -> Type

Methods

from1 :: forall (a :: k). Product a -> Rep1 Product a

to1 :: forall (a :: k). Rep1 Product a -> Product a

Generic1 Sum

Defined in Data.Semigroup.Internal

Associated Types

type Rep1 Sum :: k -> Type

Methods

from1 :: forall (a :: k). Sum a -> Rep1 Sum a

to1 :: forall (a :: k). Rep1 Sum a -> Sum a

Generic1 NonEmpty

Defined in GHC.Generics

Associated Types

type Rep1 NonEmpty :: k -> Type

Methods

from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a

to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a

Generic1 Par1

Defined in GHC.Generics

Associated Types

type Rep1 Par1 :: k -> Type

Methods

from1 :: forall (a :: k). Par1 a -> Rep1 Par1 a

to1 :: forall (a :: k). Rep1 Par1 a -> Par1 a

Generic1 Maybe

Defined in GHC.Generics

Associated Types

type Rep1 Maybe :: k -> Type

Methods

from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a

to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a

Generic1 Solo

Defined in GHC.Generics

Associated Types

type Rep1 Solo :: k -> Type

Methods

from1 :: forall (a :: k). Solo a -> Rep1 Solo a

to1 :: forall (a :: k). Rep1 Solo a -> Solo a

Generic1 List

Defined in GHC.Generics

Associated Types

type Rep1 List :: k -> Type

Methods

from1 :: forall (a :: k). [a] -> Rep1 List a

to1 :: forall (a :: k). Rep1 List a -> [a]

Generic1 (WrappedMonad m :: Type -> Type)

Defined in Control.Applicative

Associated Types

type Rep1 (WrappedMonad m) :: k -> Type

Methods

from1 :: forall (a :: k). WrappedMonad m a -> Rep1 (WrappedMonad m) a

to1 :: forall (a :: k). Rep1 (WrappedMonad m) a -> WrappedMonad m a

Generic1 (Either a :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (Either a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Either a a0 -> Rep1 (Either a) a0

to1 :: forall (a0 :: k). Rep1 (Either a) a0 -> Either a a0

Generic1 (Arg a :: Type -> Type)

Defined in Data.Semigroup

Associated Types

type Rep1 (Arg a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Arg a a0 -> Rep1 (Arg a) a0

to1 :: forall (a0 :: k). Rep1 (Arg a) a0 -> Arg a a0

Generic1 (Data r :: Type -> Type)

Defined in Generic.Data.Internal.Data

Associated Types

type Rep1 (Data r) :: k -> Type

Methods

from1 :: forall (a :: k). Data r a -> Rep1 (Data r) a

to1 :: forall (a :: k). Rep1 (Data r) a -> Data r a

Generic1 ((,) a :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,) a) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, a0) -> Rep1 ((,) a) a0

to1 :: forall (a0 :: k). Rep1 ((,) a) a0 -> (a, a0)

Generic1 (Proxy :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 Proxy :: k -> Type

Methods

from1 :: forall (a :: k0). Proxy a -> Rep1 Proxy a

to1 :: forall (a :: k0). Rep1 Proxy a -> Proxy a

Generic1 (U1 :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 U1 :: k -> Type

Methods

from1 :: forall (a :: k0). U1 a -> Rep1 U1 a

to1 :: forall (a :: k0). Rep1 U1 a -> U1 a

Generic1 (V1 :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 V1 :: k -> Type

Methods

from1 :: forall (a :: k0). V1 a -> Rep1 V1 a

to1 :: forall (a :: k0). Rep1 V1 a -> V1 a

Generic1 (WrappedArrow a b :: Type -> Type)

Defined in Control.Applicative

Associated Types

type Rep1 (WrappedArrow a b) :: k -> Type

Methods

from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0

to1 :: forall (a0 :: k). Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0

Generic1 (Kleisli m a :: Type -> Type)

Defined in Control.Arrow

Associated Types

type Rep1 (Kleisli m a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Kleisli m a a0 -> Rep1 (Kleisli m a) a0

to1 :: forall (a0 :: k). Rep1 (Kleisli m a) a0 -> Kleisli m a a0

Generic1 f => Generic1 (Generically1 f :: Type -> Type)

This is a hack to implicitly wrap/unwrap in the instances of Generically1.

Defined in Generic.Data.Internal.Generically

Associated Types

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

Methods

from1 :: forall (a :: k). Generically1 f a -> Rep1 (Generically1 f) a

to1 :: forall (a :: k). Rep1 (Generically1 f) a -> Generically1 f a

Generic1 ((,,) a b :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,) a b) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, a0) -> Rep1 ((,,) a b) a0

to1 :: forall (a0 :: k). Rep1 ((,,) a b) a0 -> (a, b, a0)

Generic1 (Const a :: k -> Type)

Defined in Data.Functor.Const

Associated Types

type Rep1 (Const a) :: k -> Type

Methods

from1 :: forall (a0 :: k0). Const a a0 -> Rep1 (Const a) a0

to1 :: forall (a0 :: k0). Rep1 (Const a) a0 -> Const a a0

Generic1 (Ap f :: k -> Type)

Defined in Data.Monoid

Associated Types

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

Methods

from1 :: forall (a :: k0). Ap f a -> Rep1 (Ap f) a

to1 :: forall (a :: k0). Rep1 (Ap f) a -> Ap f a

Generic1 (Alt f :: k -> Type)

Defined in Data.Semigroup.Internal

Associated Types

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

Methods

from1 :: forall (a :: k0). Alt f a -> Rep1 (Alt f) a

to1 :: forall (a :: k0). Rep1 (Alt f) a -> Alt f a

Generic1 (Rec1 f :: k -> Type)

Defined in GHC.Generics

Associated Types

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

Methods

from1 :: forall (a :: k0). Rec1 f a -> Rep1 (Rec1 f) a

to1 :: forall (a :: k0). Rep1 (Rec1 f) a -> Rec1 f a

Generic1 (URec (Ptr ()) :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec (Ptr ())) :: k -> Type

Methods

from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a

to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a

Generic1 (URec Char :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Char) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a

to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a

Generic1 (URec Double :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Double) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a

to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a

Generic1 (URec Float :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Float) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a

to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a

Generic1 (URec Int :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Int) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a

to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a

Generic1 (URec Word :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Word) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a

to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a

Generic1 ((,,,) a b c :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,) a b c) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, a0) -> Rep1 ((,,,) a b c) a0

to1 :: forall (a0 :: k). Rep1 ((,,,) a b c) a0 -> (a, b, c, a0)

Generic1 (Product f g :: k -> Type)

Defined in Data.Functor.Product

Associated Types

type Rep1 (Product f g) :: k -> Type

Methods

from1 :: forall (a :: k0). Product f g a -> Rep1 (Product f g) a

to1 :: forall (a :: k0). Rep1 (Product f g) a -> Product f g a

Generic1 (Sum f g :: k -> Type)

Defined in Data.Functor.Sum

Associated Types

type Rep1 (Sum f g) :: k -> Type

Methods

from1 :: forall (a :: k0). Sum f g a -> Rep1 (Sum f g) a

to1 :: forall (a :: k0). Rep1 (Sum f g) a -> Sum f g a

Generic1 (f :*: g :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (f :*: g) :: k -> Type

Methods

from1 :: forall (a :: k0). (f :*: g) a -> Rep1 (f :*: g) a

to1 :: forall (a :: k0). Rep1 (f :*: g) a -> (f :*: g) a

Generic1 (f :+: g :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (f :+: g) :: k -> Type

Methods

from1 :: forall (a :: k0). (f :+: g) a -> Rep1 (f :+: g) a

to1 :: forall (a :: k0). Rep1 (f :+: g) a -> (f :+: g) a

Generic1 (K1 i c :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (K1 i c) :: k -> Type

Methods

from1 :: forall (a :: k0). K1 i c a -> Rep1 (K1 i c) a

to1 :: forall (a :: k0). Rep1 (K1 i c) a -> K1 i c a

Generic1 ((,,,,) a b c d :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,) a b c d) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, a0) -> Rep1 ((,,,,) a b c d) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,) a b c d) a0 -> (a, b, c, d, a0)

Functor f => Generic1 (Compose f g :: k -> Type)

Defined in Data.Functor.Compose

Associated Types

type Rep1 (Compose f g) :: k -> Type

Methods

from1 :: forall (a :: k0). Compose f g a -> Rep1 (Compose f g) a

to1 :: forall (a :: k0). Rep1 (Compose f g) a -> Compose f g a

Functor f => Generic1 (f :.: g :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (f :.: g) :: k -> Type

Methods

from1 :: forall (a :: k0). (f :.: g) a -> Rep1 (f :.: g) a

to1 :: forall (a :: k0). Rep1 (f :.: g) a -> (f :.: g) a

Generic1 (M1 i c f :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (M1 i c f) :: k -> Type

Methods

from1 :: forall (a :: k0). M1 i c f a -> Rep1 (M1 i c f) a

to1 :: forall (a :: k0). Rep1 (M1 i c f) a -> M1 i c f a

Generic1 ((,,,,,) a b c d e :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,) a b c d e) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, a0) -> Rep1 ((,,,,,) a b c d e) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,,) a b c d e) a0 -> (a, b, c, d, e, a0)

Generic1 ((,,,,,,) a b c d e f :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,) a b c d e f) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, a0) -> Rep1 ((,,,,,,) a b c d e f) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,,,) a b c d e f) a0 -> (a, b, c, d, e, f, a0)

Generic1 ((,,,,,,,) a b c d e f g :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,,) a b c d e f g) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, a0) -> Rep1 ((,,,,,,,) a b c d e f g) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,,,,) a b c d e f g) a0 -> (a, b, c, d, e, f, g, a0)

Generic1 ((,,,,,,,,) a b c d e f g h :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,,,) a b c d e f g h) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, a0) -> Rep1 ((,,,,,,,,) a b c d e f g h) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,) a b c d e f g h) a0 -> (a, b, c, d, e, f, g, h, a0)

Generic1 ((,,,,,,,,,) a b c d e f g h i :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,,,,) a b c d e f g h i) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, i, a0) -> Rep1 ((,,,,,,,,,) a b c d e f g h i) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,,) a b c d e f g h i) a0 -> (a, b, c, d, e, f, g, h, i, a0)

Generic1 ((,,,,,,,,,,) a b c d e f g h i j :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,,,,,) a b c d e f g h i j) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, i, j, a0) -> Rep1 ((,,,,,,,,,,) a b c d e f g h i j) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,,,) a b c d e f g h i j) a0 -> (a, b, c, d, e, f, g, h, i, j, a0)

Generic1 ((,,,,,,,,,,,) a b c d e f g h i j k :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) :: k -> Type

Methods

from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, a0) -> Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) a0

to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) a0 -> (a, b, c, d, e, f, g, h, i, j, k, a0)

Generic1 ((,,,,,,,,,,,,) a b c d e f g h i j k l :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) :: k -> Type

Methods

from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) a0

to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, a0)

Generic1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) :: k -> Type

Methods

from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) a0

to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0)

Generic1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n :: Type -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) :: k -> Type

Methods

from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) a0

to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0)