-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Classes for working with types that can change clothes.
--   
--   Types that are parametric on a functor are like Barbies that have an
--   outfit for each role. This package provides the basic abstractions to
--   work with them comfortably.
@package barbies
@version 0.1.3.0

module Data.Barbie.Internal.Functor

-- | Barbie-types that can be mapped over. Instances of <a>FunctorB</a>
--   should satisfy the following laws:
--   
--   <pre>
--   <a>bmap</a> <a>id</a> = <a>id</a>
--   <a>bmap</a> f . <a>bmap</a> g = <a>bmap</a> (f . g)
--   </pre>
--   
--   There is a default <a>bmap</a> implementation for <a>Generic</a>
--   types, so instances can derived automatically.
class FunctorB b
bmap :: FunctorB b => (forall a. f a -> g a) -> b f -> b g
bmap :: (FunctorB b, CanDeriveGenericInstance b) => (forall a. f a -> g a) -> b f -> b g
class GFunctorB b

-- | Default implementation of <a>bmap</a> based on <a>Generic</a>.
gbmapDefault :: CanDeriveGenericInstance b => (forall a. f a -> g a) -> b f -> b g

-- | Intuivively, the requirements to have <tt><a>FunctorB</a> B</tt>
--   derived are:
--   
--   <ul>
--   <li>There is an instance of <tt><a>Generic</a> (B f)</tt> for every
--   <tt>f</tt></li>
--   <li>If <tt>f</tt> is used as argument to some type in the definition
--   of <tt>B</tt>, it is only on a Barbie-type with a <a>FunctorB</a>
--   instance.</li>
--   <li>Recursive usages of <tt>B f</tt> are allowed to appear as argument
--   to a <a>Functor</a> (e.g. @<a>Maybe</a> (B f)')</li>
--   </ul>
type CanDeriveGenericInstance b = (Generic (b (Target F)), Generic (b (Target G)), GFunctorB (Rep (b (Target F))), Rep (b (Target G)) ~ Repl (Target F) (Target G) (Rep (b (Target F))))
instance Data.Barbie.Internal.Functor.FunctorB b => Data.Barbie.Internal.Functor.GFunctorB (GHC.Generics.K1 GHC.Generics.R (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F)))
instance (GHC.Base.Functor h, Data.Barbie.Internal.Functor.FunctorB b, Data.Barbie.Internal.Generics.Repl (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.G) (GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F)))) ~ GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.G)))) => Data.Barbie.Internal.Functor.GFunctorB (GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F))))
instance Data.Barbie.Internal.Functor.GFunctorB x => Data.Barbie.Internal.Functor.GFunctorB (GHC.Generics.M1 i c x)
instance Data.Barbie.Internal.Functor.GFunctorB GHC.Generics.V1
instance Data.Barbie.Internal.Functor.GFunctorB GHC.Generics.U1
instance (Data.Barbie.Internal.Functor.GFunctorB l, Data.Barbie.Internal.Functor.GFunctorB r) => Data.Barbie.Internal.Functor.GFunctorB (l GHC.Generics.:*: r)
instance (Data.Barbie.Internal.Functor.GFunctorB l, Data.Barbie.Internal.Functor.GFunctorB r) => Data.Barbie.Internal.Functor.GFunctorB (l GHC.Generics.:+: r)
instance Data.Barbie.Internal.Functor.GFunctorB (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.Target (Data.Barbie.Internal.Generics.W Data.Barbie.Internal.Tags.F) a))
instance Data.Barbie.Internal.Functor.GFunctorB (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F a))
instance (GHC.Generics.K1 i c ~ Data.Barbie.Internal.Generics.Repl (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.G) (GHC.Generics.K1 i c)) => Data.Barbie.Internal.Functor.GFunctorB (GHC.Generics.K1 i c)


module Data.Barbie.Internal.Traversable

-- | Barbie-types that can be traversed from left to right. Instances
--   should satisfy the following laws:
--   
--   <pre>
--    t . <a>btraverse</a> f = <a>btraverse</a> (t . f)  -- naturality
--   <a>btraverse</a> <a>Identity</a> = <a>Identity</a>         -- identity
--   <a>btraverse</a> (<a>Compose</a> . <a>fmap</a> g . f) = <a>Compose</a> . <a>fmap</a> (<a>btraverse</a> g) . <a>btraverse</a> f -- composition
--   </pre>
--   
--   There is a default <a>btraverse</a> implementation for <a>Generic</a>
--   types, so instances can derived automatically.
class FunctorB b => TraversableB b
btraverse :: (TraversableB b, Applicative t) => (forall a. f a -> t (g a)) -> b f -> t (b g)
btraverse :: (TraversableB b, Applicative t, CanDeriveGenericInstance b) => (forall a. f a -> t (g a)) -> b f -> t (b g)

-- | Evaluate each action in the structure from left to right, and collect
--   the results.
bsequence :: (Applicative f, TraversableB b) => b (Compose f g) -> f (b g)

-- | Intuivively, the requirements to have <tt><a>TraversableB</a> B</tt>
--   derived are:
--   
--   <ul>
--   <li>There is an instance of <tt><a>Generic</a> (B f)</tt> for every
--   <tt>f</tt></li>
--   <li>If <tt>f</tt> is used as argument to some type in the definition
--   of <tt>B</tt>, it is only on a Barbie-type with a <a>TraversableB</a>
--   instance.</li>
--   <li>Recursive usages of <tt>B f</tt> are allowed to appear as argument
--   to a <a>Traversable</a> (e.g. @<a>Maybe</a> (B f)')</li>
--   </ul>
type CanDeriveGenericInstance b = (Generic (b (Target F)), Generic (b (Target G)), GTraversableB (Rep (b (Target F))), Rep (b (Target G)) ~ Repl (Target F) (Target G) (Rep (b (Target F))))
class GTraversableB b

-- | Default implementation of <a>btraverse</a> based on <a>Generic</a>.
gbtraverseDefault :: (Applicative t, CanDeriveGenericInstance b) => (forall a. f a -> t (g a)) -> b f -> t (b g)
instance Data.Barbie.Internal.Traversable.TraversableB b => Data.Barbie.Internal.Traversable.GTraversableB (GHC.Generics.K1 GHC.Generics.R (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F)))
instance (Data.Traversable.Traversable h, Data.Barbie.Internal.Traversable.TraversableB b, Data.Barbie.Internal.Generics.Repl (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.G) (GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F)))) ~ GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.G)))) => Data.Barbie.Internal.Traversable.GTraversableB (GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F))))
instance Data.Barbie.Internal.Traversable.GTraversableB x => Data.Barbie.Internal.Traversable.GTraversableB (GHC.Generics.M1 i c x)
instance Data.Barbie.Internal.Traversable.GTraversableB GHC.Generics.V1
instance Data.Barbie.Internal.Traversable.GTraversableB GHC.Generics.U1
instance (Data.Barbie.Internal.Traversable.GTraversableB l, Data.Barbie.Internal.Traversable.GTraversableB r) => Data.Barbie.Internal.Traversable.GTraversableB (l GHC.Generics.:*: r)
instance (Data.Barbie.Internal.Traversable.GTraversableB l, Data.Barbie.Internal.Traversable.GTraversableB r) => Data.Barbie.Internal.Traversable.GTraversableB (l GHC.Generics.:+: r)
instance Data.Barbie.Internal.Traversable.GTraversableB (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.Target (Data.Barbie.Internal.Generics.W Data.Barbie.Internal.Tags.F) a))
instance Data.Barbie.Internal.Traversable.GTraversableB (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F a))
instance (GHC.Generics.K1 i c ~ Data.Barbie.Internal.Generics.Repl (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.G) (GHC.Generics.K1 i c)) => Data.Barbie.Internal.Traversable.GTraversableB (GHC.Generics.K1 i c)

