úÎ!Á—­)Ü      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û & Safe&',-.1245678=>?@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 ->    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_fkJßàá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:;<=>?@ABCDEFGHIJKLMNOP&'()*+,-./01234None',.1245678=>?@AHSUVX_fkN¢5barbies Like the 6 family, but with two wrappers f and g? instead of one. This is useful if you have a data-type where f is parametric but g is not, consider this: data T t f = T { f1 :: 6 t f [Bool] , f2 :: 6 t f (Sum Int) , f3 :: 5 t f Sum Int , f4 :: 5 t f Max Int } with x :: T Covered Option we would have uf1 x :: IO (Option [Bool]) f2 x :: IO (Option (Sum Int)) f3 x :: IO (Option (Sum Int)) f4 x :: IO (Option (Max Int))  and with y :: T Bare Identity we would have 4f1 y :: Int f2 y :: Sum Int f3 y :: Int f4 y :: Int  Note how (Option (Sum Int)) (or MaxX) has a nice Semigroup instance that we can use to merge two (covered) barbies, while 5) removes the wrapper for the bare barbie.6barbiesThe 64 type-function allows one to define a Barbie-type as data B t f = B { f1 :: 6 t f Q , f2 :: 6 t f R } .This gives rise to two rather different types:B 7 f1 is a normal Barbie-type, in the sense that f1 :: B 7 f -> f Q, etc.B 8 fM, on the other hand, is a normal record with no functor around the type: B { f1 :: 5, f2 = S } :: B 8 f 5678None',-.1245678=>?@AHSUVX_fkO±9:None',-.1245678=>?@AHSUVX_fkPÈ;<None',-.1245678=>?@AHSUVX_fk]u=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: ? T = T ? f . ? g = ? (f . g) There is a default ? implementation for î0 types, so instances can derived automatically.UbarbiesDefault implementation of ? based on î.=>?UNone',-.1245678=>?@AHSUVX_fkq[@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 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.AbarbiesjIndexed-functors that can be traversed from left to right. Instances should satisfy the following laws:  t . B f = B (t . f) -- naturality B  =  -- identity B (V . W g . f) = V . W (B g) . B f -- composition There is a default B implementation for î0 types, so instances can derived automatically.CbarbiesdMap each element to an action, evaluate these actions from left to right, and ignore the results.DbarbiesUEvaluate each action in the structure from left to right, and collect the results.Ebarbies A version of D with f specialized to X.Fbarbies6Map each element to a monoid, and combine the results.YbarbiesDefault implementation of B based on î.@ABCDEFYNone',-.1245678=>?@AHSUVX_fk…UGbarbiesiSome endo-functors on indexed-types are monads. Common examples would be "functor-transformers", like V or Z. In that sense, G is similar to , but with additional structure (see also  *https://hackage.haskell.org.package/mmorphmmorph's MMonad class).Notice though that while  assumes a [% instance of the value to be lifted, H† has no such constraint. This means we cannot have instances for most "monad transformers", since lifting typically involves an W.G- 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 (H, I) or (H, J). In the former: ? h . H = H . h ? h . I = I . ? (? h) I . H = T I . 'tmap tlift' = T I . I = I . ? I In the latter: J f . H = f J H = T J f . J g = J (J f . g) Hbarbies(Lift a functor to a transformed functor.Ibarbies”The conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.Jbarbies Analogous to ().GHIJNone',-.1245678=>?@AHSUVX_fk‘¦KbarbiesK 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 L 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.Lbarbies3Barbie-types that can be mapped over. Instances of L& should satisfy the following laws: M T = T M f . M g = M (f . g) There is a default M implementation for î0 types, so instances can derived automatically.NbarbiesDefault implementation of M based on î.KLMNNone',-.1245678=>?@AHSUVX_fk¥,ObarbiesO 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 P 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.PbarbiesfBarbie-types that can be traversed from left to right. Instances should satisfy the following laws:  t . Q f = Q (t . f) -- naturality Q  =  -- identity Q (V . W g . f) = V . W (Q g) . Q f -- composition There is a default Q implementation for î0 types, so instances can derived automatically.RbarbiesdMap each element to an action, evaluate these actions from left to right, and ignore the results.SbarbiesUEvaluate each action in the structure from left to right, and collect the results.Tbarbies A version of S with f specialized to X.Ubarbies6Map each element to a monoid, and combine the results.VbarbiesDefault implementation of Q based on î.OPQRSTUV None',-.1245678=>?@AHSUVX_fk¦[WX!None',-.1245678=>?@AHSUVX_fkÉ~YbarbiesY 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 Z 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.ZbarbiesA >7 where the effects can be distributed to the fields: [’ 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 [ the dual of # and ] the dual of $2. As such, instances need to satisfy these laws: [ . h = ? (V . h . ]) . [ -- naturality [ .  = ? (V . ) -- identity [ . V = W (V . V . W ] . ]) . [ . W ^ -- composition By specializing f to ((->) a) and g to X{, we can define a function that decomposes a function on distributive transformers into a collection of simpler functions: ^ :: Z b => (a -> b X) -> b ((->) a) ^ = ? (W _ . ]) . [ NLawful instances of the class can then be characterized as those that satisfy: _ . ^ = T ^ . _ = T Ú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 [ 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 [ with g specialized to X.]barbiesDual of $^barbieseDecompose a function returning a distributive transformer, into a collection of simpler functions._barbies Recompose a decomposed function.`barbiesDefault implementation of [ based on î.YZ[\]^_`%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 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.abarbiesA L7 where the effects can be distributed to the fields: bˆ 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 b the dual of ' and d the dual of (2. As such, instances need to satisfy these laws: b . h = M (V . h . ]) . b -- naturality b .  = M (V . ) -- identity b . V = M (V . V . W ] . ]) . b . W b -- composition By specializing f to ((->) a) and g to Xv, we can define a function that decomposes a function on distributive barbies into a collection of simpler functions: e :: a b => (a -> b X) -> b ((->) a) e = M (W _ . ]) . b NLawful instances of the class can then be characterized as those that satisfy: f . e = T e . f = T Ú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 b 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.cbarbies A version of b with g specialized to X.dbarbiesDual of (ebarbies`Decompose a function returning a distributive barbie, into a collection of simpler functions.fbarbies Recompose a decomposed function.gbarbiesDefault implementation of b based on î.`abcdefg)None',-.1245678=>?@AHSUVX_fköbibarbies0We 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. hijklmnop+None',-.1245678=>?@AHSUVX_fk÷•qrs,None',-.1245678=>?@AHSUVX_fk tbarbiesAll types that admit a generic L0 instance, and have all their occurrences of f under a 6 admit a generic u instance.ubarbies$Class of Barbie-types defined using 6 and can therefore have 8 versions. Must satisfy: w . v = T v . w = T xbarbiesGeneralization of v to arbitrary functorsybarbiesGeneralization of w to arbitrary functorszbarbiesDefault implementation of v based on î.{barbiesDefault implementation of v based on î. 5678tuvwxyz{None',.1245678=>?@AHSUVX_fk4 5678uvwxy 687uvwxy5-None',.1245678=>?@AHSUVX_fkr678uvwxy687uvwxy.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 a b) -> a (f a) (g b)) (u `tprod' v) = ? f u `tprod' ? g v  Left and right identity ? ((a _ b) -> b) ( e `tprod' v) = v ? ((a a _) -> a) (u `tprod'  e) = u   Associativity ? ((a a (a b c)) -> a (a 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 b.…barbiesAn equivalent of 01.†barbiesAn equivalent of 02.‡barbiesAn equivalent of 03.cbarbiesDefault implementation of ‚ based on î. €‚ƒ„…†‡cd4None',-.1245678=>?@AHSUVX_fk?€ˆbarbies;The representation used for the generic computation of the Œ c t constraints. Here m and l9 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 Q) (f e ) | B (f R) (f Q ) instance ‹ T where type Œ c T = (c Q, c e, c R)  t = case t of A x y -> A (a  x) (a  y) B z w -> B (a  z) (a  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 B* but with a constraint on the elements of t.fbarbiesLike 5' but with a constraint on the function.gbarbiesLike 6* but with a constraint on the elements of t.hbarbiesLike 7* but with a constraint on the elements of t.ibarbiesLike 8* but with a constraint on the elements of t.jbarbies Similar to @ but can produce the instance dictionaries "out of the blue".kbarbiesLike B but a constraint is allowed to be required on each element of t.lbarbies Builds a t f x, by applying m on every field of t.nbarbies/Default implementation of ibaddDicts' based on î.ˆ‰Š‹ŒŽfghijklnNone',.1245678=>?@AHSUVX_fk@·#/01>?ABCDEFGHIJZ[\]^_€‚ƒ„…†‡Š‹ŒŽ#>?ABCFDEZ[\]^_€‚ƒ„…†‡GHIJ‹ŒŠŽ/019None',-.1245678=>?@AHSUVX_fkZê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 L+ with application, providing operations to:embed an "empty" value (’)align and combine values (“)%It should satisfy the following laws: Naturality of “ M ((a a b) -> a (f a) (g b)) (u `bprod' v) = M f u `bprod' M g v  Left and right identity M ((a _ b) -> b) (’ e `bprod' v) = v M ((a a _) -> a) (u `bprod' ’ e) = u   Associativity M ((a a (a b c)) -> a (a a b) c) (u `bprod' (v `bprod' w)) = (u `bprod' v) `bprod' w  It is to L 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 o.•barbiesAn equivalent of b.–barbiesAn equivalent of 01.—barbiesAn equivalent of 02.˜barbiesAn equivalent of 03.™barbiesDefault implementation of “ based on î. ‘’“”•–—˜™š:None',-.1245678=>?@AHSUVX_fkƒ›barbies;The representation used for the generic computation of the Ÿ c b constraints. Here m: 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 ~ (Þ e, Þ Q)  Þ f Person ~ (Þ (f e), Þ (f Q)) ž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 Q) (f e ) | B (f R) (f Q ) instance ž T where type Ÿ c T = (c Q, c e, c R)   t = case t of A x y -> A (a  x) (a  y) B z w -> B (a  z) (a  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 ~ (Þ e, Þ Q) &For requiring constraints of the form c (f a), use .¡barbiesLike MB 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 p: æ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 Q* 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 m on every field of b.ªbarbiesDefault implementation of   based on î.›œžŸ ¡¢£¤¥¦§¨©ªNone',.1245678=>?@AHSUVX_fk„Ô&/01LMPQRSTUabcdef‘’“”•–—˜žŸ ¡¢£¤¥¦§¨©&LMPQRUSTabcdef‘’“”•–—˜žŸ §¡£¢¨¤¥¦©/01>None',.1245678=>?@AHSUVX_fk‰‰«barbies.Wrapper for barbies that act as containers of e by wearing q e.®barbies.Wrapper for barbies that act as containers of a by wearing (p a).«¬­®¯°?None',-.1245678=>?@AHMSUVX_fk‹Â±barbies7A wrapper for Barbie-types, providing useful instances.±²³@None',-.1245678=>?@AHSUVX_fkù´barbies A barbie type without structure.¶barbiesUninhabited barbie type.´µ¶ANone',-.1245678=>?@AHSUVX_fkðrbarbiesDefault implementation of ¼ based on î. ·¸¹º»½¼rsBNone',-.1245678=>?@AHSUVX_fk‘ÿtbarbiesDefault implementation of  based on î.n¾¿ÀÁÂÃtNone',.1245678=>?@AHSUVX_fk“ žŸ ¡¢Á žŸ Á¡¢None',.1245678=>?@AHSUVX_fkšþÄ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 M (C f) (bf Å bg Ä bh) ,/01LMPQRSTU”•–—˜žŸ ¡¢©±²³´µ¶·¸¹º»½¼¾¿ÀÁÂÃÄÅ,LMPQRUST»½¼º”•–—˜žŸ ¡¢ÁÂÀé±²³¶´µ/01·¸¹¾¿ÄÅÄ4Å4 None',-.1245678=>?@AHSUVX_fkq¤ÏÆbarbies Convert a L 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¦\/01>?ABCDEFGHIJLMPQRSTUZ[\]^_abcdef€‚ƒ„…†‡Š‹ŒŽ‘’“”•–—˜žŸ ¡¢£¤¥¦§¨©«¬­®¯°±²³´µ¶ÆÇÈÉÊËÌÍÎÏ ®¯°«¬­±²³¶´µDNone',.1245678=>?@AHSUVX_fk¨«None',.1245678=>?@AHSUVX_fk©Ñœîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP&'()*+,-./012349:;<=@KNOVWXY`ghijklmnopqrstz{|}~ˆ‰™š›œª9N;<K=V9:O@gWX`Yš™|}~ªopœ‰n›ˆmlihkj{zqrst432./01*+,-&'()u 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#B#B#C#D#E#F#G#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#T#U#V#W#X#Y#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z{|{}{~€‚ƒ„…†‡ˆ‰Š‹ŒŠ‹Ž„!‘’“/”/•–4—4˜4™4š4›4œ4ž4Ÿ’ ¡¢£¤AÌA¥B¦§&barbies-2.0.2.0-HfstKv0bfXOCzagLUNTxcBData.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 FilterIndexIndexedParamWearTwoWearCoveredBare 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