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

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

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

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

Generic (<>) (or mappend).

instance Semigroup MyType where
  (<>) = gmappend

See also gmempty.

Generic mempty.

instance Monoid MyType where
  mempty = gmempty

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.

Generic (==).

instance Eq MyType where
  (==) = geq

Generic compare.

instance Ord MyType where
  compare = gcompare

Generic readPrec.

instance Read MyType where
  readPrec = greadPrec
  readListPrec = readListPrecDefault

Generic representation of Read types.

Generic showsPrec.

instance Show MyType where
  showsPrec = gshowsPrec

Generic representation of Show types.

Generic representation of Enum types.

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

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

Generic toEnum generated with the StandardEnum option.

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

Generic fromEnum generated with the StandardEnum option.

See also gtoEnum.

Generic enumFrom generated with the StandardEnum option.

See also gtoEnum.

Generic enumFromThen generated with the StandardEnum option.

See also gtoEnum.

Generic enumFromTo generated with the StandardEnum option.

See also gtoEnum.

Generic enumFromThenTo generated with the StandardEnum option.

See also gtoEnum.

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

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

Generic toEnum generated with the FiniteEnum option.

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

Generic fromEnum generated with the FiniteEnum option.

See also gtoFiniteEnum.

Generic enumFrom generated with the FiniteEnum option.

See also gtoFiniteEnum.

Generic enumFromThen generated with the FiniteEnum option.

See also gtoFiniteEnum.

Generic enumFromTo generated with the FiniteEnum option.

See also gtoFiniteEnum.

Generic enumFromThenTo generated with the FiniteEnum option.

See also gtoFiniteEnum.

Generic minBound.

instance Bounded MyType where
  minBound = gminBound
  maxBound = gmaxBound

Generic maxBound.

See also gminBound.

Generic representation of Bounded types.

Generic range.

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

Generic index.

See also grange.

Generic inRange.

See also grange.

Generic representation of Ix types.

Generic unsafeIndex.

Details

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

Generic fmap.

instance Functor MyTypeF where
  fmap = gfmap

Generic (<$).

See also gfmap.

Generic foldMap.

instance Foldable MyTypeF where
  foldMap = gfoldMap

Generic foldr.

instance Foldable MyTypeF where
  foldr = gfoldr

See also gfoldMap.

Class of generic representations for which Foldable can be derived.

Generic traverse.

instance Traversable MyTypeF where
  traverse = gtraverse

Generic sequenceA.

instance Traversable MyTypeF where
  sequenceA = gsequenceA

See also gtraverse.

Class of generic representations for which Traversable can be derived.

Generic pure.

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

Generic (<*>) (or ap).

See also gpure.

Generic liftA2.

See also gpure.

Generic empty.

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

Generic (<|>).

See also gempty.

Generic liftEq.

Generic liftCompare.

Generic liftReadPrec.

Generic representation of Read1 types.

Generic liftShowsPrec.

Generic representation of Show1 types.

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

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

A higher-kinded version of Opaque.

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

The type wrapped by a newtype.

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

Generic newtype constructor.

Generic newtype destructor.

Convert between types with representationally equivalent generic representations.

Compose gcoerce with a binary operation.

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

>>> gdatatypeName @(Maybe Int)
"Maybe"

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

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

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

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

True if the first type constructor is a newtype.

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

Generic representations that contain datatype metadata.

Name of the first constructor in a value.

>>> gconName (Just 0)
"Just"

The fixity of the first constructor.

>>> import GHC.Generics ((:*:)(..))
>>> gconFixity (Just 0)
Prefix
>>> gconFixity ([] :*: id)
Infix RightAssociative 6

True if the constructor is a record.

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

Number of constructors.

>>> gconNum @(Maybe Int)
2

Index of a constructor.

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

Constraint synonym for Generic and GConstructors.

Generic representations that contain constructor metadata.

An opaque identifier for a constructor.

Identifier of a constructor.

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

Name of a constructor. See also gconName.

All constructor identifiers.

gconNum @a = length (conIdEnum @a)

Get a ConId by name.

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

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

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

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

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

True if the generic type a is empty.

Meta field of the M1 type constructor.

Name of the data type (MetaData).

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

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

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

Name of the constructor (MetaCons).

Fixity of the constructor (MetaCons).

True for a record constructor (MetaCons).

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

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

Unpackedness annotation of a field (MetaSel).

Strictness annotation of a field (MetaSel).

Inferred strictness of a field (MetaSel).

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