License	BSD-style (see the file LICENSE)
Maintainer	sjoerd@w3future.com
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell98

Generics.OneLiner.Internal

Description

Synopsis

Documentation

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

Instances

type Constraints' V1 c c1 #
type Constraints' V1 c c1 = ()
type Constraints' U1 c c1 #
type Constraints' U1 c c1 = ()
type Constraints' Par1 c c1 #
type Constraints' Par1 c c1 = ()
type Constraints' (Rec1 f) c c1 #
type Constraints' (Rec1 f) c c1 = c1 f
type Constraints' (K1 i a) c c1 #
type Constraints' (K1 i a) c c1 = c a
type Constraints' ((:+:) f g) c c1 #
type Constraints' ((:+:) f g) c c1 = (Constraints' f c c1, Constraints' g c c1)
type Constraints' ((:*:) f g) c c1 #
type Constraints' ((:*:) f g) c c1 = (Constraints' f c c1, Constraints' g c c1)
type Constraints' ((:.:) f g) c c1 #
type Constraints' ((:.:) f g) c c1 = (c1 f, Constraints' g c c1)
type Constraints' (M1 i t f) c c1 #
type Constraints' (M1 i t f) c c1 = Constraints' f c c1

type ADT' = ADT_ Identity Proxy ADTProfunctor #

type ADTNonEmpty' = ADT_ Identity Proxy NonEmptyProfunctor #

type ADTRecord' = ADT_ Identity Proxy RecordProfunctor #

type ADT1' t = (ADT_ Identity Identity ADTProfunctor t, ADT_ Proxy Identity ADTProfunctor t) #

type ADTNonEmpty1' t = (ADT_ Identity Identity NonEmptyProfunctor t, ADT_ Proxy Identity NonEmptyProfunctor t) #

type ADTRecord1' t = (ADT_ Identity Identity RecordProfunctor t, ADT_ Proxy Identity RecordProfunctor t) #

type ADTProfunctor = GenericEmptyProfunctor ': NonEmptyProfunctor #

type NonEmptyProfunctor = GenericSumProfunctor ': RecordProfunctor #

type RecordProfunctor = '[GenericProductProfunctor, GenericUnitProfunctor, Profunctor] #

type family Satisfies (p :: * -> * -> *) (ks :: [(* -> * -> *) -> Constraint]) :: Constraint #

Instances

type Satisfies p ([] ((* -> * -> *) -> Constraint)) #
type Satisfies p ([] ((* -> * -> *) -> Constraint)) = ()
type Satisfies p ((:) ((* -> * -> *) -> Constraint) k ks) #
type Satisfies p ((:) ((* -> * -> *) -> Constraint) k ks) = (k p, Satisfies p ks)

class ks |- k where #

Minimal complete definition

(|-)

Methods

(|-) :: Satisfies p ks => proxy0 ks -> proxy1 k -> (k p => p a b) -> p a b #

Instances

((:) ((* -> * -> *) -> Constraint) k _ks) \|- k #
Methods (\|-) :: Satisfies p ((((* -> * -> ) -> Constraint) ': k) _ks) => proxy0 (((( -> * -> *) -> Constraint) ': k) _ks) -> proxy1 k -> (k p -> p a b) -> p a b #
(\|-) ks k => ((:) ((* -> * -> *) -> Constraint) _k ks) \|- k #
Methods (\|-) :: Satisfies p ((((* -> * -> ) -> Constraint) ': _k) ks) => proxy0 (((( -> * -> *) -> Constraint) ': _k) ks) -> proxy1 k -> (k p -> p a b) -> p a b #

generic' :: forall t c p ks a b proxy0 for. (ADT_ Identity Proxy ks t, Constraints' t c AnyType, Satisfies p ks) => proxy0 ks -> for c -> (forall s. c s => p s s) -> p (t a) (t b) #

generic1' :: forall t c1 p ks a b proxy0 for. (ADT_ Proxy Identity ks t, Constraints' t AnyType c1, Satisfies p ks) => proxy0 ks -> for c1 -> (forall s d e. c1 s => p d e -> p (s d) (s e)) -> p a b -> p (t a) (t b) #

generic01' :: forall t c0 c1 p ks a b proxy0 for for1. (ADT_ Identity Identity ks t, Constraints' t c0 c1, Satisfies p ks) => proxy0 ks -> for c0 -> (forall s. c0 s => p s s) -> for1 c1 -> (forall s d e. c1 s => p d e -> p (s d) (s e)) -> p a b -> p (t a) (t b) #

