úÎ!ßXÐŒˆ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡Safe&',-.1278=>?@AHSUVX_fkbarbiesLike  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_fkbarbiesThe 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`26barbies6 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~€ 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.]barbiesLike 2B but a constraint is allowed to be required on each element of bE.g. If all fields of b are Š@able then you could store each shown value in it's slot using  : æshowFields :: (AllB Show b, ConstraintsB b) => b Identity -> b (Const String) showFields = bmapC @Show showField where showField :: forall a. Show a => Identity a -> Const String a showField (Identity a) = Const (show a)^barbiesLike 8* but with a constraint on the elements of b.`barbiesDefault implementation of \ based on œ.NOPQRSTUVWXYZ[\]^_`None,-.1278=>?@AHSUVX_fk»ldbarbies-Every type that admits a generic instance of B and Z, has a generic instance of e as well.ebarbies Every type b that is an instance of both B and Z can be made an instance of e as well.Intuitively, in addition to D from B, one can define g% that takes into account constraints: D :: (forall a . f a) -> b f g :: [' c b => (forall a . c a => f a) -> b f For technical reasons, gY is not currently provided as a method of this class and is instead defined in terms f, which is similar to \> but can produce the instance dictionaries out-of-the-blue. f% could also be defined in terms of g%, so they are essentially equivalent. f :: forall c b . [ c b => b ( c) f = g ( @c) &There is a default implementation for œ0 types, so instances can derived automatically.gbarbiesLike DB but a constraint is allowed to be required on each element of b.hbarbies Builds a b f, by applying   on every field of b.jbarbiesDefault implementation of i based on œ. TabcdefghijNone,-.1278=>?@AHSUVX_fk½£kbarbies A barbie type without structure.mbarbiesUninhabited barbie type.klmNone,-.1278=>?@AHMSUVX_fk¿°nbarbies7A wrapper for Barbie-types, providing useful instances.nopNone,.1278=>?@AHSUVX_fkÀ“XYZ[\]^_cefZ[\ef]^YX_cNone,.1278=>?@AHSUVX_fkÉqtbarbiesXAll types that admit a generic FunctorB' instance, and have all their occurrences of f under a  admit a generic u instance.ubarbies$Class of Barbie-types defined using  and can therefore have  versions. Must satisfy: w . v =  v . w =  xbarbiesGeneralization of v to arbitrary functorsybarbiesGeneralization of w to arbitrary functorszbarbiesDefault implementation of v based on œ.{barbiesDefault implementation of v based on œ.qrstuvwxyz{None,.1278=>?@AHSUVX_fkÊ€uvwxyuvwxyNone,.1278=>?@AHSUVX_fkË–()*+,-./03456=>?@ALMNOPQRSTUVW`abdjqrstz{(3./0=456ML>?@A`QRUSTWVNPOjabd{zqrst)+,-*None,.1278=>?@AHSUVX_fkͬ)+,-12789:;<BDCEFGHIJKXYZ[\]^_cefghiklmnop)12789<:;BDCEFGHIJKZ[\Y]^efghnopmkl+,-X_ciNone,.1278=>?@AHSUVX_fkÐp|barbiesWrapper for container-Barbies.|}~|}~ !"#$%&'()*+,-./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.3.0-CMVVqlu4ofTCwkhij0xzhpData.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 baddDictsbmapC btraverseCadjProofgbaddDictsDefault 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.ListzipunzipData.Functor.ConstConstmempty