module Data.Barbie.Internal.Constraints

-- | Instances of this class provide means to talk about constraints, both
--   at compile-time, using <a>ConstraintsOf</a> and at run-time, in the
--   form of class instance dictionaries, via <a>adjProof</a>.
--   
--   A manual definition would look like this:
--   
--   <pre>
--   data T f = A (f <a>Int</a>) (f <a>String</a>) | B (f <a>Bool</a>) (f <a>Int</a>)
--   
--   instance <a>ConstraintsB</a> T where
--     type <a>ConstraintsOf</a> c f T
--       = (c (f <a>Int</a>), c (f <a>String</a>), c (f <a>Bool</a>))
--   
--     adjProof t = case t of
--       A x y -&gt; A (<a>Pair</a> (<a>packDict</a> x) (<a>packDict</a> y))
--       B z w -&gt; B (<a>Pair</a> (<a>packDict</a> z) (<a>packDict</a> w))
--   </pre>
--   
--   There is a default implementation of <a>ConstraintsOf</a> for
--   <a>Generic</a> types, so in practice one will simply do:
--   
--   <pre>
--   derive instance <a>Generic</a> T
--   instance <a>ConstraintsB</a> T
--   </pre>
class FunctorB b => ConstraintsB b where {
    type family ConstraintsOf (c :: * -> Constraint) (f :: *
                                                           -> *) b :: Constraint;
    type ConstraintsOf c f b =
        GConstraintsOf c f (RecRep (b (Target F)));
}

-- | Adjoint a proof-of-instance to a barbie-type.
adjProof :: forall c f. (ConstraintsB b, ConstraintsOf c f b) => b f -> b (Product (DictOf c f) f)

-- | Adjoint a proof-of-instance to a barbie-type.
adjProof :: forall c f. (ConstraintsB b, CanDeriveGenericInstance b, ConstraintsOfMatchesGenericDeriv c f b, ConstraintsOf c f b) => b f -> b (Product (DictOf c f) f)

