,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe &'+FQTV  c f a1 is evidence that there exists an instance of c (f a).0Pack the dictionary associated with an instance.jTurn a constrained-function into an unconstrained one that uses the packed instance dictionary instead. NoneFSTV[We use  to identify usagaes of Wear3 in the generic representation of a barbie-type.We use h to identify the position in the generic representation where the barbie type is used recursively.We 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! Safe.%THIS SHOULD NEVER SHOW UP IN HADDOCK!%THIS SHOULD NEVER SHOW UP IN HADDOCK!%THIS SHOULD NEVER SHOW UP IN HADDOCK!%THIS SHOULD NEVER SHOW UP IN HADDOCK!%THIS SHOULD NEVER SHOW UP IN HADDOCK!%THIS SHOULD NEVER SHOW UP IN HADDOCK!%THIS SHOULD NEVER SHOW UP IN HADDOCK!None+67;<=FQSTV]h#8&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)')3Barbie-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.Default implementation of  based on .None-FST&The parameter is never used.*The parameter is used, and always under a Wear.%The parameter is used, never under a Wear.)THe parameter is used, sometimes under a Wear, somtimes not.None+7;<=FQSTV]h3&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)')fBarbie-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.UEvaluate each action in the structure from left to right, and collect the results.Default implementation of  based on .NoneFT8## is the only type such that $ # a ~ a'.$The $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]hI)&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.*`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 ++ c f b should contain a constraint c (f x) for each f x occurring in b. E.g.: +  f Barbie = ( (f ),  (f )) ,-Adjoint a proof-of-instance to a barbie-type.-Default implementation of , based on . %&'()*+,- *+,,)(&%-'%*+,,None+7;<=FQSTV]hQM;XAll types that admit a generic FunctorB' instance, and have all their occurrences of f under a $ admit a generic < instance.<$Class of Barbie-types defined using $ and can therefore have # versions. Must satisfy: > . = =  = . > =  ?Generalization of = to arbitrary functors@Generalization of > to arbitrary functorsADefault implementatio of = based on .BDefault implementatio of = based on . #$89:;<=>?@AB$#<=>=>?@89AB;:89<=>=>Safe &',-;<=FST]n`UW '[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 V,Type-level, poly-kinded, list-concatenation.WProduct of n functors.ZThe unit of the product.[Lift a functor to a 1-tuple.\Conversion from a standard ]Conversion to a standard ^Flat product of products._Like  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 " `Inductively defined instance:  (W (f ': fs)).aInductively defined instance:  (W '[]).bInductively defined instance:  (W (f ': fs)).cInductively defined instance:  (W '[]).dInductively defined instance:  (W (f ': fs)).eInductively defined instance:  (W '[]).fInductively defined instance:  (W (f ': fs)).gInductively defined instance:  (W '[]).hInductively defined instance:  (W (f ': fs)).iInductively defined instance:  (W '[]).jInductively defined instance:  (W (f ': fs)).kInductively defined instance:  (W '[]).lInductively defined instance:  (W (f ': fs)).mInductively defined instance:  (W '[]).nInductively defined instance:  (W (f ': fs)).oInductively defined instance:  (W '[]).pInductively defined instance:  (W (f ': fs)).qInductively defined instance:  (W '[]).rInductively defined instance:  (W (f ': fs)).sInductively defined instance:  (W '[]).tInductively defined instance:  (W (f ': fs)).uInductively defined instance:  (W '[]). UVWXYZ[\]^_ WXYZ[\]^_VUWXYNone+-7;<=FQSTVh xThe 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.y9Barbie-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.| An alias of z, since this is like a  for Barbie-types.}An equivalent of  for Barbie-types.~An equivalent of  for Barbie-types.An equivalent of  for Barbie-types.An equivalent of  for Barbie-types.Like z, but returns a binary W , instead of , which composes better.See  for usage. 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) Default implementation of z based on .vwxy{z|}~yz{z{|}~xwvvyz{z{44None+-7;<=>?FSTVh-Every type that admits a generic instance of y and *, has a generic instance of  as well.>Barbie-types with products have a canonical proof of instance.There is a default  implementation for 0 types, so instances can derived automatically.Default implementation of  based on .&&NoneW*+ *+NoneFK7A wrapper for Barbie-types, providing useful instances. None!#$*+,<=>?@y{z|}~&yz{z{|}~$#<=>=>?@*+,, None06Wrapper for container-Barbies.     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~O>                    &barbies-0.1.0.0-2T4pX23C0tcEKyfVVasHJsData.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.BaseFunctorMaybeidgbmapNoBarbie WearBarbie NonWearBarbie MixedBarbieClassifyBarbieGClassifyBarbie BarbieTypeData.Traversable TraversableData.Functor.ComposeComposefmap gbtraverseghc-prim GHC.TypesIntBoolTrueStringData.Functor.ProductPairGHC.ShowShow gadjProofGbcovergbcoverProduct Data.TupleuncurryData.Functor.ClassesShow1 GHC.ClassesOrdOrd1EqEq1 Data.FoldableFoldable Alternative ApplicativefstsndconstGHC.Listzipunzipgbprodgbuniqgbproof