Safe Haskell	None
Language	Haskell2010

Generic.Data

Contents

Regular classes
Higher-kinded classes
- Functor
- Foldable
- Traversable
- Applicative
- Alternative
- Eq1
- Ord1
- Show1
Fields wrappers for deriving
Carriers of generic instances
Newtype
Generic coercions
Accessing metadata

Description

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.

Synopsis

gmappend :: (Generic a, Semigroup (Rep a ())) => a -> a -> a
gmempty :: (Generic a, Monoid (Rep a ())) => a
gmappend' :: (Generic a, Monoid (Rep a ())) => a -> a -> a
geq :: (Generic a, Eq (Rep a ())) => a -> a -> Bool
gcompare :: (Generic a, Ord (Rep a ())) => a -> a -> Ordering
gshowsPrec :: (Generic a, GShow0 (Rep a)) => Int -> a -> ShowS
type GShow0 = GShow Proxy
class GEnum opts f
data StandardEnum
gtoEnum :: (Generic a, GEnum StandardEnum (Rep a)) => Int -> a
gfromEnum :: (Generic a, GEnum StandardEnum (Rep a)) => a -> Int
genumFrom :: (Generic a, GEnum StandardEnum (Rep a)) => a -> [a]
genumFromThen :: (Generic a, GEnum StandardEnum (Rep a)) => a -> a -> [a]
genumFromTo :: (Generic a, GEnum StandardEnum (Rep a)) => a -> a -> [a]
genumFromThenTo :: (Generic a, GEnum StandardEnum (Rep a)) => a -> a -> a -> [a]
data FiniteEnum
gtoFiniteEnum :: (Generic a, GEnum FiniteEnum (Rep a)) => Int -> a
gfromFiniteEnum :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> Int
gfiniteEnumFrom :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> [a]
gfiniteEnumFromThen :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> a -> [a]
gfiniteEnumFromTo :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> a -> [a]
gfiniteEnumFromThenTo :: (Generic a, GEnum FiniteEnum (Rep a)) => a -> a -> a -> [a]
gminBound :: (Generic a, GBounded (Rep a)) => a
gmaxBound :: (Generic a, GBounded (Rep a)) => a
class GBounded f
grange :: (Generic a, GIx (Rep a)) => (a, a) -> [a]
gindex :: (Generic a, GIx (Rep a)) => (a, a) -> a -> Int
ginRange :: (Generic a, GIx (Rep a)) => (a, a) -> a -> Bool
class GIx f
gunsafeIndex :: (Generic a, GIx (Rep a)) => (a, a) -> a -> Int
gfmap :: (Generic1 f, Functor (Rep1 f)) => (a -> b) -> f a -> f b
gconstmap :: (Generic1 f, Functor (Rep1 f)) => a -> f b -> f a
gfoldMap :: (Generic1 f, Foldable (Rep1 f), Monoid m) => (a -> m) -> f a -> m
gfoldr :: (Generic1 f, Foldable (Rep1 f)) => (a -> b -> b) -> b -> f a -> b
gtraverse :: (Generic1 f, Traversable (Rep1 f), Applicative m) => (a -> m b) -> f a -> m (f b)
gsequenceA :: (Generic1 f, Traversable (Rep1 f), Applicative m) => f (m a) -> m (f a)
gpure :: (Generic1 f, Applicative (Rep1 f)) => a -> f a
gap :: (Generic1 f, Applicative (Rep1 f)) => f (a -> b) -> f a -> f b
gliftA2 :: (Generic1 f, Applicative (Rep1 f)) => (a -> b -> c) -> f a -> f b -> f c
gempty :: (Generic1 f, Alternative (Rep1 f)) => f a
galt :: (Generic1 f, Alternative (Rep1 f)) => f a -> f a -> f a
gliftEq :: (Generic1 f, Eq1 (Rep1 f)) => (a -> b -> Bool) -> f a -> f b -> Bool
gliftCompare :: (Generic1 f, Ord1 (Rep1 f)) => (a -> b -> Ordering) -> f a -> f b -> Ordering
gliftShowsPrec :: (Generic1 f, GShow1 (Rep1 f)) => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
type GShow1 = GShow Identity
newtype Id1 f a = Id1 {
- unId1 :: f a
}
newtype Opaque a = Opaque {
- unOpaque :: a
}
newtype Opaque1 f a = Opaque1 {
- unOpaque1 :: f a
}
newtype Generically a = Generically {
- unGenerically :: a
}
newtype GenericProduct a = GenericProduct {
- unGenericProduct :: a
}
newtype FiniteEnumeration a = FiniteEnumeration {
- unFiniteEnumeration :: a
}
newtype Generically1 f a = Generically1 {
- unGenerically1 :: f a
}
class (Generic a, Coercible a (Old a), Newtype' a) => Newtype a
pack :: Newtype a => Old a -> a
unpack :: Newtype a => a -> Old a
gcoerce :: (Generic a, Generic b, Coercible (Rep a) (Rep b)) => a -> b
gcoerceBinop :: (Generic a, Generic b, Coercible (Rep a) (Rep b)) => (a -> a -> a) -> b -> b -> b
gdatatypeName :: forall a. (Generic a, GDatatype (Rep a)) => String
gmoduleName :: forall a. (Generic a, GDatatype (Rep a)) => String
gpackageName :: forall a. (Generic a, GDatatype (Rep a)) => String
gisNewtype :: forall a. (Generic a, GDatatype (Rep a)) => Bool
class GDatatype f
gconName :: forall a. Constructors a => a -> String
gconFixity :: forall a. Constructors a => a -> Fixity
gconIsRecord :: forall a. Constructors a => a -> Bool
gconNum :: forall a. Constructors a => Int
gconIndex :: forall a. Constructors a => a -> Int
class (Generic a, GConstructors (Rep a)) => Constructors a
class GConstructors r
data ConId a
conId :: forall a. Constructors a => a -> ConId a
conIdToInt :: forall a. ConId a -> Int
conIdToString :: forall a. Constructors a => ConId a -> String
conIdEnum :: forall a. Constructors a => [ConId a]
conIdNamed :: forall s a. ConIdNamed s a => ConId a
class (Generic a, KnownNat (ConIdNamed' n a)) => ConIdNamed n a
type family MetaOf (f :: * -> *) :: Meta where ...
type family MetaDataName (m :: Meta) :: Symbol where ...
type family MetaDataModule (m :: Meta) :: Symbol where ...
type family MetaDataPackage (m :: Meta) :: Symbol where ...
type family MetaDataNewtype (m :: Meta) :: Bool where ...
type family MetaConsName (m :: Meta) :: Symbol where ...
type family MetaConsFixity (m :: Meta) :: FixityI where ...
type family MetaConsRecord (m :: Meta) :: Bool where ...
type family MetaSelNameM (m :: Meta) :: Maybe Symbol where ...
type family MetaSelName (m :: Meta) :: Symbol where ...
type family MetaSelUnpack (m :: Meta) :: SourceUnpackedness where ...
type family MetaSelSourceStrictness (m :: Meta) :: SourceStrictness where ...
type family MetaSelStrictness (m :: Meta) :: DecidedStrictness where ...

Regular classes

`Semigroup`

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

Generic (<>) (or mappend).

instance Semigroup MyType where
  (<>) = gmappend

`Monoid`

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

Generic mempty.

instance Monoid MyType where
  mempty = gmempty

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

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

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

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

Generic showsPrec.

instance Show MyType where
  showsPrec = gshowsPrec

type GShow0 = GShow Proxy Source #

Generic representation of Show types.

`Enum`

class GEnum opts f Source #

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) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gCardinality :: Int Source # gFromEnum :: U1 p -> Int Source # gToEnum :: Int -> U1 p Source #
(GEnum opts f, GEnum opts g) => GEnum opts (f :+: g) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gCardinality :: Int Source # gFromEnum :: (f :+: g) p -> Int Source # gToEnum :: Int -> (f :+: g) p Source #
(Bounded c, Enum c) => GEnum FiniteEnum (K1 i c :: Type -> Type) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gCardinality :: Int Source # gFromEnum :: K1 i c p -> Int Source # gToEnum :: Int -> K1 i c p Source #
(GEnum FiniteEnum f, GEnum FiniteEnum g) => GEnum FiniteEnum (f :*: g) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gCardinality :: Int Source # gFromEnum :: (f :: g) p -> Int Source # gToEnum :: Int -> (f :: g) p Source #
GEnum opts f => GEnum opts (M1 i c f) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gCardinality :: Int Source # gFromEnum :: M1 i c f p -> Int Source # gToEnum :: Int -> M1 i c f p Source #

StandardEnum option

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

data StandardEnum Source #

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

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

Generic fromEnum generated with the StandardEnum option.

See also gtoEnum.

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

Generic enumFrom generated with the StandardEnum option.

See also gtoEnum.

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

Generic enumFromThen generated with the StandardEnum option.

See also gtoEnum.

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

Generic enumFromTo generated with the StandardEnum option.

See also gtoEnum.

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

Generic enumFromThenTo generated with the StandardEnum option.

See also gtoEnum.

FiniteEnum option

data FiniteEnum Source #

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.

Details

Expand

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) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gCardinality :: Int Source # gFromEnum :: K1 i c p -> Int Source # gToEnum :: Int -> K1 i c p Source #
(GEnum FiniteEnum f, GEnum FiniteEnum g) => GEnum FiniteEnum (f :*: g) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gCardinality :: Int Source # gFromEnum :: (f :: g) p -> Int Source # gToEnum :: Int -> (f :: g) p Source #

gtoFiniteEnum :: (Generic a, GEnum FiniteEnum (Rep a)) => Int -> a Source #

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

Generic fromEnum generated with the FiniteEnum option.

See also gtoFiniteEnum.

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

Generic enumFrom generated with the FiniteEnum option.

See also gtoFiniteEnum.

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

Generic enumFromThen generated with the FiniteEnum option.

See also gtoFiniteEnum.

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

Generic enumFromTo generated with the FiniteEnum option.

See also gtoFiniteEnum.

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

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

Generic minBound.

instance Bounded MyType where
  minBound = gminBound
  maxBound = gmaxBound

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

Generic maxBound.

`Ix`

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

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

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

Generic index.

Details

Expand

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

`Functor`

Can also be derived by GHC (DeriveFunctor extension).

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

Generic fmap.

instance Functor MyTypeF where
  fmap = gfmap

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

Generic (<$).

`Foldable`

Can also be derived by GHC (DeriveFoldable extension).

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

Generic foldMap.

instance Foldable MyTypeF where
  foldMap = gfoldMap

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

Generic foldr.

instance Foldable MyTypeF where
  foldr = gfoldr

`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) Source #

Generic traverse.

instance Traversable MyTypeF where
  traverse = gtraverse

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

Generic sequenceA.

instance Traversable MyTypeF where
  sequenceA = gsequenceA

`Applicative`

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

Generic pure.

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

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

Generic (<*>) (or ap).

`Alternative`

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

Generic empty.

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

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

Generic (<|>).

`Eq1`

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

Generic liftEq.

`Ord1`

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

Generic liftCompare.

`Show1`

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

Generic liftShowsPrec.

type GShow1 = GShow Identity Source #

Generic representation of Show1 types.

Fields wrappers for deriving

newtype Id1 f a Source #

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) Source #
Instance details Defined in Generic.Data.Internal.Resolvers Methods liftEq :: (a -> b -> Bool) -> Id1 f a -> Id1 f b -> Bool #
Ord1 f => Ord1 (Id1 f) Source #
Instance details Defined in Generic.Data.Internal.Resolvers Methods liftCompare :: (a -> b -> Ordering) -> Id1 f a -> Id1 f b -> Ordering #
Read1 f => Read1 (Id1 f) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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 Source #

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 Source #	All equal.
Instance details Defined in Generic.Data.Internal.Resolvers Methods liftEq :: (a -> b -> Bool) -> Opaque a -> Opaque b -> Bool #
Ord1 Opaque Source #	All equal.
Instance details Defined in Generic.Data.Internal.Resolvers Methods liftCompare :: (a -> b -> Ordering) -> Opaque a -> Opaque b -> Ordering #
Show1 Opaque Source #	Shown as `"_"`.
Instance details 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) Source #	All equal.
Instance details Defined in Generic.Data.Internal.Resolvers Methods (==) :: Opaque a -> Opaque a -> Bool # (/=) :: Opaque a -> Opaque a -> Bool #
Ord (Opaque a) Source #	All equal.
Instance details 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) Source #	Shown as `"_"`.
Instance details Defined in Generic.Data.Internal.Resolvers Methods showsPrec :: Int -> Opaque a -> ShowS # show :: Opaque a -> String # showList :: [Opaque a] -> ShowS #

newtype Opaque1 f a Source #

A higher-kinded version of Opaque.

Constructors

Opaque1
Fields unOpaque1 :: f a

Instances

Eq1 (Opaque1 f) Source #	All equal.
Instance details Defined in Generic.Data.Internal.Resolvers Methods liftEq :: (a -> b -> Bool) -> Opaque1 f a -> Opaque1 f b -> Bool #
Ord1 (Opaque1 f) Source #	All equal.
Instance details Defined in Generic.Data.Internal.Resolvers Methods liftCompare :: (a -> b -> Ordering) -> Opaque1 f a -> Opaque1 f b -> Ordering #
Show1 (Opaque1 f) Source #	Shown as `"_"`.
Instance details 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) Source #	All equal.
Instance details 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) Source #	All equal.
Instance details 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) Source #	Shown as `"_"`.
Instance details 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 Source #

Type with instances derived via Generic.

Constructors

Generically
Fields unGenerically :: a

Instances

(Generic a, GBounded (Rep a)) => Bounded (Generically a) Source #
Instance details Defined in Generic.Data.Internal.Generically Methods minBound :: Generically a # maxBound :: Generically a #
(Generic a, GEnum StandardEnum (Rep a)) => Enum (Generically a) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details Defined in Generic.Data.Internal.Generically Methods showsPrec :: Int -> Generically a -> ShowS # show :: Generically a -> String # showList :: [Generically a] -> ShowS #
(Generic a, Ord (Rep a ()), GIx (Rep a)) => Ix (Generically a) Source #
Instance details 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 => Generic (Generically a) Source #
Instance details 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 #
(AssertNoSum Semigroup a, Generic a, Semigroup (Rep a ())) => Semigroup (Generically a) Source #
Instance details 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 #
(AssertNoSum Semigroup a, Semigroup a, Generic a, Monoid (Rep a ())) => Monoid (Generically a) Source #	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.
Instance details 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) Source #
Instance details Defined in Generic.Data.Internal.Generically type Rep (Generically a) = Rep a

newtype GenericProduct a Source #

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

Expand

>>> :set -XDeriveGeneric -XDerivingVia
>>> 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
Fields unGenericProduct :: a

Instances

Generic a => Generic (GenericProduct a) Source #
Instance details 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 #
(AssertNoSum Semigroup a, Generic a, Semigroup (Rep a ())) => Semigroup (GenericProduct a) Source #
Instance details 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 #
(AssertNoSum Semigroup a, Generic a, Monoid (Rep a ())) => Monoid (GenericProduct a) Source #
Instance details Defined in Generic.Data.Internal.Generically Methods mempty :: GenericProduct a # mappend :: GenericProduct a -> GenericProduct a -> GenericProduct a # mconcat :: [GenericProduct a] -> GenericProduct a #
type Rep (GenericProduct a) Source #
Instance details Defined in Generic.Data.Internal.Generically type Rep (GenericProduct a) = Rep a

newtype FiniteEnumeration a Source #

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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details Defined in Generic.Data.Internal.Generically type Rep (FiniteEnumeration a) = Rep a

newtype Generically1 f a Source #

Type with instances derived via Generic1.

Constructors

Generically1
Fields unGenerically1 :: f a

Instances

(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details Defined in Generic.Data.Internal.Generically type Rep1 (Generically1 f :: Type -> Type) = Rep1 f
type Rep (Generically1 f a) Source #
Instance details 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 Source #

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 Source #
Instance details Defined in Generic.Data.Internal.Newtype

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

Generic newtype constructor.

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

Generic newtype destructor.

Generic coercions

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

Convert between types with representationally equivalent generic representations.

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

Compose gcoerce with a binary operation.

Accessing metadata

Using TypeApplications.

Datatype

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

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

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

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

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

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

True if the first type constructor is a newtype.

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

class GDatatype f Source #

Generic representations that contain datatype metadata.

Minimal complete definition

gDatatypeName, gModuleName, gPackageName, gIsNewtype

Instances

Datatype d => GDatatype (M1 D d f :: k -> Type) Source #
Instance details Defined in Generic.Data.Internal.Meta Methods gDatatypeName :: String Source # gModuleName :: String Source # gPackageName :: String Source # gIsNewtype :: Bool Source #

Constructor

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

Name of the first constructor in a value.

>>> gconName (Just 0)
"Just"

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

The fixity of the first constructor.

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

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

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

Number of constructors.

>>> gconNum @(Maybe Int)
2

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

Index of a constructor.

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

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

Constraint synonym for Generic and GConstructors.

Instances

(Generic a, GConstructors (Rep a)) => Constructors a Source #
Instance details Defined in Generic.Data.Internal.Meta

class GConstructors r Source #

Generic representations that contain constructor metadata.

Minimal complete definition

gConIdToString, gConId, gConNum, gConFixity, gConIsRecord

Instances

(GConstructors f, GConstructors g) => GConstructors (f :+: g :: k -> Type) Source #
Instance details Defined in Generic.Data.Internal.Meta Methods gConIdToString :: GConId (f :+: g) -> String Source # gConId :: (f :+: g) p -> GConId (f :+: g) Source # gConNum :: Int Source # gConFixity :: (f :+: g) p -> Fixity Source # gConIsRecord :: (f :+: g) p -> Bool Source #
Constructor c => GConstructors (M1 C c f :: k -> Type) Source #
Instance details Defined in Generic.Data.Internal.Meta Methods gConIdToString :: GConId (M1 C c f) -> String Source # gConId :: M1 C c f p -> GConId (M1 C c f) Source # gConNum :: Int Source # gConFixity :: M1 C c f p -> Fixity Source # gConIsRecord :: M1 C c f p -> Bool Source #
GConstructors f => GConstructors (M1 D c f :: k -> Type) Source #
Instance details Defined in Generic.Data.Internal.Meta Methods gConIdToString :: GConId (M1 D c f) -> String Source # gConId :: M1 D c f p -> GConId (M1 D c f) Source # gConNum :: Int Source # gConFixity :: M1 D c f p -> Fixity Source # gConIsRecord :: M1 D c f p -> Bool Source #

Constructor tags

data ConId a Source #

An opaque identifier for a constructor.

Instances

Eq (ConId a) Source #
Instance details Defined in Generic.Data.Internal.Meta Methods (==) :: ConId a -> ConId a -> Bool # (/=) :: ConId a -> ConId a -> Bool #
Ord (ConId a) Source #
Instance details 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 #
Show (ConId a) Source #
Instance details Defined in Generic.Data.Internal.Meta Methods showsPrec :: Int -> ConId a -> ShowS # show :: ConId a -> String # showList :: [ConId a] -> ShowS #

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

Identifier of a constructor.

conIdToInt :: forall a. ConId a -> Int Source #

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

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

Name of a constructor. See also gconName.

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

All constructor identifiers. This must not be called on an empty type.

gconNum @a = length (conIdEnum @a)

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

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

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

Instances

(Generic a, KnownNat (ConIdNamed' n a)) => ConIdNamed n a Source #
Instance details Defined in Generic.Data.Internal.Meta

Using type families

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

Meta field of the M1 type constructor.

Equations

MetaOf (M1 i d f) = d

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

Name of the data type (MetaData).

Equations

MetaDataName (MetaData n _m _p _nt) = n

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

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 ... Source #

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 ... Source #

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

Equations

MetaDataNewtype (MetaData _n _m _p nt) = nt

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

Name of the constructor (MetaCons).

Equations

MetaConsName (MetaCons n _f _s) = n

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

Fixity of the constructor (MetaCons).

Equations

MetaConsFixity (MetaCons _n f s) = f

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

True for a record constructor (MetaCons).

Equations

MetaConsRecord (MetaCons _n _f s) = s

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

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 ... Source #

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 ... Source #

Unpackedness annotation of a field (MetaSel).

Equations

MetaSelUnpack (MetaSel _mn su _ss _ds) = su

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

Strictness annotation of a field (MetaSel).

Equations

MetaSelSourceStrictness (MetaSel _mn _su ss _ds) = ss

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

Inferred strictness of a field (MetaSel).

Equations

MetaSelStrictness (MetaSel _mn _su _ss ds) = ds

GBounded (U1 :: Type -> Type) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gMinBound :: U1 p Source # gMaxBound :: U1 p Source #
Bounded c => GBounded (K1 i c :: Type -> Type) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gMinBound :: K1 i c p Source # gMaxBound :: K1 i c p Source #
(GBounded f, GBounded g) => GBounded (f :+: g) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gMinBound :: (f :+: g) p Source # gMaxBound :: (f :+: g) p Source #
(GBounded f, GBounded g) => GBounded (f :*: g) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gMinBound :: (f :: g) p Source # gMaxBound :: (f :: g) p Source #
GBounded f => GBounded (M1 i c f) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gMinBound :: M1 i c f p Source # gMaxBound :: M1 i c f p Source #

GIx (U1 :: Type -> Type) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gRange :: (U1 p, U1 p) -> [U1 p] Source # gUnsafeIndex :: (U1 p, U1 p) -> U1 p -> Int Source # gInRange :: (U1 p, U1 p) -> U1 p -> Bool Source #
Ix c => GIx (K1 i c :: Type -> Type) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gRange :: (K1 i c p, K1 i c p) -> [K1 i c p] Source # gUnsafeIndex :: (K1 i c p, K1 i c p) -> K1 i c p -> Int Source # gInRange :: (K1 i c p, K1 i c p) -> K1 i c p -> Bool Source #
(GEnum StandardEnum f, GEnum StandardEnum g) => GIx (f :+: g) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gRange :: ((f :+: g) p, (f :+: g) p) -> [(f :+: g) p] Source # gUnsafeIndex :: ((f :+: g) p, (f :+: g) p) -> (f :+: g) p -> Int Source # gInRange :: ((f :+: g) p, (f :+: g) p) -> (f :+: g) p -> Bool Source #
(GIx f, GIx g) => GIx (f :*: g) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gRange :: ((f :: g) p, (f :: g) p) -> [(f :: g) p] Source # gUnsafeIndex :: ((f :: g) p, (f :: g) p) -> (f :: g) p -> Int Source # gInRange :: ((f :: g) p, (f :: g) p) -> (f :*: g) p -> Bool Source #
GIx f => GIx (M1 i c f) Source #
Instance details Defined in Generic.Data.Internal.Enum Methods gRange :: (M1 i c f p, M1 i c f p) -> [M1 i c f p] Source # gUnsafeIndex :: (M1 i c f p, M1 i c f p) -> M1 i c f p -> Int Source # gInRange :: (M1 i c f p, M1 i c f p) -> M1 i c f p -> Bool Source #