-- | Intuivively, the requirements to have <tt><a>ConstraintsB</a> B</tt>
--   derived are:
--   
--   <ul>
--   <li>There is an instance of <tt><a>Generic</a> (B f)</tt> for every
--   <tt>f</tt></li>
--   <li>If <tt>f</tt> is used as argument to some type in the definition
--   of <tt>B</tt>, it is only on a Barbie-type with a <a>ConstraintsB</a>
--   instance.</li>
--   </ul>
type CanDeriveGenericInstance b = (Generic (b (Target F)), Generic (b (Target PxF)), GAdjProof (ClassifyBarbie b) b (RecRep (b (Target F))), Rep (b (Target PxF)) ~ Repl' (Target F) (Target PxF) (RecRep (b (Target F))))
type ConstraintsOfMatchesGenericDeriv c f b = (ConstraintsOf c f b ~ GConstraintsOf c f (RecRep (b (Target F))), ConstraintsOf c f b ~ ConstraintByType (ClassifyBarbie b) c f (RecRep (b (Target F))))
type GConstraintsOf c f r = ConstraintByType (GClassifyBarbie r) c f r
class GAdjProof (bt :: BarbieType) b rep

-- | Default implementation of <a>adjProof</a> based on <a>Generic</a>.
gadjProofDefault :: forall b c f. (CanDeriveGenericInstance b, ConstraintsOfMatchesGenericDeriv c f b, ConstraintsOf c f b) => b f -> b (Product (DictOf c f) f)
instance Data.Barbie.Internal.Constraints.GAdjProof bt b x => Data.Barbie.Internal.Constraints.GAdjProof bt b (GHC.Generics.M1 _i _c x)
instance Data.Barbie.Internal.Constraints.GAdjProof bt b GHC.Generics.V1
instance Data.Barbie.Internal.Constraints.GAdjProof bt b GHC.Generics.U1
instance (Data.Barbie.Internal.Constraints.GAdjProof bt b l, Data.Barbie.Internal.Constraints.GAdjProof bt b r) => Data.Barbie.Internal.Constraints.GAdjProof bt b (l GHC.Generics.:*: r)
instance (Data.Barbie.Internal.Constraints.GAdjProof bt b l, Data.Barbie.Internal.Constraints.GAdjProof bt b r) => Data.Barbie.Internal.Constraints.GAdjProof bt b (l GHC.Generics.:+: r)
instance Data.Barbie.Internal.Constraints.GAdjProof 'Data.Barbie.Internal.Classification.WearBarbie b (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.NonRec (Data.Barbie.Internal.Generics.Target (Data.Barbie.Internal.Generics.W Data.Barbie.Internal.Tags.F) a)))
instance Data.Barbie.Internal.Constraints.GAdjProof 'Data.Barbie.Internal.Classification.NonWearBarbie b (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.NonRec (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F a)))
instance (Data.Barbie.Internal.Constraints.CanDeriveGenericInstance b, bt ~ Data.Barbie.Internal.Classification.ClassifyBarbie b) => Data.Barbie.Internal.Constraints.GAdjProof bt b (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.RecUsage (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F))))
instance Data.Barbie.Internal.Constraints.ConstraintsB b' => Data.Barbie.Internal.Constraints.GAdjProof bt b (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.NonRec (b' (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F))))
instance (GHC.Generics.K1 i a ~ Data.Barbie.Internal.Generics.Repl' (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.PxF) (GHC.Generics.K1 i (Data.Barbie.Internal.Generics.NonRec a))) => Data.Barbie.Internal.Constraints.GAdjProof bt b (GHC.Generics.K1 i (Data.Barbie.Internal.Generics.NonRec a))

module Data.Barbie.Internal.Bare

-- | The <a>Wear</a> type-function allows one to define a Barbie-type as
--   
--   <pre>
--   data B f
--     = B { f1 :: <a>Wear</a> f <a>Int</a>
--         , f2 :: <a>Wear</a> f <a>Bool</a>
--         }
--   </pre>
--   
--   This way, one can use <a>Bare</a> as a phantom that denotes no functor
--   around the typw:
--   
--   <pre>
--   B { f1 :: 5, f2 = <a>True</a> } :: B <a>Bare</a>
--   </pre>

-- | <a>Bare</a> is the only type such that <tt><a>Wear</a> <a>Bare</a> a ~
--   a'</tt>.
data Bare a

-- | Class of Barbie-types defined using <a>Wear</a> and can therefore have
--   <a>Bare</a> versions. Must satisfy:
--   
--   <pre>
--   <a>bcover</a> . <a>bstrip</a> = <a>id</a>
--   <a>bstrip</a> . <a>bcover</a> = <a>id</a>
--   </pre>
class FunctorB b => BareB b
bstrip :: BareB b => b Identity -> b Bare
bcover :: BareB b => b Bare -> b Identity
bstrip :: (BareB b, CanDeriveGenericInstance b) => b Identity -> b Bare
bcover :: (BareB b, CanDeriveGenericInstance' b) => b Bare -> b Identity

-- | Generalization of <a>bstrip</a> to arbitrary functors
bstripFrom :: BareB b => (forall a. f a -> a) -> b f -> b Bare

-- | Generalization of <a>bcover</a> to arbitrary functors
bcoverWith :: BareB b => (forall a. a -> f a) -> b Bare -> b f
class Gbstrip rep
gbstrip :: Gbstrip rep => rep x -> Repl (Target I) (Target B) rep x

-- | Default implementatio of <a>bstrip</a> based on <a>Generic</a>.
gbstripDefault :: CanDeriveGenericInstance b => b Identity -> b Bare

-- | Default implementatio of <a>bstrip</a> based on <a>Generic</a>.
gbcoverDefault :: CanDeriveGenericInstance' b => b Bare -> b Identity

-- | All types that admit a generic FunctorB' instance, and have all their
--   occurrences of <tt>f</tt> under a <a>Wear</a> admit a generic
--   <a>BareB</a> instance.
type CanDeriveGenericInstance b = (Generic (b (Target I)), Generic (b (Target B)), Gbstrip (Rep (b (Target I))), Rep (b (Target B)) ~ Repl (Target I) (Target B) (Rep (b (Target I))))
type CanDeriveGenericInstance' b = (Generic (b (Target I)), Generic (b (Target B)), Gbcover (Rep (b (Target B))), Rep (b (Target I)) ~ Repl (Target B) (Target I) (Rep (b (Target B))))
instance Data.Barbie.Internal.Bare.BareB b => Data.Barbie.Internal.Bare.Gbstrip (GHC.Generics.K1 GHC.Generics.R (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.I)))
instance (GHC.Base.Functor h, Data.Barbie.Internal.Bare.BareB b, Data.Barbie.Internal.Generics.Repl (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.I) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.B) (GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.I)))) ~ GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.B)))) => Data.Barbie.Internal.Bare.Gbstrip (GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.I))))
instance Data.Barbie.Internal.Bare.BareB b => Data.Barbie.Internal.Bare.Gbcover (GHC.Generics.K1 GHC.Generics.R (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.B)))
instance (GHC.Base.Functor h, Data.Barbie.Internal.Bare.BareB b, Data.Barbie.Internal.Generics.Repl (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.B) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.I) (GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.B)))) ~ GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.I)))) => Data.Barbie.Internal.Bare.Gbcover (GHC.Generics.K1 GHC.Generics.R (h (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.B))))
instance Data.Barbie.Internal.Bare.Gbcover x => Data.Barbie.Internal.Bare.Gbcover (GHC.Generics.M1 i c x)
instance Data.Barbie.Internal.Bare.Gbcover GHC.Generics.V1
instance Data.Barbie.Internal.Bare.Gbcover GHC.Generics.U1
instance (Data.Barbie.Internal.Bare.Gbcover l, Data.Barbie.Internal.Bare.Gbcover r) => Data.Barbie.Internal.Bare.Gbcover (l GHC.Generics.:*: r)
instance (Data.Barbie.Internal.Bare.Gbcover l, Data.Barbie.Internal.Bare.Gbcover r) => Data.Barbie.Internal.Bare.Gbcover (l GHC.Generics.:+: r)
instance Data.Barbie.Internal.Bare.Gbcover (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.Target (Data.Barbie.Internal.Generics.W Data.Barbie.Internal.Tags.B) a))
instance (GHC.Generics.K1 i c ~ Data.Barbie.Internal.Generics.Repl (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.B) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.I) (GHC.Generics.K1 i c)) => Data.Barbie.Internal.Bare.Gbcover (GHC.Generics.K1 i c)
instance Data.Barbie.Internal.Bare.Gbstrip x => Data.Barbie.Internal.Bare.Gbstrip (GHC.Generics.M1 i c x)
instance Data.Barbie.Internal.Bare.Gbstrip GHC.Generics.V1
instance Data.Barbie.Internal.Bare.Gbstrip GHC.Generics.U1
instance (Data.Barbie.Internal.Bare.Gbstrip l, Data.Barbie.Internal.Bare.Gbstrip r) => Data.Barbie.Internal.Bare.Gbstrip (l GHC.Generics.:*: r)
instance (Data.Barbie.Internal.Bare.Gbstrip l, Data.Barbie.Internal.Bare.Gbstrip r) => Data.Barbie.Internal.Bare.Gbstrip (l GHC.Generics.:+: r)
instance Data.Barbie.Internal.Bare.Gbstrip (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.Target (Data.Barbie.Internal.Generics.W Data.Barbie.Internal.Tags.I) a))
instance (GHC.Generics.K1 i c ~ Data.Barbie.Internal.Generics.Repl (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.I) (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.B) (GHC.Generics.K1 i c)) => Data.Barbie.Internal.Bare.Gbstrip (GHC.Generics.K1 i c)


