!K      !"#$%&'()*+,-./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. NoneFSTV8barbiesWe 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)6barbiesThe 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]i8Wbarbies&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.barbiesdMap each element to an action, evaluate these actions from left to right, and ignore the results.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]iN*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]iW<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 functorsAbarbiesGeneralization of ? to arbitrary functorsBbarbiesDefault implementatio of > based on .CbarbiesDefault implementatio of > based on . $%9:;<=>?@ABC %$=>?@A9:BC<;Safe &',-;<=FST]wVbarbiesX '[f, g, h] a -> r4 is the type of the uncurried form of a function f a -> g a -> h a -> r. V, moves from the former to the later. E.g. V (X '[] a -> r) = r a V (X '[f] a -> r) = f a -> r a V (X% '[f, g] a -> r) = f a -> g a -> r a Wbarbies,Type-level, poly-kinded, list-concatenation.XbarbiesProduct of n functors.[barbiesThe 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 XA instead of pairs. Can be thought of as a family of functions: ` :: r a -> X '[] a ` :: (f a -> r a) -> X '[f] a ` :: (f a -> g a -> r a) -> X '[f, g] a `" :: (f a -> g a -> h a -> r a) -> X '[f, g, h] a " abarbiesInductively defined instance:  (X (f ': fs)).bbarbiesInductively defined instance:  (X '[]).cbarbiesInductively defined instance:  (X (f ': fs)).dbarbiesInductively defined instance:  (X '[]).ebarbiesInductively defined instance:  (X (f ': fs)).fbarbiesInductively defined instance:  (X '[]).gbarbiesInductively defined instance:  (X (f ': fs)).hbarbiesInductively defined instance:  (X '[]).ibarbiesInductively defined instance:  (X (f ': fs)).jbarbiesInductively defined instance:  (X '[]).kbarbiesInductively defined instance:  (X (f ': fs)).lbarbiesInductively defined instance:  (X '[]).mbarbiesInductively defined instance:  (X (f ': fs)).nbarbiesInductively defined instance:  (X '[]).obarbiesInductively defined instance:  (X (f ': fs)).pbarbiesInductively defined instance:  (X '[]).qbarbiesInductively defined instance:  (X (f ': fs)).rbarbiesInductively defined instance:  (X '[]).sbarbiesInductively defined instance:  (X (f ': fs)).tbarbiesInductively defined instance:  (X '[]).ubarbiesInductively defined instance:  (X (f ': fs)).vbarbiesInductively defined instance:  (X '[]). VWXYZ[\]^_` XYZ[\]^_`WVNone+-7;<=FQSTVi ybarbiesThe requirements to to derive z (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.zbarbies9Barbie-types that can form products, subject to the laws:  ( a _) .  . { =   ( _ b) .  . { =  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 { and | for 0 types, so instances can derived automatically.}barbies An alias of {, 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 {, but returns a binary X , 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 { based on .wxyz|{}~z|{}~yxw44None+-7;<=>?FSTViCbarbies-Every type that admits a generic instance of z 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 .''None016Fdbarbies A barbie type without structure.barbiesUninhabited barbie type.NoneH+,+,NoneFKTbarbies7A wrapper for Barbie-types, providing useful instances. None3"$%+,-=>?@Az|{}~"z|{}~%$=>?@A+,- None06/barbiesWrapper for container-Barbies.     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Q@nn                     &barbies-0.1.4.0-3FvfyaZZEwhFISCUZKP09QData.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.TrivialData.Barbie.Internal.InstancesDictOf PackedDictpackDict requiringDict GFunctorBCanDeriveGenericInstanceFunctorBbmap gbmapDefault $fGFunctorBK1$fGFunctorBK10$fGFunctorBK11$fGFunctorB:+:$fGFunctorB:*: $fGFunctorBU1 $fGFunctorBV1 $fGFunctorBM1$fGFunctorBK12$fGFunctorBK13 GTraversableB TraversableB btraverse 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$fGProofbtbK10VoidBarbie 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