Safe Haskell	None
Language	Haskell2010

Barbies.Internal

Contents

Functor
Traversable
Distributive
Applicative
Constraints
Bare values
Generic derivation support

Synopsis

gbmapDefault :: CanDeriveFunctorB b f g => (forall (a :: k). f a -> g a) -> b f -> b g
class GFunctor (n :: Nat) (f :: k -> Type) (g :: k -> Type) (repbf :: k1 -> Type) (repbg :: k1 -> Type) where
- gmap :: forall (x :: k1). Proxy n -> (forall (a :: k). f a -> g a) -> repbf x -> repbg x
type CanDeriveFunctorB (b :: (k -> Type) -> Type) (f :: k -> Type) (g :: k -> Type) = (GenericP 0 (b f), GenericP 0 (b g), GFunctor 0 f g (RepP 0 (b f)) (RepP 0 (b g)))
type CanDeriveFunctorT (t :: (k -> Type) -> k1 -> Type) (f :: k -> Type) (g :: k -> Type) (x :: k1) = (GenericP 1 (t f x), GenericP 1 (t g x), GFunctor 1 f g (RepP 1 (t f x)) (RepP 1 (t g x)))
gbtraverseDefault :: forall {k1} b f g e. (Applicative e, CanDeriveTraversableB b f g) => (forall (a :: k1). f a -> e (g a)) -> b f -> e (b g)
class GTraversable (n :: k) (f :: k1 -> Type) (g :: k1 -> Type) (repbf :: k2 -> Type) (repbg :: k2 -> Type) where
- gtraverse :: forall t (x :: k2). Applicative t => Proxy n -> (forall (a :: k1). f a -> t (g a)) -> repbf x -> t (repbg x)
type CanDeriveTraversableB (b :: (k1 -> Type) -> Type) (f :: k1 -> Type) (g :: k1 -> Type) = (GenericP 0 (b f), GenericP 0 (b g), GTraversable 0 f g (RepP 0 (b f)) (RepP 0 (b g)))
type CanDeriveTraversableT (t :: (k1 -> Type) -> k -> Type) (f :: k1 -> Type) (g :: k1 -> Type) (x :: k) = (GenericP 1 (t f x), GenericP 1 (t g x), GTraversable 1 f g (RepP 1 (t f x)) (RepP 1 (t g x)))
gbdistributeDefault :: forall {k1} b f (g :: k1 -> Type). (CanDeriveDistributiveB b f g, Functor f) => f (b g) -> b (Compose f g)
class Functor f => GDistributive (n :: Nat) (f :: Type -> Type) (repbg :: k -> Type) (repbfg :: k -> Type) where
- gdistribute :: forall (x :: k). Proxy n -> f (repbg x) -> repbfg x
type CanDeriveDistributiveB (b :: (k1 -> Type) -> Type) (f :: Type -> Type) (g :: k1 -> Type) = (GenericP 0 (b g), GenericP 0 (b (Compose f g)), GDistributive 0 f (RepP 0 (b g)) (RepP 0 (b (Compose f g))))
type CanDeriveDistributiveT (t :: (Type -> Type) -> i -> Type) (f :: Type -> Type) (g :: Type -> Type) (x :: i) = (GenericP 1 (t g x), GenericP 1 (t (Compose f g) x), GDistributive 1 f (RepP 1 (t g x)) (RepP 1 (t (Compose f g) x)))
gbpureDefault :: CanDeriveApplicativeB b f f => (forall (a :: k). f a) -> b f
gbprodDefault :: forall {k} b (f :: k -> Type) (g :: k -> Type). CanDeriveApplicativeB b f g => b f -> b g -> b (Product f g)
class GApplicative (n :: k) (f :: k2 -> Type) (g :: k2 -> Type) (repbf :: k1 -> Type) (repbg :: k1 -> Type) (repbfg :: k1 -> Type) where
- gprod :: forall (x :: k1). Proxy n -> Proxy f -> Proxy g -> repbf x -> repbg x -> repbfg x
- gpure :: forall (x :: k1). (f ~ g, repbf ~ repbg) => Proxy n -> Proxy f -> Proxy repbf -> Proxy repbfg -> (forall (a :: k2). f a) -> repbf x
type CanDeriveApplicativeB (b :: (k -> Type) -> Type) (f :: k -> Type) (g :: k -> Type) = (GenericP 0 (b f), GenericP 0 (b g), GenericP 0 (b (Product f g)), GApplicative 0 f g (RepP 0 (b f)) (RepP 0 (b g)) (RepP 0 (b (Product f g))))
type CanDeriveApplicativeT (t :: (k -> Type) -> k1 -> Type) (f :: k -> Type) (g :: k -> Type) (x :: k1) = (GenericP 1 (t f x), GenericP 1 (t g x), GenericP 1 (t (Product f g) x), GApplicative 1 f g (RepP 1 (t f x)) (RepP 1 (t g x)) (RepP 1 (t (Product f g) x)))
gbaddDictsDefault :: forall {k} b (c :: k -> Constraint) (f :: k -> Type). (CanDeriveConstraintsB c b f, AllB c b) => b f -> b (Product (Dict c) f)
class GConstraints (n :: Nat) (c :: k -> Constraint) (f :: k1) (repbx :: Type -> Type) (repbf :: k2 -> Type) (repbdf :: k2 -> Type) where
- gaddDicts :: forall (x :: k2). GAll n c repbx => repbf x -> repbdf x
type CanDeriveConstraintsB (c :: k -> Constraint) (b :: (k -> Type) -> Type) (f :: k -> Type) = (GenericN (b f), GenericN (b (Product (Dict c) f)), AllB c b ~ GAll 0 c (GAllRepB b), GConstraints 0 c f (GAllRepB b) (RepN (b f)) (RepN (b (Product (Dict c) f))))
type CanDeriveConstraintsT (c :: k -> Constraint) (t :: (k -> Type) -> kg -> Type) (f :: k -> Type) (x :: kg) = (GenericN (t f x), GenericN (t (Product (Dict c) f) x), AllT c t ~ GAll 1 c (GAllRepT t), GConstraints 1 c f (GAllRepT t) (RepN (t f x)) (RepN (t (Product (Dict c) f) x)))
type family GAll (n :: Nat) (c :: k -> Constraint) (repbf :: Type -> Type)
type GAllRepB (b :: (k -> Type) -> Type) = TagSelf0 b
type GAllRepT (t :: (k -> Type) -> kg -> Type) = TagSelf1 t
data X (a :: k)
data family Y :: k
data Self p a x
data Other p a x
type family SelfOrOther (b :: k) (b' :: k) :: Type -> Type -> Type -> Type where ...
type TagSelf0 (b :: (k -> Type) -> Type) = TagSelf0' (Indexed b 1) (RepN (b (X :: k -> Type)))
type family TagSelf0' (b :: kf -> Type) (repbf :: Type -> Type) :: Type -> Type where ...
type TagSelf1 (b :: (k -> Type) -> kg -> Type) = TagSelf1' (Indexed b 2) (Zip (Rep (Indexed (b (X :: k -> Type)) 1 (Y :: kg))) (Rep (b (X :: k -> Type) (Y :: kg))))
type family TagSelf1' (b :: kf -> kg -> Type) (repbf :: Type -> Type) :: Type -> Type where ...
gbcoverDefault :: CanDeriveBareB b => b Bare Identity -> b Covered Identity
gbstripDefault :: CanDeriveBareB b => b Covered Identity -> b Bare Identity
class GBare (n :: Nat) (repbi :: k -> Type) (repbb :: k -> Type) where
- gstrip :: forall (x :: k). Proxy n -> repbi x -> repbb x
- gcover :: forall (x :: k). Proxy n -> repbb x -> repbi x
type CanDeriveBareB (b :: Type -> (Type -> Type) -> Type) = (GenericP 0 (b Bare Identity), GenericP 0 (b Covered Identity), GBare 0 (RepP 0 (b Covered Identity)) (RepP 0 (b Bare Identity)))
class Generic a where
- type Rep a :: Type -> Type
- from :: a -> Rep a x
- to :: Rep a x -> a
class Generic1 (f :: k -> Type) where
- type Rep1 (f :: k -> Type) :: k -> Type
- from1 :: forall (a :: k). f a -> Rep1 f a
- to1 :: forall (a :: k). Rep1 f a -> f a
class Datatype (d :: k) where
- datatypeName :: forall k1 t (f :: k1 -> Type) (a :: k1). t d f a -> [Char]
- moduleName :: forall k1 t (f :: k1 -> Type) (a :: k1). t d f a -> [Char]
- packageName :: forall k1 t (f :: k1 -> Type) (a :: k1). t d f a -> [Char]
- isNewtype :: forall k1 t (f :: k1 -> Type) (a :: k1). t d f a -> Bool
class Constructor (c :: k) where
- conName :: forall k1 t (f :: k1 -> Type) (a :: k1). t c f a -> [Char]
- conFixity :: forall k1 t (f :: k1 -> Type) (a :: k1). t c f a -> Fixity
- conIsRecord :: forall k1 t (f :: k1 -> Type) (a :: k1). t c f a -> Bool
class Selector (s :: k) where
- selName :: forall k1 t (f :: k1 -> Type) (a :: k1). t s f a -> [Char]
- selSourceUnpackedness :: forall k1 t (f :: k1 -> Type) (a :: k1). t s f a -> SourceUnpackedness
- selSourceStrictness :: forall k1 t (f :: k1 -> Type) (a :: k1). t s f a -> SourceStrictness
- selDecidedStrictness :: forall k1 t (f :: k1 -> Type) (a :: k1). t s f a -> DecidedStrictness
data V1 (p :: k)
data U1 (p :: k) = U1
newtype Par1 p = Par1 {
- unPar1 :: p
}
newtype Rec1 (f :: k -> Type) (p :: k) = Rec1 {
- unRec1 :: f p
}
newtype K1 i c (p :: k) = K1 {
- unK1 :: c
}
newtype M1 i (c :: Meta) (f :: k -> Type) (p :: k) = M1 {
- unM1 :: f p
}
data ((f :: k -> Type) :+: (g :: k -> Type)) (p :: k)
- = L1 (f p)
- | R1 (g p)
data ((f :: k -> Type) :*: (g :: k -> Type)) (p :: k) = (f p) :*: (g p)
newtype ((f :: k2 -> Type) :.: (g :: k1 -> k2)) (p :: k1) = Comp1 {
- unComp1 :: f (g p)
}
data R
data D
data C
data S
type Rec0 = K1 R :: Type -> k -> Type
type D1 = M1 D :: Meta -> (k -> Type) -> k -> Type
type C1 = M1 C :: Meta -> (k -> Type) -> k -> Type
type S1 = M1 S :: Meta -> (k -> Type) -> k -> Type
type family Rep a :: Type -> Type
type family Rep1 (f :: k -> Type) :: k -> Type
data family URec a (p :: k)
type UAddr = URec (Ptr ()) :: k -> Type
type UChar = URec Char :: k -> Type
type UDouble = URec Double :: k -> Type
type UFloat = URec Float :: k -> Type
type UInt = URec Int :: k -> Type
type UWord = URec Word :: k -> Type
data FixityI
- = PrefixI
- | InfixI Associativity Nat
data Associativity
- = LeftAssociative
- | RightAssociative
- | NotAssociative
data SourceUnpackedness
- = NoSourceUnpackedness
- | SourceNoUnpack
- | SourceUnpack
data SourceStrictness
- = NoSourceStrictness
- | SourceLazy
- | SourceStrict
data DecidedStrictness
- = DecidedLazy
- | DecidedStrict
- | DecidedUnpack
data Meta
- = MetaData Symbol Symbol Symbol Bool
- | MetaCons Symbol FixityI Bool
- | MetaSel (Maybe Symbol) SourceUnpackedness SourceStrictness DecidedStrictness
prec :: Fixity -> Int
newtype Generically1 (f :: k -> Type) (a :: k) where
- Generically1 :: forall {k} (f :: k -> Type) (a :: k). f a -> Generically1 f a
newtype Generically a = Generically a
data Fixity
- = Prefix
- | Infix Associativity Int
class (Coercible (Rep a) (RepN a), Generic a) => GenericN a where
- type RepN a :: Type -> Type
- toN :: RepN a x -> a
- fromN :: a -> RepN a x
newtype Rec p a (x :: k) = Rec {
- unRec :: K1 R a x
}
data family Param (n :: Nat) (a :: k) :: k
type family Indexed (t :: k) (i :: Nat) :: k where ...
type family FilterIndex (n :: Nat) (t :: k) :: k where ...
type family Zip (a :: Type -> Type) (b :: Type -> Type) :: Type -> Type where ...
class (Coercible (Rep a) (RepP n a), Generic a) => GenericP (n :: Nat) a where
- type RepP (n :: Nat) a :: Type -> Type
- toP :: Proxy n -> RepP n a x -> a
- fromP :: Proxy n -> a -> RepP n a x
type family RepN a :: Type -> Type
type family RepP (n :: Nat) a :: Type -> Type

Functor

gbmapDefault :: CanDeriveFunctorB b f g => (forall (a :: k). f a -> g a) -> b f -> b g Source #

Default implementation of bmap based on Generic.

class GFunctor (n :: Nat) (f :: k -> Type) (g :: k -> Type) (repbf :: k1 -> Type) (repbg :: k1 -> Type) where Source #

Methods

gmap :: forall (x :: k1). Proxy n -> (forall (a :: k). f a -> g a) -> repbf x -> repbg x Source #

Instances

Instances details

GFunctor n (f :: k1 -> Type) (g :: k1 -> Type) (U1 :: k2 -> Type) (U1 :: k2 -> Type) Source #
Instance details Defined in Barbies.Generics.Functor Methods gmap :: forall (x :: k2). Proxy n -> (forall (a :: k1). f a -> g a) -> U1 x -> U1 x Source #
GFunctor n (f :: k1 -> Type) (g :: k1 -> Type) (V1 :: k2 -> Type) (V1 :: k2 -> Type) Source #
Instance details Defined in Barbies.Generics.Functor Methods gmap :: forall (x :: k2). Proxy n -> (forall (a :: k1). f a -> g a) -> V1 x -> V1 x Source #
GFunctor n (f :: k1 -> Type) (g :: k1 -> Type) (Rec x x :: k2 -> Type) (Rec x x :: k2 -> Type) Source #
Instance details Defined in Barbies.Generics.Functor Methods gmap :: forall (x0 :: k2). Proxy n -> (forall (a :: k1). f a -> g a) -> Rec x x x0 -> Rec x x x0 Source #
(GFunctor n f g l l', GFunctor n f g r r') => GFunctor n (f :: k1 -> Type) (g :: k1 -> Type) (l :: r :: k2 -> Type) (l' :: r' :: k2 -> Type) Source #
Instance details Defined in Barbies.Generics.Functor Methods gmap :: forall (x :: k2). Proxy n -> (forall (a :: k1). f a -> g a) -> (l :: r) x -> (l' :: r') x Source #
(GFunctor n f g l l', GFunctor n f g r r') => GFunctor n (f :: k1 -> Type) (g :: k1 -> Type) (l :+: r :: k2 -> Type) (l' :+: r' :: k2 -> Type) Source #
Instance details Defined in Barbies.Generics.Functor Methods gmap :: forall (x :: k2). Proxy n -> (forall (a :: k1). f a -> g a) -> (l :+: r) x -> (l' :+: r') x Source #
GFunctor n f g bf bg => GFunctor n (f :: k1 -> Type) (g :: k1 -> Type) (M1 i c bf :: k2 -> Type) (M1 i c bg :: k2 -> Type) Source #
Instance details Defined in Barbies.Generics.Functor Methods gmap :: forall (x :: k2). Proxy n -> (forall (a :: k1). f a -> g a) -> M1 i c bf x -> M1 i c bg x Source #

type CanDeriveFunctorB (b :: (k -> Type) -> Type) (f :: k -> Type) (g :: k -> Type) = (GenericP 0 (b f), GenericP 0 (b g), GFunctor 0 f g (RepP 0 (b f)) (RepP 0 (b g))) Source #

CanDeriveFunctorB B f g is in practice a predicate about B only. Intuitively, it says that the following holds, for any arbitrary f:

There is an instance of Generic (B f).
B f can contain fields of type b f as long as there exists a FunctorB b instance. In particular, recursive usages of B f are allowed.
B f can also contain usages of b f under a Functor h. For example, one could use Maybe (B f) when defining B f.

type CanDeriveFunctorT (t :: (k -> Type) -> k1 -> Type) (f :: k -> Type) (g :: k -> Type) (x :: k1) = (GenericP 1 (t f x), GenericP 1 (t g x), GFunctor 1 f g (RepP 1 (t f x)) (RepP 1 (t g x))) Source #

CanDeriveFunctorT T f g x is in practice a predicate about T only. Intuitively, it says that the following holds, for any arbitrary f:

There is an instance of Generic (T f).
T f x can contain fields of type t f y as long as there exists a FunctorT t instance. In particular, recursive usages of T f y are allowed.
T f x can also contain usages of t f y under a Functor h. For example, one could use Maybe (T f y) when defining T f y.

Traversable

gbtraverseDefault :: forall {k1} b f g e. (Applicative e, CanDeriveTraversableB b f g) => (forall (a :: k1). f a -> e (g a)) -> b f -> e (b g) Source #

Default implementation of btraverse based on Generic.

class GTraversable (n :: k) (f :: k1 -> Type) (g :: k1 -> Type) (repbf :: k2 -> Type) (repbg :: k2 -> Type) where Source #

Methods

gtraverse :: forall t (x :: k2). Applicative t => Proxy n -> (forall (a :: k1). f a -> t (g a)) -> repbf x -> t (repbg x) Source #

Instances

Instances details

GTraversable (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (U1 :: k3 -> Type) (U1 :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k3). Applicative t => Proxy n -> (forall (a :: k2). f a -> t (g a)) -> U1 x -> t (U1 x) Source #
GTraversable (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (V1 :: k3 -> Type) (V1 :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k3). Applicative t => Proxy n -> (forall (a :: k2). f a -> t (g a)) -> V1 x -> t (V1 x) Source #
GTraversable (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (Rec a a :: k3 -> Type) (Rec a a :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k3). Applicative t => Proxy n -> (forall (a0 :: k2). f a0 -> t (g a0)) -> Rec a a x -> t (Rec a a x) Source #
(GTraversable n f g l l', GTraversable n f g r r') => GTraversable (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (l :: r :: k3 -> Type) (l' :: r' :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k3). Applicative t => Proxy n -> (forall (a :: k2). f a -> t (g a)) -> (l :: r) x -> t ((l' :: r') x) Source #
(GTraversable n f g l l', GTraversable n f g r r') => GTraversable (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (l :+: r :: k3 -> Type) (l' :+: r' :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k3). Applicative t => Proxy n -> (forall (a :: k2). f a -> t (g a)) -> (l :+: r) x -> t ((l' :+: r') x) Source #
GTraversable n f g bf bg => GTraversable (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (M1 i c bf :: k3 -> Type) (M1 i c bg :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Traversable Methods gtraverse :: forall t (x :: k3). Applicative t => Proxy n -> (forall (a :: k2). f a -> t (g a)) -> M1 i c bf x -> t (M1 i c bg x) Source #

type CanDeriveTraversableB (b :: (k1 -> Type) -> Type) (f :: k1 -> Type) (g :: k1 -> Type) = (GenericP 0 (b f), GenericP 0 (b g), GTraversable 0 f g (RepP 0 (b f)) (RepP 0 (b g))) Source #

CanDeriveTraversableB B f g is in practice a predicate about B only. It is analogous to CanDeriveFunctorB, so it essentially requires the following to hold, for any arbitrary f:

There is an instance of Generic (B f).
B f can contain fields of type b f as long as there exists a TraversableB b instance. In particular, recursive usages of B f are allowed.
B f can also contain usages of b f under a Traversable h. For example, one could use Maybe (B f) when defining B f.

type CanDeriveTraversableT (t :: (k1 -> Type) -> k -> Type) (f :: k1 -> Type) (g :: k1 -> Type) (x :: k) = (GenericP 1 (t f x), GenericP 1 (t g x), GTraversable 1 f g (RepP 1 (t f x)) (RepP 1 (t g x))) Source #

CanDeriveTraversableT T f g x is in practice a predicate about T only. It is analogous to CanDeriveFunctorT, so it essentially requires the following to hold, for any arbitrary f:

There is an instance of Generic (T f x).
T f x can contain fields of type t f x as long as there exists a TraversableT t instance. In particular, recursive usages of T f x are allowed.
T f x can also contain usages of t f x under a Traversable h. For example, one could use Maybe (T f x) when defining T f x.

Distributive

gbdistributeDefault :: forall {k1} b f (g :: k1 -> Type). (CanDeriveDistributiveB b f g, Functor f) => f (b g) -> b (Compose f g) Source #

Default implementation of bdistribute based on Generic.

class Functor f => GDistributive (n :: Nat) (f :: Type -> Type) (repbg :: k -> Type) (repbfg :: k -> Type) where Source #

Methods

gdistribute :: forall (x :: k). Proxy n -> f (repbg x) -> repbfg x Source #

Instances

Instances details

Functor f => GDistributive n f (U1 :: k -> Type) (U1 :: k -> Type) Source #
Instance details Defined in Barbies.Generics.Distributive Methods gdistribute :: forall (x :: k). Proxy n -> f (U1 x) -> U1 x Source #
(GDistributive n f l l', GDistributive n f r r') => GDistributive n f (l :: r :: k -> Type) (l' :: r' :: k -> Type) Source #
Instance details Defined in Barbies.Generics.Distributive Methods gdistribute :: forall (x :: k). Proxy n -> f ((l :: r) x) -> (l' :: r') x Source #
GDistributive n f bg bfg => GDistributive n f (M1 i c bg :: k -> Type) (M1 i c bfg :: k -> Type) Source #
Instance details Defined in Barbies.Generics.Distributive Methods gdistribute :: forall (x :: k). Proxy n -> f (M1 i c bg x) -> M1 i c bfg x Source #

type CanDeriveDistributiveB (b :: (k1 -> Type) -> Type) (f :: Type -> Type) (g :: k1 -> Type) = (GenericP 0 (b g), GenericP 0 (b (Compose f g)), GDistributive 0 f (RepP 0 (b g)) (RepP 0 (b (Compose f g)))) Source #

CanDeriveDistributiveB B f g is in practice a predicate about B only. Intuitively, it says the the following holds for any arbitrary f:

There is an instance of Generic (B f).
(B f) has only one constructor, and doesn't contain "naked" fields (that is, not covered by f).
B f can contain fields of type b f as long as there exists a DistributiveB b instance. In particular, recursive usages of B f are allowed.
B f can also contain usages of b f under a Distributive h. For example, one could use a -> (B f) as a field of B f.

type CanDeriveDistributiveT (t :: (Type -> Type) -> i -> Type) (f :: Type -> Type) (g :: Type -> Type) (x :: i) = (GenericP 1 (t g x), GenericP 1 (t (Compose f g) x), GDistributive 1 f (RepP 1 (t g x)) (RepP 1 (t (Compose f g) x))) Source #

CanDeriveDistributiveT T f g x is in practice a predicate about T only. Intuitively, it says the the following holds for any arbitrary f:

There is an instance of Generic (B f x).
(B f x) has only one constructor, and doesn't contain "naked" fields (that is, not covered by f). In particular, x needs to occur under f.
B f x can contain fields of type b f y as long as there exists a DistributiveT b instance. In particular, recursive usages of B f x are allowed.
B f x can also contain usages of b f y under a Distributive h. For example, one could use a -> (B f x) as a field of B f x.

Applicative

gbpureDefault :: CanDeriveApplicativeB b f f => (forall (a :: k). f a) -> b f Source #

gbprodDefault :: forall {k} b (f :: k -> Type) (g :: k -> Type). CanDeriveApplicativeB b f g => b f -> b g -> b (Product f g) Source #

Default implementation of bprod based on Generic.

class GApplicative (n :: k) (f :: k2 -> Type) (g :: k2 -> Type) (repbf :: k1 -> Type) (repbg :: k1 -> Type) (repbfg :: k1 -> Type) where Source #

Methods

gprod :: forall (x :: k1). Proxy n -> Proxy f -> Proxy g -> repbf x -> repbg x -> repbfg x Source #

gpure :: forall (x :: k1). (f ~ g, repbf ~ repbg) => Proxy n -> Proxy f -> Proxy repbf -> Proxy repbfg -> (forall (a :: k2). f a) -> repbf x Source #

Instances

Instances details

GApplicative (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (U1 :: k3 -> Type) (U1 :: k3 -> Type) (U1 :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Applicative Methods gprod :: forall (x :: k3). Proxy n -> Proxy f -> Proxy g -> U1 x -> U1 x -> U1 x Source # gpure :: forall (x :: k3). (f ~ g, (U1 :: k3 -> Type) ~ (U1 :: k3 -> Type)) => Proxy n -> Proxy f -> Proxy (U1 :: k3 -> Type) -> Proxy (U1 :: k3 -> Type) -> (forall (a :: k2). f a) -> U1 x Source #
Monoid x => GApplicative (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (Rec x x :: k3 -> Type) (Rec x x :: k3 -> Type) (Rec x x :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Applicative Methods gprod :: forall (x0 :: k3). Proxy n -> Proxy f -> Proxy g -> Rec x x x0 -> Rec x x x0 -> Rec x x x0 Source # gpure :: forall (x0 :: k3). (f ~ g, (Rec x x :: k3 -> Type) ~ (Rec x x :: k3 -> Type)) => Proxy n -> Proxy f -> Proxy (Rec x x :: k3 -> Type) -> Proxy (Rec x x :: k3 -> Type) -> (forall (a :: k2). f a) -> Rec x x x0 Source #
(GApplicative n f g lf lg lfg, GApplicative n f g rf rg rfg) => GApplicative (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (lf :: rf :: k3 -> Type) (lg :: rg :: k3 -> Type) (lfg :*: rfg :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Applicative Methods gprod :: forall (x :: k3). Proxy n -> Proxy f -> Proxy g -> (lf :: rf) x -> (lg :: rg) x -> (lfg :: rfg) x Source # gpure :: forall (x :: k3). (f ~ g, (lf :: rf) ~ (lg :: rg)) => Proxy n -> Proxy f -> Proxy (lf :: rf) -> Proxy (lfg :: rfg) -> (forall (a :: k2). f a) -> (lf :: rf) x Source #
GApplicative n f g repf repg repfg => GApplicative (n :: k1) (f :: k2 -> Type) (g :: k2 -> Type) (M1 i c repf :: k3 -> Type) (M1 i c repg :: k3 -> Type) (M1 i c repfg :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Applicative Methods gprod :: forall (x :: k3). Proxy n -> Proxy f -> Proxy g -> M1 i c repf x -> M1 i c repg x -> M1 i c repfg x Source # gpure :: forall (x :: k3). (f ~ g, M1 i c repf ~ M1 i c repg) => Proxy n -> Proxy f -> Proxy (M1 i c repf) -> Proxy (M1 i c repfg) -> (forall (a :: k2). f a) -> M1 i c repf x Source #

type CanDeriveApplicativeB (b :: (k -> Type) -> Type) (f :: k -> Type) (g :: k -> Type) = (GenericP 0 (b f), GenericP 0 (b g), GenericP 0 (b (Product f g)), GApplicative 0 f g (RepP 0 (b f)) (RepP 0 (b g)) (RepP 0 (b (Product f g)))) Source #

CanDeriveApplicativeB B f g is in practice a predicate about B only. Intuitively, it says that the following holds, for any arbitrary f:

There is an instance of Generic (B f).
B has only one constructor (that is, it is not a sum-type).
Every field of B f is either a monoid, or of the form f a, for some type a.

type CanDeriveApplicativeT (t :: (k -> Type) -> k1 -> Type) (f :: k -> Type) (g :: k -> Type) (x :: k1) = (GenericP 1 (t f x), GenericP 1 (t g x), GenericP 1 (t (Product f g) x), GApplicative 1 f g (RepP 1 (t f x)) (RepP 1 (t g x)) (RepP 1 (t (Product f g) x))) Source #

CanDeriveApplicativeT T f g x is in practice a predicate about T only. Intuitively, it says that the following holds, for any arbitrary f:

There is an instance of Generic (T f).
T has only one constructor (that is, it is not a sum-type).
Every field of T f x is either a monoid, or of the form f a, for some type a.

Constraints

gbaddDictsDefault :: forall {k} b (c :: k -> Constraint) (f :: k -> Type). (CanDeriveConstraintsB c b f, AllB c b) => b f -> b (Product (Dict c) f) Source #

Default implementation of baddDicts based on Generic.

class GConstraints (n :: Nat) (c :: k -> Constraint) (f :: k1) (repbx :: Type -> Type) (repbf :: k2 -> Type) (repbdf :: k2 -> Type) where Source #

Methods

gaddDicts :: forall (x :: k2). GAll n c repbx => repbf x -> repbdf x Source #

Instances

Instances details

GConstraints n (c :: k1 -> Constraint) (f :: k2) (U1 :: Type -> Type) (U1 :: k3 -> Type) (U1 :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints Methods gaddDicts :: forall (x :: k3). GAll n c (U1 :: Type -> Type) => U1 x -> U1 x Source #
GConstraints n (c :: k1 -> Constraint) (f :: k2) (V1 :: Type -> Type) (V1 :: k3 -> Type) (V1 :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints Methods gaddDicts :: forall (x :: k3). GAll n c (V1 :: Type -> Type) => V1 x -> V1 x Source #
GConstraints n (c :: k1 -> Constraint) (f :: k2) (Rec a' a :: Type -> Type) (Rec b' b :: k3 -> Type) (Rec b' b :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints Methods gaddDicts :: forall (x :: k3). GAll n c (Rec a' a :: Type -> Type) => Rec b' b x -> Rec b' b x Source #
(GConstraints n c f lx lf ldf, GConstraints n c f rx rf rdf) => GConstraints n (c :: k1 -> Constraint) (f :: k2) (lx :: rx) (lf :: rf :: k3 -> Type) (ldf :*: rdf :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints Methods gaddDicts :: forall (x :: k3). GAll n c (lx :: rx) => (lf :: rf) x -> (ldf :*: rdf) x Source #
(GConstraints n c f lx lf ldf, GConstraints n c f rx rf rdf) => GConstraints n (c :: k1 -> Constraint) (f :: k2) (lx :+: rx) (lf :+: rf :: k3 -> Type) (ldf :+: rdf :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints Methods gaddDicts :: forall (x :: k3). GAll n c (lx :+: rx) => (lf :+: rf) x -> (ldf :+: rdf) x Source #
GConstraints n c f repbx repbf repbdf => GConstraints n (c :: k1 -> Constraint) (f :: k2) (M1 i k4 repbx) (M1 i k4 repbf :: k3 -> Type) (M1 i k4 repbdf :: k3 -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints Methods gaddDicts :: forall (x :: k3). GAll n c (M1 i k4 repbx) => M1 i k4 repbf x -> M1 i k4 repbdf x Source #

type CanDeriveConstraintsB (c :: k -> Constraint) (b :: (k -> Type) -> Type) (f :: k -> Type) = (GenericN (b f), GenericN (b (Product (Dict c) f)), AllB c b ~ GAll 0 c (GAllRepB b), GConstraints 0 c f (GAllRepB b) (RepN (b f)) (RepN (b (Product (Dict c) f)))) Source #

CanDeriveConstraintsB B f g is in practice a predicate about B only. Intuitively, it says that the following holds, for any arbitrary f:

There is an instance of Generic (B f).
B f can contain fields of type b f as long as there exists a ConstraintsB b instance. In particular, recursive usages of B f are allowed.

type CanDeriveConstraintsT (c :: k -> Constraint) (t :: (k -> Type) -> kg -> Type) (f :: k -> Type) (x :: kg) = (GenericN (t f x), GenericN (t (Product (Dict c) f) x), AllT c t ~ GAll 1 c (GAllRepT t), GConstraints 1 c f (GAllRepT t) (RepN (t f x)) (RepN (t (Product (Dict c) f) x))) Source #

CanDeriveConstraintsT T f g x is in practice a predicate about T only. Intuitively, it says that the following holds, for any arbitrary f and x:

There is an instance of Generic (T f x).
T f can contain fields of type t f x as long as there exists a ConstraintsT t instance. In particular, recursive usages of T f x are allowed.

type family GAll (n :: Nat) (c :: k -> Constraint) (repbf :: Type -> Type) Source #

Instances

Instances details

type GAll n (c :: k -> Constraint) (U1 :: Type -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints type GAll n (c :: k -> Constraint) (U1 :: Type -> Type) = ()
type GAll n (c :: k -> Constraint) (V1 :: Type -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints type GAll n (c :: k -> Constraint) (V1 :: Type -> Type) = ()
type GAll n (c :: k -> Constraint) (Rec l r :: Type -> Type) Source #
Instance details Defined in Barbies.Generics.Constraints type GAll n (c :: k -> Constraint) (Rec l r :: Type -> Type)
type GAll n (c :: k -> Constraint) (l :*: r) Source #
Instance details Defined in Barbies.Generics.Constraints type GAll n (c :: k -> Constraint) (l :*: r) = (GAll n c l, GAll n c r)
type GAll n (c :: k -> Constraint) (l :+: r) Source #
Instance details Defined in Barbies.Generics.Constraints type GAll n (c :: k -> Constraint) (l :+: r) = (GAll n c l, GAll n c r)
type GAll n (c :: k1 -> Constraint) (M1 i k2 repbf) Source #
Instance details Defined in Barbies.Generics.Constraints type GAll n (c :: k1 -> Constraint) (M1 i k2 repbf) = GAll n c repbf

type GAllRepB (b :: (k -> Type) -> Type) = TagSelf0 b Source #

The representation used for the generic computation of the AllB c b constraints.

type GAllRepT (t :: (k -> Type) -> kg -> Type) = TagSelf1 t Source #

The representation used for the generic computation of the AllT c t constraints. .

data X (a :: k) Source #

data family Y :: k Source #

data Self p a x Source #

data Other p a x Source #

type family SelfOrOther (b :: k) (b' :: k) :: Type -> Type -> Type -> Type where ... Source #

Equations

SelfOrOther (b :: k) (b :: k) = Self
SelfOrOther (b :: k) (b' :: k) = Other

type TagSelf0 (b :: (k -> Type) -> Type) = TagSelf0' (Indexed b 1) (RepN (b (X :: k -> Type))) Source #

We use the type-families to generically compute AllB c b. Intuitively, if b' f' occurs inside b f, then we should just add AllB b' c to AllB b c. The problem is that if b is a recursive type, and b' is b, then ghc will choke and blow the stack (instead of computing a fixpoint).

So, we would like to behave differently when b = b' and add () instead of AllB b c to break the recursion. Our trick will be to use a type family to inspect Rep (b X), for an arbitrary X, and distinguish recursive usages from non-recursive ones, tagging them with different types, so we can distinguish them in the instances.

type family TagSelf0' (b :: kf -> Type) (repbf :: Type -> Type) :: Type -> Type where ... Source #

Equations

TagSelf0' (b :: kf -> Type) (M1 mt m s) = M1 mt m (TagSelf0' b s)
TagSelf0' (b :: kf -> Type) (l :+: r) = TagSelf0' b l :+: TagSelf0' b r
TagSelf0' (b :: kf -> Type) (l :: r) = TagSelf0' b l :: TagSelf0' b r
TagSelf0' (b :: kf -> Type) (Rec (b' f) (b'' g) :: Type -> Type) = SelfOrOther b b' (b' f) (b'' g)
TagSelf0' (b :: kf -> Type) (Rec x y :: Type -> Type) = Rec x y :: Type -> Type
TagSelf0' (b :: kf -> Type) (U1 :: Type -> Type) = U1 :: Type -> Type
TagSelf0' (b :: kf -> Type) (V1 :: Type -> Type) = V1 :: Type -> Type

type TagSelf1 (b :: (k -> Type) -> kg -> Type) = TagSelf1' (Indexed b 2) (Zip (Rep (Indexed (b (X :: k -> Type)) 1 (Y :: kg))) (Rep (b (X :: k -> Type) (Y :: kg)))) Source #

We use the type-families to generically compute AllT c b. Intuitively, if t' f' x' occurs inside t f x, then we should just add AllT t' c to AllT t c. The problem is that if t is a recursive type, and t' is t, then ghc will choke and blow the stack (instead of computing a fixpoint).

So, we would like to behave differently when t = t' and add () instead of AllT t c to break the recursion. Our trick will be to use a type family to inspect Rep (t X Y), for arbitrary X and Y and distinguish recursive usages from non-recursive ones, tagging them with different types, so we can distinguish them in the instances.

type family TagSelf1' (b :: kf -> kg -> Type) (repbf :: Type -> Type) :: Type -> Type where ... Source #

Equations

TagSelf1' (b :: kf -> kg -> Type) (M1 mt m s) = M1 mt m (TagSelf1' b s)
TagSelf1' (b :: kf -> kg -> Type) (l :+: r) = TagSelf1' b l :+: TagSelf1' b r
TagSelf1' (b :: kf -> kg -> Type) (l :: r) = TagSelf1' b l :: TagSelf1' b r
TagSelf1' (b :: kf -> kg -> Type) (Rec (b' fl fr) (b'' gl gr) :: Type -> Type) = SelfOrOther b b' (b' fl gr) (b'' gl gr)
TagSelf1' (b :: kf -> kg -> Type) (Rec x y :: Type -> Type) = Rec x y :: Type -> Type
TagSelf1' (b :: kf -> kg -> Type) (U1 :: Type -> Type) = U1 :: Type -> Type
TagSelf1' (b :: kf -> kg -> Type) (V1 :: Type -> Type) = V1 :: Type -> Type

Bare values

gbcoverDefault :: CanDeriveBareB b => b Bare Identity -> b Covered Identity Source #

Default implementation of bstrip based on Generic.

gbstripDefault :: CanDeriveBareB b => b Covered Identity -> b Bare Identity Source #

Default implementation of bstrip based on Generic.

class GBare (n :: Nat) (repbi :: k -> Type) (repbb :: k -> Type) where Source #

Methods

gstrip :: forall (x :: k). Proxy n -> repbi x -> repbb x Source #

gcover :: forall (x :: k). Proxy n -> repbb x -> repbi x Source #

Instances

Instances details

GBare n (U1 :: k -> Type) (U1 :: k -> Type) Source #
Instance details Defined in Barbies.Generics.Bare Methods gstrip :: forall (x :: k). Proxy n -> U1 x -> U1 x Source # gcover :: forall (x :: k). Proxy n -> U1 x -> U1 x Source #
GBare n (V1 :: k -> Type) (V1 :: k -> Type) Source #
Instance details Defined in Barbies.Generics.Bare Methods gstrip :: forall (x :: k). Proxy n -> V1 x -> V1 x Source # gcover :: forall (x :: k). Proxy n -> V1 x -> V1 x Source #
repbi ~ repbb => GBare n (Rec repbi repbi :: k -> Type) (Rec repbb repbb :: k -> Type) Source #
Instance details Defined in Barbies.Generics.Bare Methods gstrip :: forall (x :: k). Proxy n -> Rec repbi repbi x -> Rec repbb repbb x Source # gcover :: forall (x :: k). Proxy n -> Rec repbb repbb x -> Rec repbi repbi x Source #
(GBare n l l', GBare n r r') => GBare n (l :: r :: k -> Type) (l' :: r' :: k -> Type) Source #
Instance details Defined in Barbies.Generics.Bare Methods gstrip :: forall (x :: k). Proxy n -> (l :: r) x -> (l' :: r') x Source # gcover :: forall (x :: k). Proxy n -> (l' :: r') x -> (l :: r) x Source #
(GBare n l l', GBare n r r') => GBare n (l :+: r :: k -> Type) (l' :+: r' :: k -> Type) Source #
Instance details Defined in Barbies.Generics.Bare Methods gstrip :: forall (x :: k). Proxy n -> (l :+: r) x -> (l' :+: r') x Source # gcover :: forall (x :: k). Proxy n -> (l' :+: r') x -> (l :+: r) x Source #
GBare n repbi repbb => GBare n (M1 i k2 repbi :: k1 -> Type) (M1 i k2 repbb :: k1 -> Type) Source #
Instance details Defined in Barbies.Generics.Bare Methods gstrip :: forall (x :: k1). Proxy n -> M1 i k2 repbi x -> M1 i k2 repbb x Source # gcover :: forall (x :: k1). Proxy n -> M1 i k2 repbb x -> M1 i k2 repbi x Source #

type CanDeriveBareB (b :: Type -> (Type -> Type) -> Type) = (GenericP 0 (b Bare Identity), GenericP 0 (b Covered Identity), GBare 0 (RepP 0 (b Covered Identity)) (RepP 0 (b Bare Identity))) Source #

All types that admit a generic FunctorB instance, and have all their occurrences of f under a Wear admit a generic BareB instance.

Generic derivation support

class Generic a where #

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

Associated Types

type Rep a :: Type -> Type #

Generic representation type

Methods

from :: a -> Rep a x #

Convert from the datatype to its representation

to :: Rep a x -> a #

Convert from the representation to the datatype

Instances

Instances details

Generic All

Instance details

Defined in Data.Semigroup.Internal

Associated Types

type Rep All	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep All = D1 ('MetaData "All" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "All" 'PrefixI 'True) (S1 ('MetaSel ('Just "getAll") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))

Methods

from :: All -> Rep All x #

to :: Rep All x -> All #

Generic Any

Instance details

Defined in Data.Semigroup.Internal

Associated Types

type Rep Any	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep Any = D1 ('MetaData "Any" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Any" 'PrefixI 'True) (S1 ('MetaSel ('Just "getAny") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))

Methods

from :: Any -> Rep Any x #

to :: Rep Any x -> Any #

Generic Version

Instance details

Defined in Data.Version

Associated Types

type Rep Version	Since: base-4.9.0.0
Instance details Defined in Data.Version type Rep Version = D1 ('MetaData "Version" "Data.Version" "base" 'False) (C1 ('MetaCons "Version" 'PrefixI 'True) (S1 ('MetaSel ('Just "versionBranch") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int]) :*: S1 ('MetaSel ('Just "versionTags") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [String])))

Methods

from :: Version -> Rep Version x #

to :: Rep Version x -> Version #

Generic Void

Instance details

(KnownSymbol n, SingI f, SingI r) => Constructor ('MetaCons n f r :: Meta)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods conName :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> [Char] # conFixity :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> Fixity # conIsRecord :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> Bool #

MetaData Symbol Symbol Symbol Bool
MetaCons Symbol FixityI Bool
MetaSel (Maybe Symbol) SourceUnpackedness SourceStrictness DecidedStrictness

(Generic1 f, Eq1 (Rep1 f)) => Eq1 (Generically1 f)	Since: base-4.17.0.0
Instance details 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
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Generically1 f a -> Generically1 f b -> Ordering #
(Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f)	Since: base-4.17.0.0
Instance details 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
Instance details 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
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Generically1 f a -> Generically1 f b # (<$) :: a -> Generically1 f b -> Generically1 f a #
(Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a)	Since: base-4.18.0.0
Instance details 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
Instance details 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 #

(Generic a, Monoid (Rep a ())) => Monoid (Generically a)	Since: base-4.17.0.0
Instance details 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
Instance details 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 #

Indexed (t a :: k2) i = Indexed t (i + 1) (Param i a)
Indexed (t :: k) _1 = t

FilterIndex n (t (Param n a) :: k2) = FilterIndex n t (Param n a)
FilterIndex n (t (Param _1 a) :: k2) = FilterIndex n t a
FilterIndex _1 (t :: k) = t

Zip (M1 mt m s) (M1 mt m t) = M1 mt m (Zip s t)
Zip (l :+: r) (l' :+: r') = Zip l l' :+: Zip r r'
Zip (l :: r) (l' :: r') = Zip l l' :*: Zip r r'
Zip (Rec0 p) (Rec0 a) = Rec p a :: Type -> Type
Zip (U1 :: Type -> Type) (U1 :: Type -> Type) = U1 :: Type -> Type
Zip (V1 :: Type -> Type) (V1 :: Type -> Type) = V1 :: Type -> Type

type RepN a Source #
Instance details Defined in Data.Generics.GenericN type RepN a = Zip (Rep (Indexed a 0)) (Rep a)

type RepP n a Source #
Instance details Defined in Data.Generics.GenericN type RepP n a = Zip (Rep (FilterIndex n (Indexed a 0))) (Rep a)

Key	Shortcut
s	Open this search box
esc	Close this search box
↓,ctrl + j	Move down in search results
↑,ctrl + k	Move up in search results
↵	Go to active search result