-- | Generalize the standard two-functor <a>Product</a> to the product of
--   <tt>n</tt>-functors. Intuitively, this means:
--   
--   <pre>
--   <a>Product</a> f g a ~~ (f a, g a)
--   
--   <a>Prod</a> '[]        a ~~  Const () a
--   <a>Prod</a> '[f]       a ~~ (f a)
--   <a>Prod</a> '[f, g]    a ~~ (f a, g a)
--   <a>Prod</a> '[f, g, h] a ~~ (f a, g a, h a)
--       ⋮
--   </pre>
module Data.Functor.Prod

-- | Product of n functors.
data Prod :: [* -> *] -> * -> *
[Unit] :: Prod '[] a
[Cons] :: (f a) -> Prod fs a -> Prod (f : fs) a

-- | The unit of the product.
zeroTuple :: Prod '[] a

-- | Lift a functor to a 1-tuple.
oneTuple :: f a -> Prod '[f] a

-- | Conversion from a standard <a>Product</a>
fromProduct :: Product f g a -> Prod '[f, g] a

-- | Conversion to a standard <a>Product</a>
toProduct :: Prod '[f, g] a -> Product f g a

-- | Flat product of products.
prod :: Prod ls a -> Prod rs a -> Prod (ls ++ rs) a

-- | Like <a>uncurry</a> but using <a>Prod</a> instead of pairs. Can be
--   thought of as a family of functions:
--   
--   <pre>
--   <a>uncurryn</a> :: r a -&gt; <a>Prod</a> '[] a
--   <a>uncurryn</a> :: (f a -&gt; r a) -&gt; <a>Prod</a> '[f] a
--   <a>uncurryn</a> :: (f a -&gt; g a -&gt; r a) -&gt; <a>Prod</a> '[f, g] a
--   <a>uncurryn</a> :: (f a -&gt; g a -&gt; h a -&gt; r a) -&gt; <a>Prod</a> '[f, g, h] a
--           ⋮
--   </pre>
uncurryn :: Curried (Prod fs a -> r a) -> Prod fs a -> r a

-- | Type-level, poly-kinded, list-concatenation.

