úÎ!µÜ¡|Û      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅ Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú & Safe&',-.1245678=>?@AHSUVX_fk2barbiesLike  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 ->    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',.1245678=>?@AHSUVX_fk=ÞßàSafe&',-.1245678=>?@AHSUVX_fk7Þ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',-./1245678=>?@AHSUVX_fk:ríîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO&'()*+,-./01234None',.1245678=>?@AHSUVX_fkC5barbiesThe 54 type-function allows one to define a Barbie-type as data B t f = B { f1 :: 5 t f P , f2 :: 5 t f Q } .This gives rise to two rather different types:B 6 f1 is a normal Barbie-type, in the sense that f1 :: B 6 f -> f P, etc.B 7 fM, on the other hand, is a normal record with no functor around the type: B { f1 :: 5, f2 = R } :: B 7 f 567None',-.1245678=>?@AHSUVX_fkD89None',-.1245678=>?@AHSUVX_fkE':;None',-.1245678=>?@AHSUVX_fkQÔ<barbies< T f g x" is in practice a predicate about TK only. Intuitively, it says that the following holds, for any arbitrary f:There is an instance of í (T f).T f x can contain fields of type t f y" as long as there exists a = t. instance. In particular, recursive usages of T f y are allowed.T f x can also contain usages of t f y under a ì h$. For example, one could use Ü (T f y) when defining T f y.=barbies:Functor from indexed-types to indexed-types. Instances of =& should satisfy the following laws: > S = S > f . > g = > (f . g) There is a default > implementation for í0 types, so instances can derived automatically.TbarbiesDefault implementation of > based on í.<=>TNone',-.1245678=>?@AHSUVX_fkeº?barbies? T f g x" is in practice a predicate about T only. It is analogous to I, so it essentially requires the following to hold, for any arbitrary f:There is an instance of í (T f x).T f x can contain fields of type t f x" as long as there exists a @ t. instance. In particular, recursive usages of T f x are allowed.T f x can also contain usages of t f x under a è h$. For example, one could use Ü (T f x) when defining T f x.@barbiesjIndexed-functors that can be traversed from left to right. Instances should satisfy the following laws:  t . A f = A (t . f) -- naturality A  =  -- identity A (U . V g . f) = U . V (A g) . A f -- composition There is a default A implementation for í0 types, so instances can derived automatically.BbarbiesdMap each element to an action, evaluate these actions from left to right, and ignore the results.CbarbiesUEvaluate each action in the structure from left to right, and collect the results.Dbarbies A version of C with f specialized to W.Ebarbies6Map each element to a monoid, and combine the results.XbarbiesDefault implementation of A based on í.?@ABCDEXNone',-.1245678=>?@AHSUVX_fky´FbarbiesiSome endo-functors on indexed-types are monads. Common examples would be "functor-transformers", like U or Y. In that sense, F is similar to , but with additional structure (see also  *https://hackage.haskell.org.package/mmorphmmorph's MMonad class).Notice though that while  assumes a Z% instance of the value to be lifted, G† has no such constraint. This means we cannot have instances for most "monad transformers", since lifting typically involves an V.F- also corresponds to the indexed-monad of  ;https://personal.cis.strath.ac.uk/conor.mcbride/Kleisli.pdf$Kleisli arrows of outrageous fortune.eInstances of this class should to satisfy the monad laws. They laws can stated either in terms of (G, H) or (G, I). In the former: > h . G = G . h > h . H = H . > (> h) H . G = S H . 'tmap tlift' = S H . H = H . > H In the latter: I f . G = f I G = S I f . I g = I (I f . g) Gbarbies(Lift a functor to a transformed functor.Hbarbies”The conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.Ibarbies Analogous to ().FGHINone',-.1245678=>?@AHSUVX_fk†JbarbiesJ 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 K 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.Kbarbies3Barbie-types that can be mapped over. Instances of K& should satisfy the following laws: L S = S L f . L g = L (f . g) There is a default L implementation for í0 types, so instances can derived automatically.MbarbiesDefault implementation of L based on í.JKLMNone',-.1245678=>?@AHSUVX_fk™‹NbarbiesN 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 O 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.ObarbiesfBarbie-types that can be traversed from left to right. Instances should satisfy the following laws:  t . P f = P (t . f) -- naturality P  =  -- identity P (U . V g . f) = U . V (P g) . P f -- composition There is a default P implementation for í0 types, so instances can derived automatically.QbarbiesdMap each element to an action, evaluate these actions from left to right, and ignore the results.RbarbiesUEvaluate each action in the structure from left to right, and collect the results.Sbarbies A version of R with f specialized to W.Tbarbies6Map each element to a monoid, and combine the results.UbarbiesDefault implementation of P based on í.NOPQRSTU None',-.1245678=>?@AHSUVX_fkšºVW!None',-.1245678=>?@AHSUVX_fk½ÝXbarbiesX T f g x" is in practice a predicate about TJ only. Intuitively, it says the the following holds for any arbitrary f:There is an instance of í (B f x).(B f x)^ has only one constructor, and doesn't contain "naked" fields (that is, not covered by f). In particular, x needs to occur under f.B f x can contain fields of type b f y" as long as there exists a Y b. instance. In particular, recursive usages of B f x are allowed.B f x can also contain usages of b f y under a [ h$. For example, one could use  a -> (B f x) as a field of B f x.YbarbiesA =7 where the effects can be distributed to the fields: Z’ turns an effectful way of building a transformer-type into a pure transformer-type with effectful ways of computing the values of its fields.&This class is the categorical dual of " , with Z the dual of # and \ the dual of $2. As such, instances need to satisfy these laws: Z . h = > (U . h . \) . Z -- naturality Z .  = > (U . ) -- identity Z . U = V (U . U . V \ . \) . Z . V ] -- composition By specializing f to ((->) a) and g to W{, we can define a function that decomposes a function on distributive transformers into a collection of simpler functions: ] :: Y b => (a -> b W) -> b ((->) a) ] = > (V ^ . \) . Z NLawful instances of the class can then be characterized as those that satisfy: ^ . ] = S ] . ^ = S ÚThis means intuitively that instances need to have a fixed shape (i.e. no sum-types can be involved). Typically, this means record types, as long as they don't contain fields where the functor argument is not applied.%There is a default implementation of Z based on í‹. Intuitively, it works on product types where the shape of a pure value is uniquely defined and every field is covered by the argument f.[barbies A version of Z with g specialized to W.\barbiesDual of $]barbieseDecompose a function returning a distributive transformer, into a collection of simpler functions.^barbies Recompose a decomposed function._barbiesDefault implementation of Z based on í.XYZ[\]^_%None',-.1245678=>?@AHSUVX_fkß¾_barbies_ B f g" is in practice a predicate about BJ only. Intuitively, it says the the following holds for any arbitrary f:There is an instance of í (B f).(B f)^ has only one constructor, and doesn't contain "naked" fields (that is, not covered by f).B f can contain fields of type b f" as long as there exists a ` 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  a -> (B f) as a field of B f.`barbiesA K7 where the effects can be distributed to the fields: aˆ turns an effectful way of building a Barbie-type into a pure Barbie-type with effectful ways of computing the values of its fields.&This class is the categorical dual of & , with a the dual of ' and c the dual of (2. As such, instances need to satisfy these laws: a . h = L (U . h . \) . a -- naturality a .  = L (U . ) -- identity a . U = L (U . U . V \ . \) . a . V a -- composition By specializing f to ((->) a) and g to Wv, we can define a function that decomposes a function on distributive barbies into a collection of simpler functions: d :: ` b => (a -> b W) -> b ((->) a) d = L (V ^ . \) . a NLawful instances of the class can then be characterized as those that satisfy: e . d = S d . e = S ÚThis means intuitively that instances need to have a fixed shape (i.e. no sum-types can be involved). Typically, this means record types, as long as they don't contain fields where the functor argument is not applied.%There is a default implementation of a based on í‹. Intuitively, it works on product types where the shape of a pure value is uniquely defined and every field is covered by the argument f.bbarbies A version of a with g specialized to W.cbarbiesDual of (dbarbies`Decompose a function returning a distributive barbie, into a collection of simpler functions.ebarbies Recompose a decomposed function.fbarbiesDefault implementation of a based on í._`abcdef)None',-.1245678=>?@AHSUVX_fkêÁhbarbies0We use the type-families to generically compute * c b. Intuitively, if b' f occurs inside b f, then we should just add * b' c to * 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 () instead of * b fN to break the recursion. Our trick will be to use a type family to inspect + (b f) and distinguish recursive usages from non-recursive ones, tagging them with different types, so we can distinguish them in the instances. ghijklmno+None',-.1245678=>?@AHSUVX_fkëôpqr,None',-.1245678=>?@AHSUVX_fkôlsbarbiesAll types that admit a generic K0 instance, and have all their occurrences of f under a 5 admit a generic t instance.tbarbies$Class of Barbie-types defined using 5 and can therefore have 7 versions. Must satisfy: v . u = S u . v = S wbarbiesGeneralization of u to arbitrary functorsxbarbiesGeneralization of v to arbitrary functorsybarbiesDefault implementation of u based on í.zbarbiesDefault implementation of u based on í. 567stuvwxyzNone',.1245678=>?@AHSUVX_fkõ567tuvwx576tuvwx-None',.1245678=>?@AHSUVX_fköÅ567tuvwx576tuvwx.None',-.1245678=>?@AHSUVX_fkø{|}/None',-.1245678=>?@AHSUVX_fkqþ~barbies~ T f g x" is in practice a predicate about TK only. Intuitively, it says that the following holds, for any arbitrary f:There is an instance of í (T f).T: has only one constructor (that is, it is not a sum-type).Every field of T f x$ is either a monoid, or of the form f a, for some type a.barbiesA =+ with application, providing operations to:embed an "empty" value (€)align and combine values ()%It should satisfy the following laws: Naturality of  > ((` a b) -> ` (f a) (g b)) (u `tprod' v) = > f u `tprod' > g v  Left and right identity > ((` _ b) -> b) (€ e `tprod' v) = v > ((` a _) -> a) (u `tprod' € e) = u   Associativity > ((` a (` b c)) -> ` (` a b) c) (u `tprod' (v `tprod' w)) = (u `tprod' v) `tprod' w  It is to = in the same way is ë relates to ì. For a presentation of ë- as a monoidal functor, see Section 7 of  7http://www.soi.city.ac.uk/~ross/papers/Applicative.html$Applicative Programming with Effects.%There is a default implementation of  and € based on í5. Intuitively, it works on types where the value of €€ is uniquely defined. This corresponds rougly to record types (in the presence of sums, there would be several candidates for €!), where every field is either a Û or covered by the argument f.‚barbies An alias of .ƒbarbiesAn equivalent of a.„barbiesAn equivalent of 01.…barbiesAn equivalent of 02.†barbiesAn equivalent of 03.bbarbiesDefault implementation of  based on í. ~€‚ƒ„…†bc4None',-.1245678=>?@AHSUVX_fk3Ó‡barbies;The representation used for the generic computation of the ‹ c t constraints. Here l and k9 are arbitrary constants since the actual argument to t is irrelevant.ˆbarbiesˆ T f g x" is in practice a predicate about TK only. Intuitively, it says that the following holds, for any arbitrary f and x:There is an instance of í (T f x).T f can contain fields of type t f x" as long as there exists a Š t. instance. In particular, recursive usages of T f x are allowed.‰barbies Similar to ‹# but will put the functor argument f between the constraint c and the type a.Šbarbies`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 = A (f P) (f d ) | B (f Q) (f P ) instance Š T where type ‹ c T = (c P, c d, c Q) Œ t = case t of A x y -> A (`  x) (`  y) B z w -> B (`  z) (`  w) Now, when we given a T f, if we need to use the Ý' instance of their fields, we can use: Œ :: AllT Show t => t f -> t ( Ý `Product' f) %There is a default implementation of Š for í* types, so in practice one will simply do: derive instance í (T f a) instance Š T ‹barbies‹ c t should contain a constraint c a for each a occurring under an f in t f.&For requiring constraints of the form c (f a), use ‰.barbiesLike >B but a constraint is allowed to be required on each element of t.ŽbarbiesLike A* but with a constraint on the elements of t.ebarbiesLike 5' but with a constraint on the function.fbarbiesLike 6* but with a constraint on the elements of t.gbarbiesLike 7* but with a constraint on the elements of t.hbarbiesLike 8* but with a constraint on the elements of t.ibarbies Similar to Œ@ but can produce the instance dictionaries "out of the blue".jbarbiesLike €B but a constraint is allowed to be required on each element of t.kbarbies Builds a t f x, by applying l on every field of t.mbarbies/Default implementation of ibaddDicts' based on í.‡ˆ‰Š‹ŒŽefghijkmNone',.1245678=>?@AHSUVX_fk5 #/01=>@ABCDEFGHIYZ[\]^€‚ƒ„…†‰Š‹ŒŽ#=>@ABECDYZ[\]^€‚ƒ„…†FGHIŠ‹Œ‰Ž/019None',-.1245678=>?@AHSUVX_fkO=barbies 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 either a monoid, or of the form f a, for some type a.barbiesA K+ with application, providing operations to:embed an "empty" value (‘)align and combine values (’)%It should satisfy the following laws: Naturality of ’ L ((` a b) -> ` (f a) (g b)) (u `bprod' v) = L f u `bprod' L g v  Left and right identity L ((` _ b) -> b) (‘ e `bprod' v) = v L ((` a _) -> a) (u `bprod' ‘ e) = u   Associativity L ((` a (` b c)) -> ` (` a b) c) (u `bprod' (v `bprod' w)) = (u `bprod' v) `bprod' w  It is to K in the same way as ë relates to ì. For a presentation of ë- as a monoidal functor, see Section 7 of  7http://www.soi.city.ac.uk/~ross/papers/Applicative.html$Applicative Programming with Effects.%There is a default implementation of ’ and ‘ based on í5. Intuitively, it works on types where the value of ‘€ is uniquely defined. This corresponds rougly to record types (in the presence of sums, there would be several candidates for ‘!), where every field is either a Û or covered by the argument f.“barbies An alias of ’, since this is like a n.”barbiesAn equivalent of a.•barbiesAn equivalent of 01.–barbiesAn equivalent of 02.—barbiesAn equivalent of 03.˜barbiesDefault implementation of ’ based on í. ‘’“”•–—˜™:None',-.1245678=>?@AHSUVX_fkwðšbarbies;The representation used for the generic computation of the ž c b constraints. Here l: is an arbitrary constant since the actual argument to b is irrelevant.›barbies› 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  b. instance. In particular, recursive usages of B f are allowed.œbarbies Similar to ž# but will put the functor argument f between the constraint c and the type a. For example:  ž Ý Person ~ (Ý d, Ý P) œ Ý f Person ~ (Ý (f d), Ý (f P)) barbies`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 P) (f d ) | B (f Q) (f P ) instance  T where type ž c T = (c P, c d, c Q) Ÿ t = case t of A x y -> A (`  x) (`  y) B z w -> B (`  z) (`  w) Now, when we given a T f, if we need to use the Ý' instance of their fields, we can use: Ÿ :: AllB Show b => b f -> b ( Ý `Product' f) %There is a default implementation of  for í* types, so in practice one will simply do: derive instance í (T f) instance  T žbarbiesž c b should contain a constraint c a for each a occurring under an f in b f. E.g.: ž Ý Person ~ (Ý d, Ý P) &For requiring constraints of the form c (f a), use œ. barbiesLike LB 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 o: æ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 P* but with a constraint on the elements of b.£barbiesLike ;* but with a constraint on the elements of b.¤barbiesLike <* but with a constraint on the elements of b.¥barbiesLike =* but with a constraint on the elements of b.¦barbies Similar to Ÿ@ but can produce the instance dictionaries "out of the blue".§barbiesLike ‘B but a constraint is allowed to be required on each element of b.¨barbies Builds a b f, by applying l on every field of b.©barbiesDefault implementation of Ÿ based on í.š›œžŸ ¡¢£¤¥¦§¨©None',.1245678=>?@AHSUVX_fky'&/01KLOPQRST`abcde‘’“”•–—œžŸ ¡¢£¤¥¦§¨&KLOPQTRS`abcde‘’“”•–—žŸœ¦ ¢¡§£¤¥¨/01>None',.1245678=>?@AHSUVX_fk}ܪbarbies.Wrapper for barbies that act as containers of e by wearing p e.­barbies.Wrapper for barbies that act as containers of a by wearing (o a).ª«¬­®¯?None',-.1245678=>?@AHMSUVX_fk€°barbies7A wrapper for Barbie-types, providing useful instances.°±²@None',-.1245678=>?@AHSUVX_fk‚L³barbies A barbie type without structure.µbarbiesUninhabited barbie type.³´µANone',-.1245678=>?@AHSUVX_fk„CqbarbiesDefault implementation of » based on í. ¶·¸¹º¼»qrBNone',-.1245678=>?@AHSUVX_fk†RsbarbiesDefault implementation of Á based on í.m½¾¿ÀÁÂsNone',.1245678=>?@AHSUVX_fk‡i œžŸ ¡ÀÁ žŸÀÁ ¡œNone',.1245678=>?@AHSUVX_fkQÃbarbiesLike », but returns a binary  , instead of á, which composes better.See à for usage.Äbarbies Similar to Ã# but one of the sides is already a  fs. Note that Ä, à and C# 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 C on an n-ary function. E.g. f :: f a -> g a -> h a -> i a L (C f) (bf Ä bg à bh) ,/01KLOPQRST“”•–—œžŸ ¡¨°±²³´µ¶·¸¹º¼»½¾¿ÀÁÂÃÄ,KLOPQTRSº¼»¹“”•–—žŸœ ¡ÀÁ¿Â¨°±²µ³´/01¶·¸½¾ÃÄÃ4Ä4 None',-.1245678=>?@AHSUVX_fkq™"Åbarbies Convert a K into a = and vice-versa.Èbarbies)Map over both arguments at the same time.Ébarbies A version of È" specialized to a single argument.Êbarbies)Traverse over both arguments, first over f , then over g..Ëbarbies A version of Ê" specialized to a single argument.Ìbarbies0Conceptually, this is like simultaneously using ‘ and €.Íbarbies A version of Ì" specialized to a single argument.Îbarbies'Simultaneous product on both arguments. ÅÆÇÈÉÊËÌÍÎ ÈÉÊËÌÍÎÅÆÇNone',.1245678=>?@AHSUVX_fkšh\/01=>@ABCDEFGHIKLOPQRSTYZ[\]^`abcde€‚ƒ„…†‰Š‹ŒŽ‘’“”•–—œžŸ ¡¢£¤¥¦§¨ª«¬­®¯°±²³´µÅÆÇÈÉÊËÌÍÎ ­®¯ª«¬°±²µ³´DNone',.1245678=>?@AHSUVX_fkœþœœNone',.1245678=>?@AHSUVX_fkž$œíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO&'()*+,-./0123489:;<?JMNUVWX_fghijklmnopqrsyz{|}~‡ˆ˜™š›©9M:;J<U89N?fVW_X™˜{|}~©no›ˆmš‡lkhgjizypqrs432./01*+,-&'()t E F G G HIJKLMNOPQRCSTUVWXYZ[\]^_`abcdefghijklmnopqrrstuvwxyz{|}~€"$#‚5ƒ„…†‡ˆ‰Š&(‹'ŒŽ  !‘!’!“!”!•!–!—%˜%™%š%›%œ%%ž%Ÿ) )¡)¢)£)¤)¥)¦)§)¨+©+ª+«,¬,­,®,¯,°,±,²,³.´.µ.¶/·/¸/¹/º/»/¼/6/7/84½4¾4¿4À4Á4Â4Ã4Ä9Å9Æ9Ç9È9É9Ê9;9<9=9Ë9Ì:Í:Î:Ï:Ð:*:Ñ:Ò:Ó:Ô:Õ:Ö:×:Ø:Ù:Ú:Û>Ü>Ü>Ý>Þ>Þ>ß?à?à?á@L@L@âAãAäAåAæAçAÈAèBéBêBëBìBØBíîï ð ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ           !"#"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":":";";"<"="=">"?"?"@"A"A"B"C"D"E"F"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"S"T"U"V"W"X"_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"yz{z|z}~€‚ƒ„…†‡ˆ‰Š‹€Œ‰ŠƒŽ!‘’/“/”•4–4—4˜4™4š4›4œ4ž‘Ÿ ¡¢£AËA¤B¥¦&barbies-2.0.1.0-GWezepPC8vC6io1tXMWHwHData.Barbie.ConstraintsData.Functor.ProdBarbies.InternalData.Functor.Transformer Barbies.BareData.Functor.BarbieBarbies Data.Barbie Barbies.BiBarbies.Internal.Dicts Data.Kind ConstraintBarbies.Internal.WriterData.Generics.GenericNBarbies.Internal.WearBarbies.Generics.TraversableBarbies.Generics.FunctorBarbies.Internal.FunctorTBarbies.Internal.TraversableTCanDeriveFunctorT Data.FunctorIdentityBarbies.Internal.MonadTControl.Monad.Trans.Class MonadTranslift Control.Monad=<<Barbies.Internal.FunctorBBarbies.Internal.TraversableBCanDeriveFunctorBBarbies.Generics.DistributiveBarbies.Internal.DistributiveT TraversableT tsequence ttraverseBarbies.Internal.DistributiveB TraversableB bsequence btraverseBarbies.Generics.ConstraintsAllBBarbies.Generics.BareBarbies.Internal.BareBData.Barbie.BareBarbies.Generics.ApplicativeBarbies.Internal.ApplicativeT Data.ListzipWithzipWith3zipWith4Barbies.Internal.ConstraintsTtfoldMaptzipWith tzipWith3 tzipWith4Barbies.Internal.ApplicativeBBarbies.Internal.ConstraintsBbzipWith bzipWith3 bzipWith4Barbies.Internal.ContainersBarbies.Internal.WrappersBarbies.Internal.TrivialData.Barbie.Internal.ProductData.Barbie.Internal.ProductCuncurrynBarbies.ConstraintsClassFGClassFDict requiringDictCurried++ProdUnitCons zeroTupleoneTuple fromProduct toProductprod $fShowProd $fShowProd0 $fShow1Prod $fShow1Prod0 $fOrdProd $fOrdProd0 $fOrd1Prod $fOrd1Prod0$fEqProd $fEqProd0 $fEq1Prod $fEq1Prod0$fTraversableProd$fTraversableProd0$fFoldableProd$fFoldableProd0$fAlternativeProd$fAlternativeProd0$fApplicativeProd$fApplicativeProd0 $fFunctorProd$fFunctorProd0GenericPRepPtoPfromPGenericNRepNtoNfromNZipRecunRec FilterIndexIndexedParamWearCoveredBare GTraversable gtraverseGFunctorgmapFunctorTtmapCanDeriveTraversableT ttraverse_ tsequence'MonadTtlifttjointembedFunctorBbmap gbmapDefaultCanDeriveTraversableB btraverse_ bsequence'bfoldMapgbtraverseDefault GDistributive gdistributeCanDeriveDistributiveT DistributiveT tdistribute tdistribute' tcotraverse tdecompose trecomposeCanDeriveDistributiveB DistributiveB bdistribute bdistribute' bcotraverse bdecompose brecomposegbdistributeDefaultTagSelf'TagSelfOtherSelfYXGAll GConstraints gaddDictsGBaregstripgcoverCanDeriveBareBBareBbstripbcover bstripFrom bcoverWithgbstripDefaultgbcoverDefault GApplicativegprodgpureCanDeriveApplicativeT ApplicativeTtpuretprodtziptunzipGAllRepTCanDeriveConstraintsTAllTF ConstraintsTAllT taddDictstmapC ttraverseCCanDeriveApplicativeB ApplicativeBbpurebprodbzipbunzip gbprodDefault gbpureDefaultGAllRepBCanDeriveConstraintsBAllBF ConstraintsB baddDictsbmapC btraverseC bfoldMapC bzipWithC bzipWith3C bzipWith4CbdictsbpureCbmemptygbaddDictsDefaultErrorContainergetErrorContainer Container getContainerBarbie getBarbieVoid GProductBgbprodgbuniqCanDeriveProductBProductBbuniq GProductBCgbdictsCanDeriveProductBC ProductBCbuniqC/*//*FliprunFlipbtmapbtmap1 bttraverse bttraverse1btpurebtpure1btprod$fApplicativeTkk'Flip$fTraversableTkk'Flip$fDistributiveTiFlip$fFunctorTkk'Flip$fApplicativeBkFlip$fTraversableBkFlip$fDistributiveBTYPEFlip$fFunctorBkFlip$fEqFlip $fOrdFlip $fReadFlip $fShowFlipbaseGHC.BaseMonoid GHC.MaybeMaybeGHC.ShowShowWrexecWrtellData.Functor.ProductProduct Data.TupleuncurryData.Functor.ClassesShow1ghc-prim GHC.ClassesOrdOrd1EqEq1Data.Traversable Traversable Data.FoldableFoldable Alternative ApplicativeFunctor GHC.GenericsGenericRepfromtoGeneric1Rep1from1to1Datatype datatypeName moduleName packageName isNewtype ConstructorconName conFixity conIsRecordSelectorselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUAddrUCharUDoubleUFloatUIntUWorduWord#uInt#uFloat#uDouble#uChar#uAddr#precFixityPrefixInfixFixityIPrefixIInfixI AssociativityLeftAssociativeRightAssociativeNotAssociativeSourceUnpackedness SourceUnpackSourceNoUnpackNoSourceUnpackednessSourceStrictness SourceLazy SourceStrictNoSourceStrictnessDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackMetaMetaDataMetaConsMetaSel GHC.TypesIntBoolTrueid gtmapDefaultData.Functor.ComposeComposefmapData.Functor.IdentityttraverseDefaulttransformers-0.5.5.0Control.Monad.Trans.ReaderReaderTMonad)distributive-0.6.2-9LgT9uHZr8B4Dxk4MvZJQvData.Distributive Distributive getCompose distribute runIdentitygtdistributeDefaultPairGHC.Listunzip gtprodDefault gtpureDefaultString tfoldMapC tzipWithC tzipWith3C tzipWith4CtdictstpureCtmemptymemptygtaddDictsDefaultzipData.Functor.ConstConst Data.EitherEither gbuniqDefaultgbdictsDefault