Generics.OneLiner.Internal

Documentation

type family Constraints' (t :: * -> *) (c :: * -> Constraint) :: Constraint

Instances

type Constraints' V1 c

type Constraints' V1 c = ()

type Constraints' U1 c

type Constraints' U1 c = ()

type Constraints' (K1 i a) c

type Constraints' (K1 i a) c = c a

type Constraints' ((:+:) f g) c

type Constraints' ((:+:) f g) c = (Constraints' f c, Constraints' g c)

type Constraints' ((:*:) f g) c

type Constraints' ((:*:) f g) c = (Constraints' f c, Constraints' g c)

type Constraints' (M1 i t f) c

type Constraints' (M1 i t f) c = Constraints' f c

class ADT' t where

Minimal complete definition

p

Associated Types

type CtorCount' t :: Nat

Methods

ctorIndex' :: t x -> Int

ctorCount :: proxy t -> Int

p :: (Constraints' t c, GenericProfunctor p) => for c -> (forall s. c s => p s s) -> p (t x) (t x)

Instances

ADT' V1

Associated Types

type CtorCount' (V1 :: * -> *) :: Nat

Methods

ctorIndex' :: V1 x -> Int

ctorCount :: proxy V1 -> Int

p :: (Constraints' V1 c, GenericProfunctor p) => for c -> (forall s. c s => p s s) -> p (V1 x) (V1 x)

ADT' U1

Associated Types

type CtorCount' (U1 :: * -> *) :: Nat

Methods

ctorIndex' :: U1 x -> Int

ctorCount :: proxy U1 -> Int

p :: (Constraints' U1 c, GenericProfunctor p) => for c -> (forall s. c s => p s s) -> p (U1 x) (U1 x)

ADT' (K1 i v)

Associated Types

type CtorCount' (K1 i v :: * -> *) :: Nat

Methods

ctorIndex' :: K1 i v x -> Int

ctorCount :: proxy (K1 i v) -> Int

p :: (Constraints' (K1 i v) c, GenericProfunctor p) => for c -> (forall s. c s => p s s) -> p (K1 i v x) (K1 i v x)

(ADT' f, ADT' g) => ADT' ((:+:) f g)

Associated Types

type CtorCount' ((:+:) f g :: * -> *) :: Nat

Methods

ctorIndex' :: (f :+: g) x -> Int

ctorCount :: proxy (f :+: g) -> Int

p :: (Constraints' (f :+: g) c, GenericProfunctor p) => for c -> (forall s. c s => p s s) -> p ((f :+: g) x) ((f :+: g) x)

(ADT' f, ADT' g) => ADT' ((:*:) f g)

Associated Types

type CtorCount' ((:*:) f g :: * -> *) :: Nat

Methods

ctorIndex' :: (f :*: g) x -> Int

ctorCount :: proxy (f :*: g) -> Int

p :: (Constraints' (f :*: g) c, GenericProfunctor p) => for c -> (forall s. c s => p s s) -> p ((f :*: g) x) ((f :*: g) x)

ADT' f => ADT' (M1 i t f)

Associated Types

type CtorCount' (M1 i t f :: * -> *) :: Nat

Methods

ctorIndex' :: M1 i t f x -> Int

ctorCount :: proxy (M1 i t f) -> Int

p :: (Constraints' (M1 i t f) c, GenericProfunctor p) => for c -> (forall s. c s => p s s) -> p (M1 i t f x) (M1 i t f x)

class Profunctor p => GenericProfunctor p where

Minimal complete definition

zero, unit, plus, mult

Methods

zero :: p (V1 a) (V1 a)

unit :: p (U1 a) (U1 a)

plus :: p (f a) (f' a) -> p (g a) (g' a) -> p ((f :+: g) a) ((f' :+: g') a)

mult :: p (f a) (f' a) -> p (g a) (g' a) -> p ((f :*: g) a) ((f' :*: g') a)

Instances

Applicative f => GenericProfunctor (Star f)

Methods

zero :: Star f (V1 a) (V1 a)

unit :: Star f (U1 a) (U1 a)

plus :: Star f (f a) (f' a) -> Star f (g a) (g' a) -> Star f ((f :+: g) a) ((f' :+: g') a)

mult :: Star f (f a) (f' a) -> Star f (g a) (g' a) -> Star f ((f :*: g) a) ((f' :*: g') a)

generic :: (ADT t, Constraints t c, GenericProfunctor p) => for c -> (forall s. c s => p s s) -> p t t

All the above functions have been implemented using this single function, using different profunctors.

type Constraints t c = Constraints' (Rep t) c

Constraints is a constraint type synonym, containing the constraint requirements for an instance for t of class c. It requires an instance of class c for each component of t.

type ADT t = (Generic t, ADT' (Rep t))

ADT is a constraint type synonym. The Generic instance can be derived, and any generic representation will be an instance of ADT'.

type CtorCount t = CtorCount' (Rep t)

CtorCount is the number of constructors of a type at the type level. F.e. if you want to require that a type has at least two constructors, you can add the constraint (2 <= CtorCount t).

type ADTRecord t = (ADT t, 1 ~ CtorCount t)

ADTRecord is a constraint type synonym. An instance is an ADT with *exactly* one constructor.

type ADTNonEmpty t = (ADT t, 1 <= CtorCount t)

ADTNonEmpty is a constraint type synonym. An instance is an ADT with *at least* one constructor.

data For c

Tell the compiler which class we want to use in the traversal. Should be used like this:

(For :: For Show)

Where Show can be any class.

Constructors

For

ctorIndex :: ADT t => t -> Int

Get the index in the lists returned by create and createA of the constructor of the given value.

For example, this is the implementation of put that generates the binary data that the above implentation of get expects:

put t = putWord8 (toEnum (ctorIndex t)) <> gfoldMap (For :: For Binary) put t