-- | <tt><a>Prod</a> '[f, g, h] a -&gt; r</tt> is the type of the uncurried
--   form of a function <tt>f a -&gt; g a -&gt; h a -&gt; r</tt>.
--   <a>Curried</a> moves from the former to the later. E.g.
--   
--   <pre>
--   <a>Curried</a> (<a>Prod</a> '[]  a    -&gt; r) = r a
--   <a>Curried</a> (<a>Prod</a> '[f] a    -&gt; r) = f a -&gt; r a
--   <a>Curried</a> (<a>Prod</a> '[f, g] a -&gt; r) = f a -&gt; g a -&gt; r a
--   </pre>
instance GHC.Base.Functor (Data.Functor.Prod.Prod '[])
instance (GHC.Base.Functor f, GHC.Base.Functor (Data.Functor.Prod.Prod fs)) => GHC.Base.Functor (Data.Functor.Prod.Prod (f : fs))
instance GHC.Base.Applicative (Data.Functor.Prod.Prod '[])
instance (GHC.Base.Applicative f, GHC.Base.Applicative (Data.Functor.Prod.Prod fs)) => GHC.Base.Applicative (Data.Functor.Prod.Prod (f : fs))
instance GHC.Base.Alternative (Data.Functor.Prod.Prod '[])
instance (GHC.Base.Alternative f, GHC.Base.Alternative (Data.Functor.Prod.Prod fs)) => GHC.Base.Alternative (Data.Functor.Prod.Prod (f : fs))
instance Data.Foldable.Foldable (Data.Functor.Prod.Prod '[])
instance (Data.Foldable.Foldable f, Data.Foldable.Foldable (Data.Functor.Prod.Prod fs)) => Data.Foldable.Foldable (Data.Functor.Prod.Prod (f : fs))
instance Data.Traversable.Traversable (Data.Functor.Prod.Prod '[])
instance (Data.Traversable.Traversable f, Data.Traversable.Traversable (Data.Functor.Prod.Prod fs)) => Data.Traversable.Traversable (Data.Functor.Prod.Prod (f : fs))
instance Data.Functor.Classes.Eq1 (Data.Functor.Prod.Prod '[])
instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 (Data.Functor.Prod.Prod fs)) => Data.Functor.Classes.Eq1 (Data.Functor.Prod.Prod (f : fs))
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Functor.Prod.Prod '[] a)
instance (Data.Functor.Classes.Eq1 f, GHC.Classes.Eq a, Data.Functor.Classes.Eq1 (Data.Functor.Prod.Prod fs)) => GHC.Classes.Eq (Data.Functor.Prod.Prod (f : fs) a)
instance Data.Functor.Classes.Ord1 (Data.Functor.Prod.Prod '[])
instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 (Data.Functor.Prod.Prod fs)) => Data.Functor.Classes.Ord1 (Data.Functor.Prod.Prod (f : fs))
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Functor.Prod.Prod '[] a)
instance (Data.Functor.Classes.Ord1 f, GHC.Classes.Ord a, Data.Functor.Classes.Ord1 (Data.Functor.Prod.Prod fs)) => GHC.Classes.Ord (Data.Functor.Prod.Prod (f : fs) a)
instance Data.Functor.Classes.Show1 (Data.Functor.Prod.Prod '[])
instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 (Data.Functor.Prod.Prod fs)) => Data.Functor.Classes.Show1 (Data.Functor.Prod.Prod (f : fs))
instance GHC.Show.Show a => GHC.Show.Show (Data.Functor.Prod.Prod '[] a)
instance (Data.Functor.Classes.Show1 f, GHC.Show.Show a, Data.Functor.Classes.Show1 (Data.Functor.Prod.Prod fs)) => GHC.Show.Show (Data.Functor.Prod.Prod (f : fs) a)

module Data.Barbie.Internal.Product

-- | Barbie-types that can form products, subject to the laws:
--   
--   <pre>
--   <a>bmap</a> (<a>Pair</a> a _) . <a>uncurry</a> . <a>bprod</a> = <a>fst</a>
--   <a>bmap</a> (<a>Pair</a> _ b) . <a>uncurry</a> . <a>bprod</a> = <a>snd</a>
--   </pre>
--   
--   Notice that because of the laws, having an internal product structure
--   is not enough to have a lawful instance. E.g.
--   
--   <pre>
--   data Ok  f = Ok {o1 :: f <a>String</a>, o2 :: f <a>Int</a>}        -- has an instance
--   data Bad f = Bad{b1 :: f <a>String</a>, hiddenFromArg: <a>Int</a>} -- no lawful instance
--   </pre>
--   
--   Intuitively, the laws for this class require that <tt>b</tt> hides no
--   structure from its argument <tt>f</tt>. Because of this, any <tt>x ::
--   forall a . f a</tt> determines a unique value of <tt>b f</tt>,
--   witnessed by the <a>buniq</a> method. Formally:
--   
--   <pre>
--   <a>const</a> (<a>buniq</a> x) = <a>bmap</a> (<a>const</a> x)
--   </pre>
--   
--   There is a default implementation of <a>bprod</a> and <a>buniq</a> for
--   <a>Generic</a> types, so instances can derived automatically.
class FunctorB b => ProductB b
bprod :: ProductB b => b f -> b g -> b (Product f g)
buniq :: ProductB b => (forall a. f a) -> b f
bprod :: (ProductB b, CanDeriveGenericInstance b) => b f -> b g -> b (Product f g)
buniq :: (ProductB b, CanDeriveGenericInstance' b) => (forall a. f a) -> b f

-- | An alias of <a>bprod</a>, since this is like a <a>zip</a> for
--   Barbie-types.
bzip :: ProductB b => b f -> b g -> b (Product f g)

-- | An equivalent of <a>unzip</a> for Barbie-types.
bunzip :: ProductB b => b (Product f g) -> (b f, b g)

-- | An equivalent of <a>zipWith</a> for Barbie-types.
bzipWith :: ProductB b => (forall a. f a -> g a -> h a) -> b f -> b g -> b h

-- | An equivalent of <a>zipWith3</a> for Barbie-types.
bzipWith3 :: ProductB b => (forall a. f a -> g a -> h a -> i a) -> b f -> b g -> b h -> b i

-- | An equivalent of <a>zipWith4</a> for Barbie-types.
bzipWith4 :: ProductB b => (forall a. f a -> g a -> h a -> i a -> j a) -> b f -> b g -> b h -> b i -> b j

-- | Like <a>bprod</a>, but returns a binary <a>Prod</a>, instead of
--   <a>Product</a>, which composes better.
--   
--   See <a>/*/</a> for usage.
(/*/) :: ProductB b => b f -> b g -> b (Prod '[f, g])
infixr 4 /*/

-- | Similar to <a>/*/</a> but one of the sides is already a 'Prod fs'.
--   
--   Note that <a>/*</a>, <a>/*/</a> and <a>uncurryn</a> are meant to be
--   used together: <a>/*</a> and <a>/*/</a> combine <tt>b f1, b f2...b
--   fn</tt> into a single product that can then be consumed by using
--   <a>uncurryn</a> on an n-ary function. E.g.
--   
--   <pre>
--   f :: f a -&gt; g a -&gt; h a -&gt; i a
--   
--   <a>bmap</a> (<a>uncurryn</a> f) (bf <a>/*</a> bg <a>/*/</a> bh)
--   </pre>
(/*) :: ProductB b => b f -> b (Prod fs) -> b (Prod (f : fs))
infixr 4 /*

-- | The requirements to to derive <tt><a>ProductB</a> (B f)</tt> are more
--   strict than those for <a>FunctorB</a> or <tt>TraversableB</tt>.
--   Intuitively, we need:
--   
--   <ul>
--   <li>There is an instance of <tt><a>Generic</a> (B f)</tt> for every
--   <tt>f</tt></li>
--   <li><tt>B</tt> has only one constructor.</li>
--   <li>Every field of <tt>B</tt>' constructor is of the form 'f t'. That
--   is, <tt>B</tt> has no hidden structure.</li>
--   </ul>
type CanDeriveGenericInstance b = (Generic (b (Target F)), Generic (b (Target G)), Generic (b (Target FxG)), GProductB (Rep (b (Target F))), Rep (b (Target G)) ~ Repl (Target F) (Target G) (Rep (b (Target F))), Rep (b (Target FxG)) ~ Repl (Target F) (Target FxG) (Rep (b (Target F))))
type CanDeriveGenericInstance' b = (Generic (b (Target F)), GProductB (Rep (b (Target F))))
class GProductB b

-- | Default implementation of <a>bprod</a> based on <a>Generic</a>.
gbprodDefault :: CanDeriveGenericInstance b => b f -> b g -> b (Product f g)
gbuniqDefault :: CanDeriveGenericInstance' b => (forall a. f a) -> b f
instance Data.Barbie.Internal.Product.ProductB b => Data.Barbie.Internal.Product.GProductB (GHC.Generics.K1 GHC.Generics.R (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F)))
instance Data.Barbie.Internal.Product.GProductB x => Data.Barbie.Internal.Product.GProductB (GHC.Generics.M1 i c x)
instance Data.Barbie.Internal.Product.GProductB GHC.Generics.U1
instance (Data.Barbie.Internal.Product.GProductB l, Data.Barbie.Internal.Product.GProductB r) => Data.Barbie.Internal.Product.GProductB (l GHC.Generics.:*: r)
instance Data.Barbie.Internal.Product.GProductB (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.Target (Data.Barbie.Internal.Generics.W Data.Barbie.Internal.Tags.F) a))
instance Data.Barbie.Internal.Product.GProductB (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F a))

module Data.Barbie.Internal.ProofB

-- | Barbie-types with products have a canonical proof of instance.
--   
--   There is a default <a>bproof</a> implementation for <a>Generic</a>
--   types, so instances can derived automatically.
class (ConstraintsB b, ProductB b) => ProofB b
bproof :: (ProofB b, ConstraintsOf c f b) => b (DictOf c f)
bproof :: (ProofB b, CanDeriveGenericInstance b, ConstraintsOfMatchesGenericDeriv c f b, ConstraintsOf c f b) => b (DictOf c f)

-- | Every type that admits a generic instance of <a>ProductB</a> and
--   <a>ConstraintsB</a>, has a generic instance of <a>ProofB</a> as well.
type CanDeriveGenericInstance b = (Generic (b (Target P)), GProof (ClassifyBarbie b) b (RecRep (b (Target F))), Rep (b (Target P)) ~ Repl' (Target F) (Target P) (RecRep (b (Target F))))
type ConstraintsOfMatchesGenericDeriv c f b = (ConstraintsOf c f b ~ GConstraintsOf c f (RecRep (b (Target F))), ConstraintsOf c f b ~ ConstraintByType (ClassifyBarbie b) c f (RecRep (b (Target F))))
type GConstraintsOf c f r = ConstraintByType (GClassifyBarbie r) c f r
class GProof (bt :: BarbieType) b rep

-- | Default implementation of <a>bproof</a> based on <a>Generic</a>.
gbproofDefault :: forall b c f. (CanDeriveGenericInstance b, ConstraintsOfMatchesGenericDeriv c f b, ConstraintsOf c f b) => b (DictOf c f)
instance Data.Barbie.Internal.ProofB.ProofB b' => Data.Barbie.Internal.ProofB.GProof bt b (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.NonRec (b' (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F))))
instance (Data.Barbie.Internal.ProofB.CanDeriveGenericInstance b, bt ~ Data.Barbie.Internal.Classification.ClassifyBarbie b) => Data.Barbie.Internal.ProofB.GProof bt b (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.RecUsage (b (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F))))
instance Data.Barbie.Internal.ProofB.GProof bt b x => Data.Barbie.Internal.ProofB.GProof bt b (GHC.Generics.M1 _i _c x)
instance Data.Barbie.Internal.ProofB.GProof bt b GHC.Generics.U1
instance (Data.Barbie.Internal.ProofB.GProof bt b l, Data.Barbie.Internal.ProofB.GProof bt b r) => Data.Barbie.Internal.ProofB.GProof bt b (l GHC.Generics.:*: r)
instance Data.Barbie.Internal.ProofB.GProof 'Data.Barbie.Internal.Classification.WearBarbie b (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.NonRec (Data.Barbie.Internal.Generics.Target (Data.Barbie.Internal.Generics.W Data.Barbie.Internal.Tags.F) a)))
instance Data.Barbie.Internal.ProofB.GProof 'Data.Barbie.Internal.Classification.NonWearBarbie b (GHC.Generics.K1 GHC.Generics.R (Data.Barbie.Internal.Generics.NonRec (Data.Barbie.Internal.Generics.Target Data.Barbie.Internal.Tags.F a)))


-- | Support for operating on Barbie-types with constrained functions.
--   
--   Consider the following function:
--   
--   <pre>
--   showIt :: <a>Show</a> a =&gt; <a>Maybe</a> a -&gt; <a>Const</a> <a>String</a> a
--   showIt = <a>Const</a> . <a>show</a>
--   </pre>
--   
--   We would then like to be able to do:
--   
--   <pre>
--   <a>bmap</a> <tt>showIt</tt> :: <a>FunctorB</a> b =&gt; b <a>Maybe</a> -&gt; b (<a>Const</a> <a>String</a>)
--   </pre>
--   
--   This however doesn't work because of the <tt>(<a>Show</a> a)</tt>
--   constraint in the the type of <tt>showIt</tt>.
--   
--   This module adds support to overcome this problem.
module Data.Barbie.Constraints

-- | <tt><a>DictOf</a> c f a</tt> is evidence that there exists an instance
--   of <tt>c (f a)</tt>.
data DictOf c f a
[PackedDict] :: c (f a) => DictOf c f a

-- | Pack the dictionary associated with an instance.
packDict :: c (f a) => DictOf c f a

-- | Turn a constrained-function into an unconstrained one that uses the
--   packed instance dictionary instead.
requiringDict :: (c (f a) => r) -> (DictOf c f a -> r)

-- | Instances of this class provide means to talk about constraints, both
--   at compile-time, using <a>ConstraintsOf</a> and at run-time, in the
--   form of class instance dictionaries, via <a>adjProof</a>.
--   
--   A manual definition would look like this:
--   
--   <pre>
--   data T f = A (f <a>Int</a>) (f <a>String</a>) | B (f <a>Bool</a>) (f <a>Int</a>)
--   
--   instance <a>ConstraintsB</a> T where
--     type <a>ConstraintsOf</a> c f T
--       = (c (f <a>Int</a>), c (f <a>String</a>), c (f <a>Bool</a>))
--   
--     adjProof t = case t of
--       A x y -&gt; A (<a>Pair</a> (<a>packDict</a> x) (<a>packDict</a> y))
--       B z w -&gt; B (<a>Pair</a> (<a>packDict</a> z) (<a>packDict</a> w))
--   </pre>
--   
--   There is a default implementation of <a>ConstraintsOf</a> for
--   <a>Generic</a> types, so in practice one will simply do:
--   
--   <pre>
--   derive instance <a>Generic</a> T
--   instance <a>ConstraintsB</a> T
--   </pre>
class FunctorB b => ConstraintsB b where {
    type family ConstraintsOf (c :: * -> Constraint) (f :: *
                                                           -> *) b :: Constraint;
    type ConstraintsOf c f b =
        GConstraintsOf c f (RecRep (b (Target F)));
}

-- | Barbie-types with products have a canonical proof of instance.
--   
--   There is a default <a>bproof</a> implementation for <a>Generic</a>
--   types, so instances can derived automatically.
class (ConstraintsB b, ProductB b) => ProofB b
bproof :: (ProofB b, ConstraintsOf c f b) => b (DictOf c f)
bproof :: (ProofB b, CanDeriveGenericInstance b, ConstraintsOfMatchesGenericDeriv c f b, ConstraintsOf c f b) => b (DictOf c f)


-- | A common Haskell idiom is to parameterise a datatype by a type <tt>*
--   -&gt; *</tt>, typically a functor or a GADT. These are like outfits of
--   a Barbie, that turn her into a different doll. E.g.
--   
--   <pre>
--   data Barbie f
--     = Barbie
--         { name :: f <a>String</a>
--         , age  :: f <a>Int</a>
--         }
--   
--   b1 :: Barbie <a>Last</a>       -- Barbie with a monoid structure
--   b2 :: Barbie (<a>Const</a> a)  -- <a>Container</a> Barbie
--   b3 :: Barbie <a>Identity</a>   -- Barbie's new clothes
--   </pre>
--   
--   This module define the classes to work with these types and easily
--   transform them. They all come with default instances based on
--   <a>Generic</a>, so using them is as easy as:
--   
--   <pre>
--   data Barbie f
--     = Barbie
--         { name :: f <a>String</a>
--         , age  :: f <a>Int</a>
--         }
--     deriving
--       ( <a>Generic</a>
--       , <a>FunctorB</a>, <a>TraversableB</a>, <a>ProductB</a>, <a>ConstraintsB</a>, <a>ProofB</a>
--       )
--   
--   deriving instance <a>ConstraintsOf</a> <a>Show</a> f Barbie =&gt; <a>Show</a> Barbie
--   deriving instance <a>ConstraintsOf</a> <a>Eq</a>   f Barbie =&gt; <a>Eq</a>   Barbie
--   </pre>
--   
--   Sometimes one wants to use <tt>Barbie <a>Identity</a></tt> and it may
--   feels lik a second-class record type, where one needs to unpack values
--   in each field. For those cases, we can leverage on closed
--   type-families ang get the best of both worlds:
--   
--   <pre>
--   data <a>Bare</a>
--   
--   type family <a>Wear</a> f a where
--     <a>Wear</a> <a>Bare</a> a = a
--     <a>Wear</a> f      a = f a
--   
--   data SignUpForm f
--     = SignUpForm'
--         { username  :: <a>Wear</a> f <a>String</a>,
--         , password  :: <a>Wear</a> f <a>String</a>
--         , mailingOk :: <a>Wear</a> f <tt>Boolean</tt>
--         }
--     deriving ( ..., <a>BareB</a>)
--   
--   type SignUpRaw  = SignUpForm <a>Maybe</a>
--   type SignUpData = SignUpForm <a>Bare</a>
--   
--   formData = SignUpForm "jbond" "shaken007" False :: SignUpData
--   </pre>
module Data.Barbie

-- | Barbie-types that can be mapped over. Instances of <a>FunctorB</a>
--   should satisfy the following laws:
--   
--   <pre>
--   <a>bmap</a> <a>id</a> = <a>id</a>
--   <a>bmap</a> f . <a>bmap</a> g = <a>bmap</a> (f . g)
--   </pre>
--   
--   There is a default <a>bmap</a> implementation for <a>Generic</a>
--   types, so instances can derived automatically.
class FunctorB b
bmap :: FunctorB b => (forall a. f a -> g a) -> b f -> b g
bmap :: (FunctorB b, CanDeriveGenericInstance b) => (forall a. f a -> g a) -> b f -> b g

-- | Barbie-types that can be traversed from left to right. Instances
--   should satisfy the following laws:
--   
--   <pre>
--    t . <a>btraverse</a> f = <a>btraverse</a> (t . f)  -- naturality
--   <a>btraverse</a> <a>Identity</a> = <a>Identity</a>         -- identity
--   <a>btraverse</a> (<a>Compose</a> . <a>fmap</a> g . f) = <a>Compose</a> . <a>fmap</a> (<a>btraverse</a> g) . <a>btraverse</a> f -- composition
--   </pre>
--   
--   There is a default <a>btraverse</a> implementation for <a>Generic</a>
--   types, so instances can derived automatically.
class FunctorB b => TraversableB b
btraverse :: (TraversableB b, Applicative t) => (forall a. f a -> t (g a)) -> b f -> t (b g)
btraverse :: (TraversableB b, Applicative t, CanDeriveGenericInstance b) => (forall a. f a -> t (g a)) -> b f -> t (b g)

-- | Evaluate each action in the structure from left to right, and collect
--   the results.
bsequence :: (Applicative f, TraversableB b) => b (Compose f g) -> f (b g)

-- | Barbie-types that can form products, subject to the laws:
--   
--   <pre>
--   <a>bmap</a> (<a>Pair</a> a _) . <a>uncurry</a> . <a>bprod</a> = <a>fst</a>
--   <a>bmap</a> (<a>Pair</a> _ b) . <a>uncurry</a> . <a>bprod</a> = <a>snd</a>
--   </pre>
--   
--   Notice that because of the laws, having an internal product structure
--   is not enough to have a lawful instance. E.g.
--   
--   <pre>
--   data Ok  f = Ok {o1 :: f <a>String</a>, o2 :: f <a>Int</a>}        -- has an instance
--   data Bad f = Bad{b1 :: f <a>String</a>, hiddenFromArg: <a>Int</a>} -- no lawful instance
--   </pre>
--   
--   Intuitively, the laws for this class require that <tt>b</tt> hides no
--   structure from its argument <tt>f</tt>. Because of this, any <tt>x ::
--   forall a . f a</tt> determines a unique value of <tt>b f</tt>,
--   witnessed by the <a>buniq</a> method. Formally:
--   
--   <pre>
--   <a>const</a> (<a>buniq</a> x) = <a>bmap</a> (<a>const</a> x)
--   </pre>
--   
--   There is a default implementation of <a>bprod</a> and <a>buniq</a> for
--   <a>Generic</a> types, so instances can derived automatically.
class FunctorB b => ProductB b
bprod :: ProductB b => b f -> b g -> b (Product f g)
buniq :: ProductB b => (forall a. f a) -> b f
bprod :: (ProductB b, CanDeriveGenericInstance b) => b f -> b g -> b (Product f g)
buniq :: (ProductB b, CanDeriveGenericInstance' b) => (forall a. f a) -> b f

-- | Like <a>bprod</a>, but returns a binary <a>Prod</a>, instead of
--   <a>Product</a>, which composes better.
--   
--   See <a>/*/</a> for usage.
(/*/) :: ProductB b => b f -> b g -> b (Prod '[f, g])
infixr 4 /*/

-- | Similar to <a>/*/</a> but one of the sides is already a 'Prod fs'.
--   
--   Note that <a>/*</a>, <a>/*/</a> and <a>uncurryn</a> are meant to be
--   used together: <a>/*</a> and <a>/*/</a> combine <tt>b f1, b f2...b
--   fn</tt> into a single product that can then be consumed by using
--   <a>uncurryn</a> on an n-ary function. E.g.
--   
--   <pre>
--   f :: f a -&gt; g a -&gt; h a -&gt; i a
--   
--   <a>bmap</a> (<a>uncurryn</a> f) (bf <a>/*</a> bg <a>/*/</a> bh)
--   </pre>
(/*) :: ProductB b => b f -> b (Prod fs) -> b (Prod (f : fs))
infixr 4 /*

-- | An alias of <a>bprod</a>, since this is like a <a>zip</a> for
--   Barbie-types.
bzip :: ProductB b => b f -> b g -> b (Product f g)

-- | An equivalent of <a>unzip</a> for Barbie-types.
bunzip :: ProductB b => b (Product f g) -> (b f, b g)

-- | An equivalent of <a>zipWith</a> for Barbie-types.
bzipWith :: ProductB b => (forall a. f a -> g a -> h a) -> b f -> b g -> b h

-- | An equivalent of <a>zipWith3</a> for Barbie-types.
bzipWith3 :: ProductB b => (forall a. f a -> g a -> h a -> i a) -> b f -> b g -> b h -> b i

-- | An equivalent of <a>zipWith4</a> for Barbie-types.
bzipWith4 :: ProductB b => (forall a. f a -> g a -> h a -> i a -> j a) -> b f -> b g -> b h -> b i -> b j

-- | The <a>Wear</a> type-function allows one to define a Barbie-type as
--   
--   <pre>
--   data B f
--     = B { f1 :: <a>Wear</a> f <a>Int</a>
--         , f2 :: <a>Wear</a> f <a>Bool</a>
--         }
--   </pre>
--   
--   This way, one can use <a>Bare</a> as a phantom that denotes no functor
--   around the typw:
--   
--   <pre>
--   B { f1 :: 5, f2 = <a>True</a> } :: B <a>Bare</a>
--   </pre>

-- | <a>Bare</a> is the only type such that <tt><a>Wear</a> <a>Bare</a> a ~
--   a'</tt>.
data Bare a

-- | Class of Barbie-types defined using <a>Wear</a> and can therefore have
--   <a>Bare</a> versions. Must satisfy:
--   
--   <pre>
--   <a>bcover</a> . <a>bstrip</a> = <a>id</a>
--   <a>bstrip</a> . <a>bcover</a> = <a>id</a>
--   </pre>
class FunctorB b => BareB b
bstrip :: BareB b => b Identity -> b Bare
bcover :: BareB b => b Bare -> b Identity
bstrip :: (BareB b, CanDeriveGenericInstance b) => b Identity -> b Bare
bcover :: (BareB b, CanDeriveGenericInstance' b) => b Bare -> b Identity

-- | Generalization of <a>bstrip</a> to arbitrary functors
bstripFrom :: BareB b => (forall a. f a -> a) -> b f -> b Bare

-- | Generalization of <a>bcover</a> to arbitrary functors
bcoverWith :: BareB b => (forall a. a -> f a) -> b Bare -> b f

-- | Instances of this class provide means to talk about constraints, both
--   at compile-time, using <a>ConstraintsOf</a> and at run-time, in the
--   form of class instance dictionaries, via <a>adjProof</a>.
--   
--   A manual definition would look like this:
--   
--   <pre>
--   data T f = A (f <a>Int</a>) (f <a>String</a>) | B (f <a>Bool</a>) (f <a>Int</a>)
--   
--   instance <a>ConstraintsB</a> T where
--     type <a>ConstraintsOf</a> c f T
--       = (c (f <a>Int</a>), c (f <a>String</a>), c (f <a>Bool</a>))
--   
--     adjProof t = case t of
--       A x y -&gt; A (<a>Pair</a> (<a>packDict</a> x) (<a>packDict</a> y))
--       B z w -&gt; B (<a>Pair</a> (<a>packDict</a> z) (<a>packDict</a> w))
--   </pre>
--   
--   There is a default implementation of <a>ConstraintsOf</a> for
--   <a>Generic</a> types, so in practice one will simply do:
--   
--   <pre>
--   derive instance <a>Generic</a> T
--   instance <a>ConstraintsB</a> T
--   </pre>
class FunctorB b => ConstraintsB b where {
    type family ConstraintsOf (c :: * -> Constraint) (f :: *
                                                           -> *) b :: Constraint;
    type ConstraintsOf c f b =
        GConstraintsOf c f (RecRep (b (Target F)));
}

-- | Adjoint a proof-of-instance to a barbie-type.
adjProof :: forall c f. (ConstraintsB b, ConstraintsOf c f b) => b f -> b (Product (DictOf c f) f)

-- | Adjoint a proof-of-instance to a barbie-type.
adjProof :: forall c f. (ConstraintsB b, CanDeriveGenericInstance b, ConstraintsOfMatchesGenericDeriv c f b, ConstraintsOf c f b) => b f -> b (Product (DictOf c f) f)

-- | Barbie-types with products have a canonical proof of instance.
--   
--   There is a default <a>bproof</a> implementation for <a>Generic</a>
--   types, so instances can derived automatically.
class (ConstraintsB b, ProductB b) => ProofB b
bproof :: (ProofB b, ConstraintsOf c f b) => b (DictOf c f)
bproof :: (ProofB b, CanDeriveGenericInstance b, ConstraintsOfMatchesGenericDeriv c f b, ConstraintsOf c f b) => b (DictOf c f)

-- | A wrapper for Barbie-types, providing useful instances.
newtype Barbie b (f :: * -> *)
Barbie :: b f -> Barbie b
[getBarbie] :: Barbie b -> b f


-- | We get a container of <tt>a</tt>'s for any Barbie-type when we make it
--   wear a <tt>(<a>Const</a> a)</tt> . The <a>Container</a> wrapper gives
--   us the expected instances for a container type.
module Data.Barbie.Container

-- | Wrapper for container-Barbies.
newtype Container b a
Container :: b (Const a) -> Container b a
[getContainer] :: Container b a -> b (Const a)
instance GHC.Generics.Generic (Data.Barbie.Container.Container b a)
instance GHC.Classes.Eq (b (Data.Functor.Const.Const a)) => GHC.Classes.Eq (Data.Barbie.Container.Container b a)
instance GHC.Classes.Ord (b (Data.Functor.Const.Const a)) => GHC.Classes.Ord (Data.Barbie.Container.Container b a)
instance GHC.Read.Read (b (Data.Functor.Const.Const a)) => GHC.Read.Read (Data.Barbie.Container.Container b a)
instance GHC.Show.Show (b (Data.Functor.Const.Const a)) => GHC.Show.Show (Data.Barbie.Container.Container b a)
instance Data.Barbie.Internal.Functor.FunctorB b => GHC.Base.Functor (Data.Barbie.Container.Container b)
instance Data.Barbie.Internal.Traversable.TraversableB b => Data.Foldable.Foldable (Data.Barbie.Container.Container b)
instance Data.Barbie.Internal.Traversable.TraversableB b => Data.Traversable.Traversable (Data.Barbie.Container.Container b)
instance Data.Barbie.Internal.Product.ProductB b => GHC.Base.Applicative (Data.Barbie.Container.Container b)