h&:      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                        &  Safe-Inferred)*/015689:;<#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 ->    This 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 constraints package, but because of its kind, it allows us to define things like  .barbiesTurn a constrained-function into an unconstrained one that uses the packed instance dictionary instead.  Safe-Inferred*/15689:;<t Safe-Inferred)*/015689:;<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  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 E 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-portable Safe-Inferred*/0125689:;<`&'()*+,-./01234 Safe-Inferred*/15689:;<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 f1 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 Max) 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  , f2 :: 6 t f  } .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 , etc.B 8 f, on the other hand, is a normal record with no functor around the type: B { f1 :: 5, f2 =  } :: B 8 f 5678 Safe-Inferred*/015689:;<9: Safe-Inferred*/015689:;<I;< Safe-Inferred*/015689:;<!=barbies= T f g x" is in practice a predicate about T 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: ?  =  ? f . ? g = ? (f . g) There is a default ? implementation for 0 types, so instances can derived automatically.barbiesDefault implementation of ? based on .=>? Safe-Inferred*/015689:;<#@barbies@ T f g x" is in practice a predicate about T only. It is analogous to , 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.AbarbiesIndexed-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 ( .  g . f) =  .  (B g) . B f -- composition There is a default B implementation for 0 types, so instances can derived automatically.CbarbiesMap each element to an action, evaluate these actions from left to right, and ignore the results.DbarbiesEvaluate each action in the structure from left to right, and collect the results.Ebarbies A version of D with f specialized to .Fbarbies6Map each element to a monoid, and combine the results.barbiesDefault implementation of B based on .@ABCDEF Safe-Inferred*/015689:;<),GbarbiesSome endo-functors on indexed-types are monads. Common examples would be "functor-transformers", like  or . 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 .G- also corresponds to the indexed-monad of  ;https://personal.cis.strath.ac.uk/conor.mcbride/Kleisli.pdf$Kleisli arrows of outrageous fortune.Instances 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 =  I . 'tmap tlift' =  I . I = I . ? I In the latter: J f . H = f J H =  J f . J g = J (J f . g) Hbarbies(Lift a functor to a transformed functor.IbarbiesThe 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 ().GHIJ Safe-Inferred*/015689:;<,KbarbiesK B f g" is in practice a predicate about B 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  =  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 .KLMN Safe-Inferred*/015689:;<2ObarbiesO B f g" is in practice a predicate about B only. It is analogous to , 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.PbarbiesBarbie-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 ( .  g . f) =  .  (Q g) . Q f -- composition There is a default Q implementation for 0 types, so instances can derived automatically.RbarbiesMap each element to an action, evaluate these actions from left to right, and ignore the results.SbarbiesEvaluate each action in the structure from left to right, and collect the results.Tbarbies A version of S with f specialized to .Ubarbies6Map each element to a monoid, and combine the results.VbarbiesDefault implementation of Q based on .OPQRSTUV  Safe-Inferred*/015689:;<3WX! Safe-Inferred*/015689:;<=YbarbiesY T f g x" is in practice a predicate about T 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 = ? ( . h . ) . [ -- naturality [ .  = ? ( . ) -- identity [ .  =  ( .  .   . ) . [ .   -- composition By specializing f to ((->) a) and g to , we can define a function that decomposes a function on distributive transformers into a collection of simpler functions: ^ :: Z b => (a -> b ) -> b ((->) a) ^ = ? (  . ) . [ Lawful instances of the class can then be characterized as those that satisfy: _ . ^ =  ^ . _ =  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 .]barbiesDual of $^barbiesDecompose a function returning a distributive transformer, into a collection of simpler functions._barbies Recompose a decomposed function.barbiesDefault implementation of [ based on .YZ[\]^_% Safe-Inferred*/015689:;<G`barbies` B f g" is in practice a predicate about B 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 ( . h . ) . b -- naturality b .  = M ( . ) -- identity b .  = M ( .  .   . ) . b .  b -- composition By specializing f to ((->) a) and g to , we can define a function that decomposes a function on distributive barbies into a collection of simpler functions: e :: a b => (a -> b ) -> b ((->) a) e = M (  . ) . b Lawful instances of the class can then be characterized as those that satisfy: f . e =  e . f =  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 .dbarbiesDual of (ebarbiesDecompose a function returning a distributive barbie, into a collection of simpler functions.fbarbies Recompose a decomposed function.gbarbiesDefault implementation of b based on .`abcdefg) Safe-Inferred*/015689:;<HGhijklmno* Safe-Inferred*/015689:;<Hpqr+ Safe-Inferred*/015689:;<K=sbarbiesAll types that admit a generic L0 instance, and have all their occurrences of f under a 6 admit a generic t instance.tbarbies$Class of Barbie-types defined using 6 and can therefore have 8 versions. Must satisfy: v . u =  u . v =  wbarbiesGeneralization of u to arbitrary functorsxbarbiesGeneralization of v to arbitrary functorsybarbiesDefault implementation of u based on .zbarbiesDefault implementation of u based on . 5678stuvwxyz Safe-Inferred*/15689:;<K 5678tuvwx 687tuvwx5, Safe-Inferred*/15689:;<K678tuvwx687tuvwx- Safe-Inferred*/015689:;<LP{|}. Safe-Inferred*/015689:;<S~barbies~ T f g x" is in practice a predicate about T 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 `` v) = ? f u `` ? g v  Left and right identity ? (( _ b) -> b) ( e ` ` v) = v ? (( a _) -> a) (u ``  e) = u   Associativity ? (( a ( b c)) ->  ( a b) c) (u `` (v ` ` w)) = (u `` v) `` 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 .barbiesAn equivalent of /0.barbiesAn equivalent of /1.barbiesAn equivalent of /2.barbiesDefault implementation of  based on . ~3 Safe-Inferred*/015689:;<aRbarbies0We use the type-families to generically compute 4 c b. Intuitively, if t' f' x' occurs inside t f x, then we should just add 4 t' c to 4 t c. The problem is that if t is a recursive type, and t' is t, then ghc will choke and blow the stack (instead of computing a fixpoint).-So, we would like to behave differently when t = t' and add () instead of 4 t c to break the recursion. Our trick will be to use a type family to inspect  (t X Y), for arbitrary X and Y and distinguish recursive usages from non-recursive ones, tagging them with different types, so we can distinguish them in the instances.barbies;The representation used for the generic computation of the  c t constraints. .barbies T f g x" is in practice a predicate about T 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.barbiesInstances 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 ) (f  ) | B (f ) (f  ) instance  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, 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 (  `` 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 ? but a constraint is allowed to be required on each element of t.barbiesLike B* but with a constraint on the elements of t.barbiesLike 5' but with a constraint on the function.barbiesLike 6* but with a constraint on the elements of t.barbiesLike 7* but with a constraint on the elements of t.barbiesLike 8* but with a constraint on the elements of t.barbies Similar to  but can produce the instance dictionaries "out of the blue".barbiesLike  but a constraint is allowed to be required on each element of t.barbies Builds a t f x, by applying  on every field of t.barbies/Default implementation of ibaddDicts' based on . Safe-Inferred*/15689:;<a#/01>?ABCDEFGHIJZ[\]^_#>?ABCFDEZ[\]^_GHIJ/019 Safe-Inferred*/015689:;<ibarbies B f g" is in practice a predicate about B 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 b) ->  (f a) (g b)) (u `` v) = M f u `` M g v  Left and right identity M (( _ b) -> b) ( e ` ` v) = v M (( a _) -> a) (u ``  e) = u   Associativity M (( a ( b c)) ->  ( a b) c) (u `` (v ` ` w)) = (u `` v) `` 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 .barbiesAn equivalent of .barbiesAn equivalent of /0.barbiesAn equivalent of /1.barbiesAn equivalent of /2.barbiesDefault implementation of  based on . : Safe-Inferred*/015689:;<ybarbies0We 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 b, 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 c to break the recursion. Our trick will be to use a type family to inspect  (b X), for an arbitrary X, and distinguish recursive usages from non-recursive ones, tagging them with different types, so we can distinguish them in the instances.barbies;The representation used for the generic computation of the  c b constraints.barbies B f g" is in practice a predicate about B 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 ~ ( ,  )   f Person ~ ( (f ),  (f )) barbiesInstances 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  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, 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 (  `` 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 ~ ( ,  ) &For requiring constraints of the form c (f a), use .barbiesLike M 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 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  but a constraint is allowed to be required on each element of b.barbies Builds a b f, by applying  on every field of b.barbiesDefault implementation of  based on . Safe-Inferred*/15689:;<y&/01LMPQRSTUabcdef&LMPQRUSTabcdef/01? Safe-Inferred*/15689:;<{barbies.Wrapper for barbies that act as containers of e by wearing  e.barbies.Wrapper for barbies that act as containers of a by wearing ( a).@ Safe-Inferred*/015689:;<{barbies7A wrapper for Barbie-types, providing useful instances.A Safe-Inferred*/015689:;<|ibarbies A barbie type without structure.barbiesUninhabited barbie type.B Safe-Inferred*/015689:;<}barbiesDefault implementation of  based on . C Safe-Inferred*/015689:;<}barbiesDefault implementation of  based on .m Safe-Inferred*/15689:;<~   Safe-Inferred*/15689:;<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 D# 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 D on an n-ary function. E.g. f :: f a -> g a -> h a -> i a M (D f) (bf  bg  bh) ,/01LMPQRSTU,LMPQRUST/0144  Safe-Inferred*/015689:;<l 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.barbiesMap each element to an action, evaluate these actions from left to right and ignore the results.barbies6Map each element to a monoid, and combine the results.barbies0Conceptually, this is like simultaneously using  and .barbies A version of " specialized to a single argument.barbies'Simultaneous product on both arguments.   Safe-Inferred*/15689:;</01>?ABCDEFGJHILMPQRSTUZ[\]^_abcdef E Safe-Inferred*/15689:;< Safe-Inferred*/15689:;<@&)'('*-+,+./012349:;<=@KNOVWXY`ghijklmnopqrsyz{|}~99:::::::;:::::::::::??????@@@AMAMABBBBBBBCCCCCC                           !..33333333BBC&barbies-2.0.4.0-KY6nuhPmaNpIwRscfuW31WData.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.ConstraintsBarbies.Generics.BareBarbies.Internal.BareBData.Barbie.BareBarbies.Generics.ApplicativeBarbies.Internal.ApplicativeT Data.ListzipWithzipWith3zipWith4Barbies.Internal.ConstraintsTAllTtfoldMaptzipWith tzipWith3 tzipWith4Barbies.Internal.ApplicativeBBarbies.Internal.ConstraintsBAllBbzipWith 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 brecomposegbdistributeDefault SelfOrOtherOtherSelfYXGAll GConstraints gaddDictsGBaregstripgcoverCanDeriveBareBBareBbstripbcover bstripFrom bcoverWithgbstripDefaultgbcoverDefault GApplicativegprodgpureCanDeriveApplicativeT ApplicativeTtpuretprodtziptunzip TagSelf1'TagSelf1GAllRepTCanDeriveConstraintsTAllTF ConstraintsT taddDictstmapC ttraverseCCanDeriveApplicativeB ApplicativeBbpurebprodbzipbunzip gbprodDefault gbpureDefault TagSelf0'TagSelf0GAllRepBCanDeriveConstraintsBAllBF ConstraintsB baddDictsbmapC btraverseC bfoldMapC bzipWithC bzipWith3C bzipWith4CbdictsbpureCbmemptygbaddDictsDefaultErrorContainergetErrorContainer Container getContainerBarbie getBarbieVoid GProductBgbprodgbuniqCanDeriveProductBProductBbuniq GProductBCgbdictsCanDeriveProductBC ProductBCbuniqC/*//*FliprunFlipbtmapbtmap1 bttraverse bttraverse1 bttraverse_ btfoldMapbtpurebtpure1btprod$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.GenericsGenerictoRepfromGeneric1to1Rep1from1Datatype packageName moduleName datatypeName isNewtype ConstructorconName conFixity conIsRecordSelectorselSourceUnpackednessselSourceStrictnessselDecidedStrictnessselNameV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecuWord#uInt#uFloat#uDouble#uChar#uAddr#UWordUIntUFloatUDoubleUAddrUCharSourceUnpackednessNoSourceUnpackedness SourceUnpackSourceNoUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictMetaMetaSelMetaDataMetaConsFixityIPrefixIInfixIFixityInfixPrefixDecidedStrictness DecidedUnpack DecidedLazy DecidedStrict AssociativityNotAssociativeLeftAssociativeRightAssociativeprec GHC.TypesIntBoolTrueid gtmapDefaultData.Functor.ComposeComposefmapData.Functor.IdentityttraverseDefaulttransformers-0.5.6.2Control.Monad.Trans.ReaderReaderTMonad*distributive-0.6.2.1-4tEHAlYOuSlrjFFNkxy0WData.Distributive Distributive getCompose distribute runIdentitygtdistributeDefaultPairGHC.Listunzip gtprodDefault gtpureDefaultString tfoldMapC tzipWithC tzipWith3C tzipWith4CtdictstpureCtmemptymemptygtaddDictsDefaultzipData.Functor.ConstConst Data.EitherEither gbuniqDefaultgbdictsDefault