class ADT_ nullary unary ks t where #

Minimal complete definition

generic_

Methods

generic_ :: (Constraints' t c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (t a) (t b) #

Instances

(\|-) ks Profunctor => ADT_ nullary Identity ks Par1 #
Methods generic_ :: (Constraints' Par1 c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => Identity (p d e -> p (s1 d) (s1 e))) -> Identity (p a b) -> p (Par1 a) (Par1 b) #
(\|-) ks GenericUnitProfunctor => ADT_ nullary unary ks U1 #
Methods generic_ :: (Constraints' U1 c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (U1 a) (U1 b) #
(\|-) ks GenericEmptyProfunctor => ADT_ nullary unary ks V1 #
Methods generic_ :: (Constraints' V1 c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (V1 a) (V1 b) #
(\|-) ks Profunctor => ADT_ nullary Identity ks (Rec1 f) #
Methods generic_ :: (Constraints' (Rec1 f) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => Identity (p d e -> p (s1 d) (s1 e))) -> Identity (p a b) -> p (Rec1 f a) (Rec1 f b) #
((\|-) ks Profunctor, ADT_ nullary Identity ks g) => ADT_ nullary Identity ks ((:.:) f g) #
Methods generic_ :: (Constraints' (f :.: g) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => Identity (p d e -> p (s1 d) (s1 e))) -> Identity (p a b) -> p ((f :.: g) a) ((f :.: g) b) #
((\|-) ks GenericProductProfunctor, ADT_ nullary unary ks f, ADT_ nullary unary ks g) => ADT_ nullary unary ks ((:*:) f g) #
Methods generic_ :: (Constraints' (f :: g) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p ((f :: g) a) ((f :*: g) b) #
((\|-) ks GenericSumProfunctor, ADT_ nullary unary ks f, ADT_ nullary unary ks g) => ADT_ nullary unary ks ((:+:) f g) #
Methods generic_ :: (Constraints' (f :+: g) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p ((f :+: g) a) ((f :+: g) b) #
(\|-) ks Profunctor => ADT_ Identity unary ks (K1 i v) #
Methods generic_ :: (Constraints' (K1 i v) c c1, Satisfies p ks) => proxy0 ks -> proxy1 Identity -> for c -> (forall s. c s => Identity (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (K1 i v a) (K1 i v b) #
((\|-) ks Profunctor, ADT_ nullary unary ks f) => ADT_ nullary unary ks (M1 i c f) #
Methods generic_ :: (Constraints' (M1 i c f) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (M1 i c f a) (M1 i c f b) #
(\|-) ks GenericEmptyProfunctor => ADT_ (Proxy *) unary ks (K1 i v) #
Methods generic_ :: (Constraints' (K1 i v) c c1, Satisfies p ks) => proxy0 ks -> proxy1 (Proxy ) -> for c -> (forall s. c s => Proxy (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (K1 i v a) (K1 i v b) #

absurd :: V1 a -> b #

e1 :: (f a -> b) -> (g a -> b) -> (f :+: g) a -> b #

fst1 :: (f :*: g) a -> f a #

snd1 :: (f :*: g) a -> g a #

class Profunctor p => GenericUnitProfunctor p where #

Minimal complete definition

unit

Methods

unit :: p (U1 a) (U1 a') #

Instances

GenericUnitProfunctor (->) #
Methods unit :: U1 a -> U1 a' #
Applicative f => GenericUnitProfunctor (Star f) #
Methods unit :: Star f (U1 a) (U1 a') #
Functor f => GenericUnitProfunctor (Costar f) #
Methods unit :: Costar f (U1 a) (U1 a') #
GenericUnitProfunctor (Tagged *) #
Methods unit :: Tagged * (U1 a) (U1 a') #
GenericUnitProfunctor (Ctor *) #
Methods unit :: Ctor * (U1 a) (U1 a') #
Applicative f => GenericUnitProfunctor (Zip f) #
Methods unit :: Zip f (U1 a) (U1 a') #
Applicative f => GenericUnitProfunctor (Joker * * f) #
Methods unit :: Joker * * f (U1 a) (U1 a') #
Divisible f => GenericUnitProfunctor (Clown * * f) #
Methods unit :: Clown * * f (U1 a) (U1 a') #
(GenericUnitProfunctor p, GenericUnitProfunctor q) => GenericUnitProfunctor (Product * * p q) #
Methods unit :: Product * * p q (U1 a) (U1 a') #
(Applicative f, GenericUnitProfunctor p) => GenericUnitProfunctor (Tannen * * * f p) #
Methods unit :: Tannen * * * f p (U1 a) (U1 a') #
(Functor f, Applicative g, Profunctor p, GenericUnitProfunctor p) => GenericUnitProfunctor (Biff * * * * p f g) #
Methods unit :: Biff * * * * p f g (U1 a) (U1 a') #

class Profunctor p => GenericProductProfunctor p where #

Minimal complete definition

mult

Methods

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

Instances

GenericProductProfunctor (->) #
Methods mult :: (f a -> f' a') -> (g a -> g' a') -> (f :: g) a -> (f' :: g') a' #
Applicative f => GenericProductProfunctor (Star f) #
Methods mult :: Star f (f a) (f' a') -> Star f (g a) (g' a') -> Star f ((f :: g) a) ((f' :: g') a') #
Functor f => GenericProductProfunctor (Costar f) #
Methods mult :: Costar f (f a) (f' a') -> Costar f (g a) (g' a') -> Costar f ((f :: g) a) ((f' :: g') a') #
GenericProductProfunctor (Tagged *) #
Methods mult :: Tagged * (f a) (f' a') -> Tagged * (g a) (g' a') -> Tagged * ((f :: g) a) ((f' :: g') a') #
GenericProductProfunctor (Ctor *) #
Methods mult :: Ctor * (f a) (f' a') -> Ctor * (g a) (g' a') -> Ctor * ((f :: g) a) ((f' :: g') a') #
Applicative f => GenericProductProfunctor (Zip f) #
Methods mult :: Zip f (f a) (f' a') -> Zip f (g a) (g' a') -> Zip f ((f :: g) a) ((f' :: g') a') #
Applicative f => GenericProductProfunctor (Joker * * f) #
Methods mult :: Joker * * f (f a) (f' a') -> Joker * * f (g a) (g' a') -> Joker * * f ((f :: g) a) ((f' :: g') a') #
Divisible f => GenericProductProfunctor (Clown * * f) #
Methods mult :: Clown * * f (f a) (f' a') -> Clown * * f (g a) (g' a') -> Clown * * f ((f :: g) a) ((f' :: g') a') #
(GenericProductProfunctor p, GenericProductProfunctor q) => GenericProductProfunctor (Product * * p q) #
Methods mult :: Product * * p q (f a) (f' a') -> Product * * p q (g a) (g' a') -> Product * * p q ((f :: g) a) ((f' :: g') a') #
(Applicative f, GenericProductProfunctor p) => GenericProductProfunctor (Tannen * * * f p) #
Methods mult :: Tannen * * * f p (f a) (f' a') -> Tannen * * * f p (g a) (g' a') -> Tannen * * * f p ((f :: g) a) ((f' :: g') a') #
(Functor f, Applicative g, Profunctor p, GenericProductProfunctor p) => GenericProductProfunctor (Biff * * * * p f g) #
Methods mult :: Biff * * * * p f g (f a) (f' a') -> Biff * * * * p f g (g a) (g' a') -> Biff * * * * p f g ((f :: g) a) ((f' :: g') a') #

class Profunctor p => GenericSumProfunctor p where #

Minimal complete definition

plus

Methods

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

Instances

GenericSumProfunctor (->) #
Methods plus :: (f a -> f' a') -> (g a -> g' a') -> (f :+: g) a -> (f' :+: g') a' #
Applicative f => GenericSumProfunctor (Star f) #
Methods plus :: Star f (f a) (f' a') -> Star f (g a) (g' a') -> Star f ((f :+: g) a) ((f' :+: g') a') #
GenericSumProfunctor (Ctor *) #
Methods plus :: Ctor * (f a) (f' a') -> Ctor * (g a) (g' a') -> Ctor * ((f :+: g) a) ((f' :+: g') a') #
Alternative f => GenericSumProfunctor (Zip f) #
Methods plus :: Zip f (f a) (f' a') -> Zip f (g a) (g' a') -> Zip f ((f :+: g) a) ((f' :+: g') a') #
Alternative f => GenericSumProfunctor (Joker * * f) #
Methods plus :: Joker * * f (f a) (f' a') -> Joker * * f (g a) (g' a') -> Joker * * f ((f :+: g) a) ((f' :+: g') a') #
Decidable f => GenericSumProfunctor (Clown * * f) #
Methods plus :: Clown * * f (f a) (f' a') -> Clown * * f (g a) (g' a') -> Clown * * f ((f :+: g) a) ((f' :+: g') a') #
(GenericSumProfunctor p, GenericSumProfunctor q) => GenericSumProfunctor (Product * * p q) #
Methods plus :: Product * * p q (f a) (f' a') -> Product * * p q (g a) (g' a') -> Product * * p q ((f :+: g) a) ((f' :+: g') a') #
(Applicative f, GenericSumProfunctor p) => GenericSumProfunctor (Tannen * * * f p) #
Methods plus :: Tannen * * * f p (f a) (f' a') -> Tannen * * * f p (g a) (g' a') -> Tannen * * * f p ((f :+: g) a) ((f' :+: g') a') #

class Profunctor p => GenericEmptyProfunctor p where #

Minimal complete definition

identity, zero

Methods

identity :: p a a #

zero :: p (V1 a) (V1 a') #

Instances

GenericEmptyProfunctor (->) #
Methods identity :: a -> a # zero :: V1 a -> V1 a' #
Applicative f => GenericEmptyProfunctor (Star f) #
Methods identity :: Star f a a # zero :: Star f (V1 a) (V1 a') #
GenericEmptyProfunctor (Ctor *) #
Methods identity :: Ctor * a a # zero :: Ctor * (V1 a) (V1 a') #
Alternative f => GenericEmptyProfunctor (Zip f) #
Methods identity :: Zip f a a # zero :: Zip f (V1 a) (V1 a') #
Alternative f => GenericEmptyProfunctor (Joker * * f) #
Methods identity :: Joker * * f a a # zero :: Joker * * f (V1 a) (V1 a') #
Decidable f => GenericEmptyProfunctor (Clown * * f) #
Methods identity :: Clown * * f a a # zero :: Clown * * f (V1 a) (V1 a') #
(GenericEmptyProfunctor p, GenericEmptyProfunctor q) => GenericEmptyProfunctor (Product * * p q) #
Methods identity :: Product * * p q a a # zero :: Product * * p q (V1 a) (V1 a') #
(Applicative f, GenericEmptyProfunctor p) => GenericEmptyProfunctor (Tannen * * * f p) #
Methods identity :: Tannen * * * f p a a # zero :: Tannen * * * f p (V1 a) (V1 a') #

class (Profunctor p, GenericUnitProfunctor p, GenericProductProfunctor p) => GenericRecordProfunctor p #

A generic function using a GenericRecordProfunctor works on any data type with exactly one constructor, a.k.a. records, with multiple fields (mult) or no fields (unit).

GenericRecordProfunctor is similar to ProductProfuctor from the product-profunctor package, but using types from GHC.Generics.

Instances

(Profunctor p, GenericUnitProfunctor p, GenericProductProfunctor p) => GenericRecordProfunctor p #

class (GenericRecordProfunctor p, GenericSumProfunctor p) => GenericNonEmptyProfunctor p #

A generic function using a GenericNonEmptyProfunctor works on any data type with at least one constructor.

Instances

(GenericRecordProfunctor p, GenericSumProfunctor p) => GenericNonEmptyProfunctor p #

class (GenericNonEmptyProfunctor p, GenericEmptyProfunctor p) => GenericProfunctor p #

A generic function using a GenericProfunctor works on any algebraic data type, including those with no constructors and constants.

Instances

(GenericNonEmptyProfunctor p, GenericEmptyProfunctor p) => GenericProfunctor p #

data Ctor a b #

Constructors

Ctor
Fields index :: a -> Int count :: Int

Instances

Profunctor (Ctor *) #
Methods dimap :: (a -> b) -> (c -> d) -> Ctor * b c -> Ctor * a d # lmap :: (a -> b) -> Ctor * b c -> Ctor * a c # rmap :: (b -> c) -> Ctor * a b -> Ctor * a c # (#.) :: Coercible * c b => (b -> c) -> Ctor * a b -> Ctor * a c # (.#) :: Coercible * b a => Ctor * b c -> (a -> b) -> Ctor * a c #
GenericEmptyProfunctor (Ctor *) #
Methods identity :: Ctor * a a # zero :: Ctor * (V1 a) (V1 a') #
GenericSumProfunctor (Ctor *) #
Methods plus :: Ctor * (f a) (f' a') -> Ctor * (g a) (g' a') -> Ctor * ((f :+: g) a) ((f' :+: g') a') #
GenericProductProfunctor (Ctor *) #
Methods mult :: Ctor * (f a) (f' a') -> Ctor * (g a) (g' a') -> Ctor * ((f :: g) a) ((f' :: g') a') #
GenericUnitProfunctor (Ctor *) #
Methods unit :: Ctor * (U1 a) (U1 a') #

record :: forall c p t. (ADTRecord t, Constraints t c, GenericRecordProfunctor p) => (forall s. c s => p s s) -> p t t #

record1 :: forall c p t a b. (ADTRecord1 t, Constraints1 t c, GenericRecordProfunctor p) => (forall d e s. c s => p d e -> p (s d) (s e)) -> p a b -> p (t a) (t b) #

record01 :: forall c0 c1 p t a b. (ADTRecord1 t, Constraints01 t c0 c1, GenericRecordProfunctor p) => (forall s. c0 s => p s s) -> (forall d e s. c1 s => p d e -> p (s d) (s e)) -> p a b -> p (t a) (t b) #

nonEmpty :: forall c p t. (ADTNonEmpty t, Constraints t c, GenericNonEmptyProfunctor p) => (forall s. c s => p s s) -> p t t #

nonEmpty1 :: forall c p t a b. (ADTNonEmpty1 t, Constraints1 t c, GenericNonEmptyProfunctor p) => (forall d e s. c s => p d e -> p (s d) (s e)) -> p a b -> p (t a) (t b) #

nonEmpty01 :: forall c0 c1 p t a b. (ADTNonEmpty1 t, Constraints01 t c0 c1, GenericNonEmptyProfunctor p) => (forall s. c0 s => p s s) -> (forall d e s. c1 s => p d e -> p (s d) (s e)) -> p a b -> p (t a) (t b) #

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

generic1 :: forall c p t a b. (ADT1 t, Constraints1 t c, GenericProfunctor p) => (forall d e s. c s => p d e -> p (s d) (s e)) -> p a b -> p (t a) (t b) #

generic01 :: forall c0 c1 p t a b. (ADT1 t, Constraints01 t c0 c1, GenericProfunctor p) => (forall s. c0 s => p s s) -> (forall d e s. c1 s => p d e -> p (s d) (s e)) -> p a b -> p (t a) (t b) #

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

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 Constraints1 t c = Constraints' (Rep1 t) AnyType c #

type Constraints01 t c0 c1 = Constraints' (Rep1 t) c0 c1 #

type ADTRecord t = (Generic t, ADTRecord' (Rep t), Constraints t AnyType) #

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

type ADTRecord1 t = (Generic1 t, ADTRecord1' (Rep1 t), Constraints1 t AnyType) #

type ADTNonEmpty t = (Generic t, ADTNonEmpty' (Rep t), Constraints t AnyType) #

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

type ADTNonEmpty1 t = (Generic1 t, ADTNonEmpty1' (Rep1 t), Constraints1 t AnyType) #

type ADT t = (Generic t, ADT' (Rep t), Constraints t AnyType) #

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

type ADT1 t = (Generic1 t, ADT1' (Rep1 t), Constraints1 t AnyType) #

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 @Binary put t

ctorIndex1 :: ADT1 t => t a -> Int #

class AnyType a #

Any type is instance of AnyType, you can use it with @AnyType if you don't actually need a class constraint.

Instances

AnyType k a #

type family FunResult t where ... #

The result type of a curried function.

If r is not a function type (i.e., does not unify with `_ -> _`):

FunResult (a -> r) ~ r
FunResult (a -> b -> r) ~ r
FunResult (a -> b -> c -> r) ~ r

Equations

FunResult (a -> b) = FunResult b
FunResult r = r

class FunConstraints c t where #

Automatically apply a lifted function to a polymorphic argument as many times as possible.

A constraint `FunConstraint c t` is equivalent to the conjunction of constraints `c s` for every argument type of t.

If r is not a function type:

c a :- FunConstraints c (a -> r)
(c a, c b) :- FunConstraints c (a -> b -> r)
(c a, c b, c d) :- FunConstraints c (a -> b -> d -> r)

Minimal complete definition

autoApply

Methods

autoApply :: Applicative f => (forall s. c s => f s) -> f t -> f (FunResult t) #

Instances

(~) * (FunResult r) r => FunConstraints c r #
Methods autoApply :: Applicative f => (forall s. c s => f s) -> f r -> f (FunResult r) #
(c a, FunConstraints c b) => FunConstraints c (a -> b) #
Methods autoApply :: Applicative f => (forall s. c s => f s) -> f (a -> b) -> f (FunResult (a -> b)) #

((:) ((* -> * -> *) -> Constraint) k _ks) \|- k #
Methods (\|-) :: Satisfies p ((((* -> * -> ) -> Constraint) ': k) _ks) => proxy0 (((( -> * -> *) -> Constraint) ': k) _ks) -> proxy1 k -> (k p -> p a b) -> p a b #
(\|-) ks k => ((:) ((* -> * -> *) -> Constraint) _k ks) \|- k #
Methods (\|-) :: Satisfies p ((((* -> * -> ) -> Constraint) ': _k) ks) => proxy0 (((( -> * -> *) -> Constraint) ': _k) ks) -> proxy1 k -> (k p -> p a b) -> p a b #

(\|-) ks Profunctor => ADT_ nullary Identity ks Par1 #
Methods generic_ :: (Constraints' Par1 c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => Identity (p d e -> p (s1 d) (s1 e))) -> Identity (p a b) -> p (Par1 a) (Par1 b) #
(\|-) ks GenericUnitProfunctor => ADT_ nullary unary ks U1 #
Methods generic_ :: (Constraints' U1 c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (U1 a) (U1 b) #
(\|-) ks GenericEmptyProfunctor => ADT_ nullary unary ks V1 #
Methods generic_ :: (Constraints' V1 c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (V1 a) (V1 b) #
(\|-) ks Profunctor => ADT_ nullary Identity ks (Rec1 f) #
Methods generic_ :: (Constraints' (Rec1 f) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => Identity (p d e -> p (s1 d) (s1 e))) -> Identity (p a b) -> p (Rec1 f a) (Rec1 f b) #
((\|-) ks Profunctor, ADT_ nullary Identity ks g) => ADT_ nullary Identity ks ((:.:) f g) #
Methods generic_ :: (Constraints' (f :.: g) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => Identity (p d e -> p (s1 d) (s1 e))) -> Identity (p a b) -> p ((f :.: g) a) ((f :.: g) b) #
((\|-) ks GenericProductProfunctor, ADT_ nullary unary ks f, ADT_ nullary unary ks g) => ADT_ nullary unary ks ((:*:) f g) #
Methods generic_ :: (Constraints' (f :: g) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p ((f :: g) a) ((f :*: g) b) #
((\|-) ks GenericSumProfunctor, ADT_ nullary unary ks f, ADT_ nullary unary ks g) => ADT_ nullary unary ks ((:+:) f g) #
Methods generic_ :: (Constraints' (f :+: g) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p ((f :+: g) a) ((f :+: g) b) #
(\|-) ks Profunctor => ADT_ Identity unary ks (K1 i v) #
Methods generic_ :: (Constraints' (K1 i v) c c1, Satisfies p ks) => proxy0 ks -> proxy1 Identity -> for c -> (forall s. c s => Identity (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (K1 i v a) (K1 i v b) #
((\|-) ks Profunctor, ADT_ nullary unary ks f) => ADT_ nullary unary ks (M1 i c f) #
Methods generic_ :: (Constraints' (M1 i c f) c c1, Satisfies p ks) => proxy0 ks -> proxy1 nullary -> for c -> (forall s. c s => nullary (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (M1 i c f a) (M1 i c f b) #
(\|-) ks GenericEmptyProfunctor => ADT_ (Proxy *) unary ks (K1 i v) #
Methods generic_ :: (Constraints' (K1 i v) c c1, Satisfies p ks) => proxy0 ks -> proxy1 (Proxy ) -> for c -> (forall s. c s => Proxy (p s s)) -> for1 c1 -> (forall s1 d e. c1 s1 => unary (p d e -> p (s1 d) (s1 e))) -> unary (p a b) -> p (K1 i v a) (K1 i v b) #