!"      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe &'+FQTV barbies c f a1 is evidence that there exists an instance of c (f a).barbies0Pack the dictionary associated with an instance.barbiesjTurn a constrained-function into an unconstrained one that uses the packed instance dictionary instead. NoneFSTVbarbiesWe use  to identify usagaes of Wear3 in the generic representation of a barbie-type.barbiesWe use h to identify the position in the generic representation where the barbie type is used recursively.barbiesWe use D to identify the position in in the generic representation where f6 is used. This is a hack to overcome the fact that & does not currently work on a type T f whenever if f is applied in T), which are all the interesting cases! Safebarbies%THIS SHOULD NEVER SHOW UP IN HADDOCK!barbies%THIS SHOULD NEVER SHOW UP IN HADDOCK!barbies%THIS SHOULD NEVER SHOW UP IN HADDOCK!barbies%THIS SHOULD NEVER SHOW UP IN HADDOCK!barbies%THIS SHOULD NEVER SHOW UP IN HADDOCK!barbies%THIS SHOULD NEVER SHOW UP IN HADDOCK!barbies%THIS SHOULD NEVER SHOW UP IN HADDOCK!None+67;<=FQSTV]i$barbies&Intuivively, the requirements to have  B derived are:There is an instance of  (B f) for every fIf f7 is used as argument to some type in the definition of B,, it is only on a Barbie-type with a  instance.Recursive usages of B f/ are allowed to appear as argument to a  (e.g. @ (B f)')barbies3Barbie-types that can be mapped over. Instances of & should satisfy the following laws:    =   f .  g =  (f . g) There is a default  implementation for 0 types, so instances can derived automatically.barbiesDefault implementation of  based on .None-FST)barbiesThe parameter is never used.barbies*The parameter is used, and always under a Wear.barbies%The parameter is used, never under a Wear.barbies)THe parameter is used, sometimes under a Wear, somtimes not.None+7;<=FQSTV]i6mbarbies&Intuivively, the requirements to have  B derived are:There is an instance of  (B f) for every fIf f7 is used as argument to some type in the definition of B,, it is only on a Barbie-type with a  instance.Recursive usages of B f/ are allowed to appear as argument to a  (e.g. @ (B f)')barbiesfBarbie-types that can be traversed from left to right. Instances should satisfy the following laws:  t .  f =  (t . f) -- naturality   =  -- identity  ( .  g . f) =  .  ( g) .  f -- composition There is a default  implementation for 0 types, so instances can derived automatically.barbiesUEvaluate each action in the structure from left to right, and collect the results.barbiesDefault implementation of  based on .NoneFT;#barbies# is the only type such that $ # a ~ a'.$barbiesThe $4 type-function allows one to define a Barbie-type as data B f = B { f1 :: $ f  , f2 :: $ f  } This way, one can use #7 as a phantom that denotes no functor around the typw: B { f1 :: 5, f2 =  } :: B # #$None+-7;<=>?FSTV]iL)barbies&Intuivively, the requirements to have * B derived are:There is an instance of  (B f) for every fIf f7 is used as argument to some type in the definition of B,, it is only on a Barbie-type with a * instance.*barbies`Instances of this class provide means to talk about constraints, both at compile-time, using +E and at run-time, in the form of class instance dictionaries, via ,.)A manual definition would look like this: data T f = A (f ) (f  ) | B (f ) (f  ) instance * T where type + c f T = (c (f ), c (f ), c (f -)) adjProof t = case t of A x y -> A ( ( x) ( y)) B z w -> B ( ( z) ( w)) %There is a default implementation of + for * types, so in practice one will simply do: derive instance  T instance * T +barbies+ c f b should contain a constraint c (f x) for each f x occurring in b. E.g.: +  f Barbie = ( (f ),  (f )) ,barbies-Adjoint a proof-of-instance to a barbie-type.-barbiesDefault implementation of , based on . %&'()*+,- *+,)(&%-'None+7;<=FQSTV]iU;barbiesXAll types that admit a generic FunctorB' instance, and have all their occurrences of f under a $ admit a generic < instance.<barbies$Class of Barbie-types defined using $ and can therefore have # versions. Must satisfy: > . = =  = . > =  ?barbiesGeneralization of = to arbitrary functors@barbiesGeneralization of > to arbitrary functorsAbarbiesDefault implementatio of = based on .BbarbiesDefault implementatio of = based on . #$89:;<=>?@AB $#<=>?@89AB;:Safe &',-;<=FST]uUbarbiesW '[f, g, h] a -> r4 is the type of the uncurried form of a function f a -> g a -> h a -> r. U, moves from the former to the later. E.g. U (W '[] a -> r) = r a U (W '[f] a -> r) = f a -> r a U (W% '[f, g] a -> r) = f a -> g a -> r a Vbarbies,Type-level, poly-kinded, list-concatenation.WbarbiesProduct of n functors.ZbarbiesThe unit of the product.[barbiesLift a functor to a 1-tuple.\barbiesConversion from a standard ]barbiesConversion to a standard ^barbiesFlat product of products._barbiesLike  but using WA instead of pairs. Can be thought of as a family of functions: _ :: r a -> W '[] a _ :: (f a -> r a) -> W '[f] a _ :: (f a -> g a -> r a) -> W '[f, g] a _" :: (f a -> g a -> h a -> r a) -> W '[f, g, h] a " `barbiesInductively defined instance:  (W (f ': fs)).abarbiesInductively defined instance:  (W '[]).bbarbiesInductively defined instance:  (W (f ': fs)).cbarbiesInductively defined instance:  (W '[]).dbarbiesInductively defined instance:  (W (f ': fs)).ebarbiesInductively defined instance:  (W '[]).fbarbiesInductively defined instance:  (W (f ': fs)).gbarbiesInductively defined instance:  (W '[]).hbarbiesInductively defined instance:  (W (f ': fs)).ibarbiesInductively defined instance:  (W '[]).jbarbiesInductively defined instance:  (W (f ': fs)).kbarbiesInductively defined instance:  (W '[]).lbarbiesInductively defined instance:  (W (f ': fs)).mbarbiesInductively defined instance:  (W '[]).nbarbiesInductively defined instance:  (W (f ': fs)).obarbiesInductively defined instance:  (W '[]).pbarbiesInductively defined instance:  (W (f ': fs)).qbarbiesInductively defined instance:  (W '[]).rbarbiesInductively defined instance:  (W (f ': fs)).sbarbiesInductively defined instance:  (W '[]).tbarbiesInductively defined instance:  (W (f ': fs)).ubarbiesInductively defined instance:  (W '[]). UVWXYZ[\]^_ WXYZ[\]^_VUNone+-7;<=FQSTVi xbarbiesThe requirements to to derive y (B f)# are more strict than those for  or  TraversableB. Intuitively, we need:There is an instance of  (B f) for every fB has only one constructor.Every field of B-' constructor is of the form 'f t'. That is, B has no hidden structure.ybarbies9Barbie-types that can form products, subject to the laws:  ( a _) .  . z =   ( _ b) .  . z =  tNotice that because of the laws, having an internal product structure is not enough to have a lawful instance. E.g. data Ok f = Ok {o1 :: f  , o2 :: f 5} -- has an instance data Bad f = Bad{b1 :: f , hiddenFromArg: } -- no lawful instance 2Intuitively, the laws for this class require that b' hides no structure from its argument f. Because of this, any x :: forall a . f a determines a unique value of b f, witnessed by the { method. Formally:  ({ x) =  ( x) %There is a default implementation of z and { for 0 types, so instances can derived automatically.|barbies An alias of z, since this is like a  for Barbie-types.}barbiesAn equivalent of  for Barbie-types.~barbiesAn equivalent of  for Barbie-types.barbiesAn equivalent of  for Barbie-types.barbiesAn equivalent of  for Barbie-types.barbiesLike z, but returns a binary W , instead of , which composes better.See  for usage.barbies Similar to - but one of the sides is already a 'Prod fs'. Note that ,  and _# are meant to be used together:  and  combine b f1, b f2...b fn= into a single product that can then be consumed by using _ on an n-ary function. E.g. f :: f a -> g a -> h a -> i a  (_ f) (bf  bg  bh) barbiesDefault implementation of z based on .vwxy{z|}~y{z|}~xwv44None+-7;<=>?FSTViQbarbies-Every type that admits a generic instance of y and *, has a generic instance of  as well.barbies>Barbie-types with products have a canonical proof of instance.There is a default  implementation for 0 types, so instances can derived automatically.barbiesDefault implementation of  based on .&&None*+*+NoneFKTgbarbies7A wrapper for Barbie-types, providing useful instances. None#$*+,<=>?@y{z|}~y{z|}~$#<=>?@*+, None06barbiesWrapper for container-Barbies.     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~O>                     &barbies-0.1.3.1-LKgSwW1XNT88vGqRWdpoc1Data.Barbie.ConstraintsData.Barbie.Internal.Functor Data.Barbie.Internal.TraversableData.Barbie.Internal.Bare Data.Barbie.Internal.ConstraintsData.Functor.ProdData.Barbie.Internal.ProductData.Barbie.Internal.ProofB Data.BarbieData.Barbie.ContainerData.Barbie.Internal.DictsData.Barbie.Internal.GenericsData.Barbie.Internal.Tags#Data.Barbie.Internal.Classification Data.FunctorIdentityData.Barbie.Internal.Wear Data.ListzipWithzipWith3zipWith4Data.Barbie.Internal.InstancesDictOf PackedDictpackDict requiringDict GFunctorBCanDeriveGenericInstanceFunctorBbmap gbmapDefault $fGFunctorBK1$fGFunctorBK10$fGFunctorBK11$fGFunctorB:+:$fGFunctorB:*: $fGFunctorBU1 $fGFunctorBV1 $fGFunctorBM1$fGFunctorBK12$fGFunctorBK13 GTraversableB TraversableB btraverse bsequencegbtraverseDefault$fGTraversableBK1$fGTraversableBK10$fGTraversableBK11$fGTraversableB:+:$fGTraversableB:*:$fGTraversableBU1$fGTraversableBV1$fGTraversableBM1$fGTraversableBK12$fGTraversableBK13BareWear GAdjProofGConstraintsOfConstraintByType ConstraintsOfMatchesGenericDeriv ConstraintsB ConstraintsOfadjProofgadjProofDefault$fGAdjProofbtbK1$fGAdjProofbtbK10$fGAdjProofbtbK11$fGAdjProofNonWearBarbiebK1$fGAdjProofWearBarbiebK1$fGAdjProofbtb:+:$fGAdjProofbtb:*:$fGAdjProofbtbU1$fGAdjProofbtbV1$fGAdjProofbtbM1GbstripgbstripCanDeriveGenericInstance'BareBbstripbcover bstripFrom bcoverWithgbstripDefaultgbcoverDefault $fGbstripK1 $fGbstripK10 $fGbstrip:+: $fGbstrip:*: $fGbstripU1 $fGbstripV1 $fGbstripM1 $fGbcoverK1 $fGbcoverK10 $fGbcover:+: $fGbcover:*: $fGbcoverU1 $fGbcoverV1 $fGbcoverM1 $fGbcoverK11 $fGbcoverK12 $fGbstripK11 $fGbstripK12Curried++ProdUnitCons zeroTupleoneTuple fromProduct toProductproduncurryn $fShowProd $fShowProd0 $fShow1Prod $fShow1Prod0 $fOrdProd $fOrdProd0 $fOrd1Prod $fOrd1Prod0$fEqProd $fEqProd0 $fEq1Prod $fEq1Prod0$fTraversableProd$fTraversableProd0$fFoldableProd$fFoldableProd0$fAlternativeProd$fAlternativeProd0$fApplicativeProd$fApplicativeProd0 $fFunctorProd$fFunctorProd0 GProductBProductBbprodbuniqbzipbunzipbzipWith bzipWith3 bzipWith4/*//* gbprodDefault gbuniqDefault $fGProductBK1$fGProductBK10$fGProductB:*: $fGProductBU1 $fGProductBM1$fGProductBK11GProofProofBbproofgbproofDefault$fGProofNonWearBarbiebK1$fGProofWearBarbiebK1$fGProofbtb:*: $fGProofbtbU1 $fGProofbtbM1 $fGProofbtbK1$fGProofbtbK10Barbie getBarbie Container getContainer$fApplicativeContainer$fTraversableContainer$fFoldableContainer$fFunctorContainer$fGenericContainer$fShowContainer$fReadContainer$fOrdContainer $fEqContainerWRecUsageTargetbase GHC.GenericsGeneric1Repl'RecRepDeannRecAnnRecNonRecReplunsafeTargetBarbieunsafeUntarget unsafeTargetunsafeUntargetBarbiefromWithRecAnn toWithRecAnnBIPxFPFxGGFGenericGHC.BaseFunctorMaybeidNoBarbie WearBarbie NonWearBarbie MixedBarbieClassifyBarbieGClassifyBarbie BarbieTypeData.Traversable TraversableData.Functor.ComposeComposefmapghc-prim GHC.TypesIntBoolTrueStringData.Functor.ProductPairGHC.ShowShowProduct Data.TupleuncurryData.Functor.ClassesShow1 GHC.ClassesOrdOrd1EqEq1 Data.FoldableFoldable Alternative ApplicativefstsndconstGHC.Listzipunzip