úÎ!×zÈ؆      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…Safe&',-.1278=>?@AHSUVX_fkêbarbiesLike  but for binary relations.barbies' has one universal instance that makes  c f a equivalent to c (f a). However, we have 'ClassF c f :: k ->  Constraint GThis is useful since it allows to define constraint-constructors like  † ‡barbies c a. is evidence that there exists an instance of c a. It is essentially equivalent to  Dict (c a) from the  .http://hackage.haskell.org/package/constraints constraintsI package, but because of its kind, it allows us to define things like  ˆ.barbiesjTurn a constrained-function into an unconstrained one that uses the packed instance dictionary instead.Safe,.1278=>?@AHSUVX_fk÷barbiesThe 4 type-function allows one to define a Barbie-type as data B t f = B { f1 ::  t f ‰ , f2 ::  t f Š } .This gives rise to two rather different types:B  f1 is a normal Barbie-type, in the sense that f1 :: B  f -> f ‰, etc.B  fM, on the other hand, is a normal record with no functor around the type: B { f1 :: 5, f2 = ‹ } :: B  f Safe&',-.1278=>?@AHSUVX_fk9€barbies  '[f, g, h] a -> r4 is the type of the uncurried form of a function f a -> g a -> h a -> r. , moves from the former to the later. E.g.  (  '[] a -> r) = r a  (  '[f] a -> r) = f a -> r a  ( % '[f, g] a -> r) = f a -> g a -> r a barbies,Type-level, poly-kinded, list-concatenation. barbiesProduct 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  A instead of pairs. Can be thought of as a family of functions:  :: r a ->   '[] a  :: (f a -> r a) ->   '[f] a  :: (f a -> g a -> r a) ->   '[f, g] a " :: (f a -> g a -> h a -> r a) ->   '[f, g, h] a "î barbiesInductively defined instance: ˆ (  (f ': fs)).barbiesInductively defined instance: ˆ (  '[]).barbiesInductively defined instance: Ž (  (f ': fs)).barbiesInductively defined instance: Ž (  '[]).barbiesInductively defined instance:  (  (f ': fs)).barbiesInductively defined instance:  (  '[]).barbiesInductively defined instance:  (  (f ': fs)).barbiesInductively defined instance:  (  '[]).barbiesInductively defined instance: ‘ (  (f ': fs)).barbiesInductively defined instance: ‘ (  '[]).barbiesInductively defined instance: ’ (  (f ': fs)).barbiesInductively defined instance: ’ (  '[]).barbiesInductively defined instance: “ (  (f ': fs)). barbiesInductively defined instance: “ (  '[]).!barbiesInductively defined instance: ” (  (f ': fs))."barbiesInductively defined instance: ” (  '[]).#barbiesInductively defined instance: • (  (f ': fs)).$barbiesInductively defined instance: • (  '[]).%barbiesInductively defined instance: – (  (f ': fs)).&barbiesInductively defined instance: – (  '[]).'barbiesInductively defined instance: — (  (f ': fs)).(barbiesInductively defined instance: — (  '[]).     (C) 2018 Csongor KissBSD3 experimental non-portableNone,-./1278=>?@AHSUVX_fk>¾˜barbies˜ a b holds iff a ~ b or ™ n a ~ b—. It is useful when defining generic instances and one don't want to differentiate the case of a parameter-usage from the usage of a constant.lš›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûü˜)*ýþ+,-™ None,-.1278=>?@AHSUVX_fkL¢0barbies0 B f g" is in practice a predicate about BK only. Intuitively, it says that the following holds, for any arbitrary f:There is an instance of š (B f).B f can contain fields of type b f" as long as there exists a 1 b. instance. In particular, recursive usages of B f are allowed.B f can also contain usages of b f under a — h$. For example, one could use ‡ (B f) when defining B f.1barbies3Barbie-types that can be mapped over. Instances of 1& should satisfy the following laws:  2 ÿ = ÿ 2 f . 2 g = 2 (f . g) There is a default 2 implementation for š0 types, so instances can derived automatically.3barbiesDefault implementation of 2 based on š../0123 None,-.1278=>?@AHSUVX_fk`6barbies6 B f g" is in practice a predicate about B only. It is analogous to   I, so it essentially requires the following to hold, for any arbitrary f:There is an instance of š (B f).B f can contain fields of type b f" as long as there exists a 7 b. instance. In particular, recursive usages of B f are allowed.B f can also contain usages of b f under a “ h$. For example, one could use ‡ (B f) when defining B f.7barbiesfBarbie-types that can be traversed from left to right. Instances should satisfy the following laws:  t . 8 f = 8 (t . f) -- naturality 8   =   -- identity 8 ( .  g . f) =  .  (8 g) . 8 f -- composition There is a default 8 implementation for š0 types, so instances can derived automatically.9barbiesdMap 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.;barbies A version of : with g specialized to .<barbies6Map each element to a monoid, and combine the results.=barbiesDefault implementation of 8 based on š. 456789:;<=None,-.1278=>?@AHSUVX_fk~n AbarbiesA B f g" is in practice a predicate about BK only. Intuitively, it says that the following holds, for any arbitrary f:There is an instance of š (B f).B: has only one constructor (that is, it is not a sum-type).Every field of B f is of the form f a, for some type a. In other words, B has no "hidden" structure.Bbarbies9Barbie-types that can form products, subject to the laws: 2 (\( a _) -> a) .  . C =  2 (\( _ b) -> b) .  . C =  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 ‰} 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, if we are given any: x :: forall a . f a ,then this determines a unique value of type b f, witnessed by the D method. For example: D x = Ok {o1 = x, o2 = x}  Formally, D should satisfy:  (D x) = 2 ( x) %There is a default implementation of C and D for š0 types, so instances can derived automatically.Ebarbies An alias of C, since this is like a  for Barbie-types.FbarbiesAn equivalent of   for Barbie-types.GbarbiesAn equivalent of  for Barbie-types.HbarbiesAn equivalent of  for Barbie-types.IbarbiesAn equivalent of  for Barbie-types.JbarbiesLike C, but returns a binary   , instead of Œ, which composes better.See J for usage.Kbarbies Similar to J# but one of the sides is already a   fs. Note that K, J and # are meant to be used together: K and J 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 2 ( f) (bf K bg J bh) LbarbiesDefault implementation of C based on š.>?@ABDCEFGHIJKLMJ4K4None,-.1278=>?@AHSUVX_fk¢±Nbarbies,We use type-families to generically compute [ 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 bN, 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 ()g instead of `AllB b f` to break the recursion. Our trick will be to use a type family to inspect  RepN (b f) and distinguish recursive usages from non-recursive ones, tagging them with different types, so we can distinguish them in the instances.UbarbiesU B f g" is in practice a predicate about BK only. Intuitively, it says that the following holds, for any arbitrary f:There is an instance of š (B f).B f can contain fields of type b f" as long as there exists a Z b. instance. In particular, recursive usages of B f are allowed.Wbarbies;The representation used for the generic computation of the [ c b constraints. Here V: is an arbitrary constant since the actual argument to b is irrelevant.Ybarbies Similar to [# but will put the functor argument f between the constraint c and the type a. For example:  [ ˆ Barbie ~ (ˆ , ˆ ‰) Y ˆ f Barbie ~ (ˆ (f ), ˆ (f ‰)) Zbarbies`Instances of this class provide means to talk about constraints, both at compile-time, using [%, and at run-time, in the form of , via \.)A manual definition would look like this: data T f = A (f ‰) (f  ) | B (f Š) (f ‰ ) instance Z T where type [ c T = (c ‰, c , c Š) \ t = case t of A x y -> A (  x) (  y) B z w -> B (  z) (  w) Now if we given a T f, we need to use the ˆ' instance of their fields, we can use: \ :: AllB Show b => b f -> b ( ˆ Œ b) %There is a default implementation of Z for š* types, so in practice one will simply do: derive instance š (T f) instance Z T [barbies[ c b should contain a constraint c a for each a occurring under an f in b f. E.g.: [ ˆ Barbie ~ (ˆ , ˆ ‰) &For requiring constraints of the form c (f a), use Y.^barbiesDefault implementation of \ based on š.NOPQRSTUVWXYZ[\]^None,-.1278=>?@AHSUVX_fk³Øbbarbies-Every type that admits a generic instance of B and Z, has a generic instance of c as well.cbarbies Every type b that is an instance of both B and Z can be made an instance of c as well.Intuitively, in addition to D from B, one can define e% that takes into account constraints: D :: (forall a . f a) -> b f e :: [' c b => (forall a . c a => f a) -> b f For technical reasons, eY is not currently provided as a method of this class and is instead defined in terms d, which is similar to \> but can produce the instance dictionaries out-of-the-blue. d% could also be defined in terms of e%, so they are essentially equivalent. d :: forall c b . [ c b => b ( c) d = e ( @c) &There is a default implementation for š0 types, so instances can derived automatically.ebarbiesLike DB but a constraint is allowed to be required on each element of b.fbarbies Builds a b f, by applying   on every field of b.hbarbiesDefault implementation of g based on š. T_`abcdefghNone,-.1278=>?@AHSUVX_fk¶ibarbies A barbie type without structure.kbarbiesUninhabited barbie type.ijkNone,-.1278=>?@AHMSUVX_fk¸lbarbies7A wrapper for Barbie-types, providing useful instances.lmnNone,.1278=>?@AHSUVX_fk¸ÿXYZ[\]acdZ[\cdYX]aNone,.1278=>?@AHSUVX_fkÁÍrbarbiesXAll types that admit a generic FunctorB' instance, and have all their occurrences of f under a  admit a generic s instance.sbarbies$Class of Barbie-types defined using  and can therefore have  versions. Must satisfy: u . t = ÿ t . u = ÿ vbarbiesGeneralization of t to arbitrary functorswbarbiesGeneralization of u to arbitrary functorsxbarbiesDefault implementation of t based on š.ybarbiesDefault implementation of t based on š.opqrstuvwxyNone,.1278=>?@AHSUVX_fkÂÜstuvwstuvwNone,.1278=>?@AHSUVX_fkÃò()*+,-./03456=>?@ALMNOPQRSTUVW^_`bhopqrxy(3./0=456ML>?@A^QRUSTWVNPOh_`byxopqr)+,-*None,.1278=>?@AHSUVX_fkÆ'+,-12789:;<BDCEFGHIJKXYZ[\]acdefgijklmn'12789<:;BDCEFGHIJKZ[\Ycdeflmnkij+,-X]agNone,.1278=>?@AHSUVX_fkȼzbarbiesWrapper for container-Barbies.z{|z{|  !"#$%&'()*+,-./0123456789:;<=>?@ A B C C D E F  G H I J K L M N O P Q R STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~##€€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š˜›œ˜žŸ ¡Ÿ ¢Ÿ £˜¤¥˜¦§˜¨©Ÿª«˜¨¬Ÿª­˜¨®˜¯°˜±²˜™³˜™´˜™µ ¶ ·˜¸¹˜¸º˜¸»˜¸¼˜¸½˜¸¾˜¸¿˜¸À˜¸Á˜¸Â˜¸Ã˜¸Ä˜¸Å˜¸Ƙ¸Ç˜¸È˜¸É˜¸ʘ¸Ë˜¸Ì˜¸Í˜¸Î˜¸Ϙ¸И¸И¸ј¸ј¸Ò˜¸Ó˜¸Ó˜¸Ô˜¸Õ˜¸Õ˜¸Ö˜¸ט¸ט¸Ø˜¸Ù˜¸Ú˜¸Û˜¸ܘ¸ܘ¸ݘ¸Þ˜¸ß˜¸à˜¸ᘸ☸㘸䘸嘸昸瘸蘸阸꘸똸옸호ð˜¸ñ˜¸ò˜¸ó˜¸ô˜¸阸꘸똸옸호õ˜¸ö˜¸÷˜¸ø˜¸ù˜¸ú˜¸û˜¸ü˜¸ý˜¸þ˜¸ÿ˜¸˜¸˜¸˜¸˜¸˜¸˜¸˜¸˜¸˜¸ ˜¸ ˜¸ ˜¸ ˜¸ ˜¸˜¸  ˜™˜˜™˜˜¤˜¦˜¦˜™˜™˜˜˜™ &barbies-1.1.0.0-HhbW1brroXP4iVFS1SXZq9Data.Barbie.ConstraintsData.Barbie.BareData.Functor.ProdData.Barbie.Internal Data.BarbieData.Barbie.ContainerData.Barbie.Internal.DictsData.Barbie.Internal.WearData.Generics.GenericNData.Barbie.Internal.Functor Data.Barbie.Internal.TraversableCanDeriveFunctorB Data.FunctorIdentityData.Barbie.Internal.Product Data.ListzipWithzipWith3zipWith4 Data.Barbie.Internal.ConstraintsData.Barbie.Internal.ProductCData.Barbie.TrivialData.Barbie.Internal.InstancesData.Barbie.Internal.BareClassFGClassFDict requiringDictWearCoveredBareCurried++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$fFunctorProd0GenericNRepNRecunRec GFunctorBgbmapFunctorBbmap gbmapDefault GTraversableB gbtraverseCanDeriveTraversableB TraversableB btraverse btraverse_ bsequence bsequence'bfoldMapgbtraverseDefault GProductBgbprodgbuniqCanDeriveProductBProductBbprodbuniqbzipbunzipbzipWith bzipWith3 bzipWith4/*//* gbprodDefault gbuniqDefaultTagSelfOtherSelf GConstraintsB gbaddDictsGAllBCGAllBCanDeriveConstraintsBXGAllBRep ConstraintsOfAllBF ConstraintsBAllB baddDictsadjProofgbaddDictsDefault GProductBCgbdictsProofBCanDeriveProductBC ProductBCbdictsbuniqCbmemptybproofgbdictsDefaultVoidBarbie getBarbieGBareBgbstripgbcoverCanDeriveBareBBareBbstripbcover bstripFrom bcoverWithgbstripDefaultgbcoverDefault Container getContainer$fApplicativeContainer$fTraversableContainer$fFoldableContainer$fFunctorContainer$fGenericContainer$fShowContainer$fReadContainer$fOrdContainer $fEqContainerbaseGHC.BaseMonoid GHC.MaybeMaybeGHC.ShowShowghc-prim GHC.TypesIntBoolTrueData.Functor.ProductProduct Data.TupleuncurryData.Functor.ClassesShow1 GHC.ClassesOrdOrd1EqEq1Data.Traversable Traversable Data.FoldableFoldable Alternative ApplicativeFunctor SameOrParamParam GHC.GenericsGenericRepfromtoGeneric1Rep1from1to1Datatype datatypeName moduleName packageName isNewtype ConstructorconName conFixity conIsRecordSelectorselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUAddrUCharUDoubleUFloatUIntUWorduWord#uInt#uFloat#uDouble#uChar#uAddr#precFixityPrefixInfixFixityIPrefixIInfixI AssociativityLeftAssociativeRightAssociativeNotAssociativeSourceUnpackedness SourceUnpackSourceNoUnpackNoSourceUnpackednessSourceStrictness SourceLazy SourceStrictNoSourceStrictnessDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackMetaMetaDataMetaConsMetaSeltoNfromNidData.Functor.ComposeComposefmapData.Functor.IdentityPairfstsndStringconstGHC.Listzipunzipmempty