h*zK      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2.1.1.0  Safe-Inferred)*/01679:;<=dbarbiesLike  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*/1679:;<= (C) 2018 Csongor KissBSD3 experimental non-portable Safe-Inferred*/013679:;<=A   Safe-Inferred*/1679:;<= barbies Like the  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 ::  t f [Bool] , f2 ::  t f (Sum Int) , f3 ::  t f Sum Int , f4 ::  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 ) removes the wrapper for the bare barbie.barbiesThe 4 type-function allows one to define a Barbie-type as data B t f = B { f1 ::  t f  , f2 ::  t f  } .This gives rise to two rather different types:B  f1 is a normal Barbie-type, in the sense that f1 :: B  f -> f , etc.B  f, on the other hand, is a normal record with no functor around the type: B { f1 :: 5, f2 =  } :: B  f  Safe-Inferred*/01679:;<=  Safe-Inferred*/01679:;<=2 Safe-Inferred*/01679:;<= 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*/01679:;<= 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   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. barbiesIndexed-functors that can be traversed from left to right. Instances should satisfy the following laws:  t . ! f = ! (t . f) -- naturality !  =  -- identity ! ( .  g . f) =  .  (! g) . ! f -- composition There is a default ! implementation for 0 types, so instances can derived automatically."barbies! with the arguments flipped. Useful when the traversing function is a large lambda: !tfor someTransformer $ fa -> ... #barbiesMap each element to an action, evaluate these actions from left to right, and ignore the results.$barbies# with the arguments flipped.%barbiesEvaluate each action in the structure from left to right, and collect the results.&barbies A version of % with f specialized to .'barbies6Map each element to a monoid, and combine the results.barbiesDefault implementation of ! based on . !"#$%&' Safe-Inferred*/01679:;<=(barbiesSome endo-functors on indexed-types are monads. Common examples would be "functor-transformers", like  or . In that sense, ( 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, ) has no such constraint. This means we cannot have instances for most "monad transformers", since lifting typically involves an .(- 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 (), *) or (), +). In the former:  h . ) = ) . h  h . * = * .  ( h) * . ) =  * . 'tmap tlift' =  * . * = * .  * In the latter: + f . ) = f + ) =  + f . + g = + (+ f . g) )barbies(Lift a functor to a transformed functor.*barbiesThe conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.+barbies Analogous to ().()*+ Safe-Inferred*/01679:;<=",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.B f can also contain usages of b f under a  h$. For example, one could use  (B f) when defining B f.-barbies3Barbie-types that can be mapped over. 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*/01679:;<=)- 0barbies0 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 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.1barbiesBarbie-types that can be traversed from left to right. Instances should satisfy the following laws:  t . 2 f = 2 (t . f) -- naturality 2  =  -- identity 2 ( .  g . f) =  .  (2 g) . 2 f -- composition There is a default 2 implementation for 0 types, so instances can derived automatically.3barbies2 with the arguments flipped. Useful when the traversing function is a large lambda: bfor someBarbie $ fa -> ... 4barbiesMap each element to an action, evaluate these actions from left to right, and ignore the results.5barbies4 with the arguments flipped.6barbiesEvaluate each action in the structure from left to right, and collect the results.7barbies A version of 6 with f specialized to .8barbies6Map each element to a monoid, and combine the results.9barbiesDefault implementation of 2 based on . 1234567809 Safe-Inferred*/01679:;<=):;  Safe-Inferred*/01679:;<=4 <barbies< 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 = 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.=barbiesA 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: A :: = b => (a -> b ) -> b ((->) a) A =  (  . ) . > Lawful instances of the class can then be characterized as those that satisfy: B . A =  A . B =  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 #AbarbiesDecompose a function returning a distributive transformer, into a collection of simpler functions.Bbarbies Recompose a decomposed function.barbiesDefault implementation of > based on .=>?@AB<$ Safe-Inferred*/01679:;<=>]CbarbiesC 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 D 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.DbarbiesA -7 where the effects can be distributed to the fields: E 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 E the dual of & and G the dual of '2. As such, instances need to satisfy these laws: E . h = . ( . h . ) . E -- naturality E .  = . ( . ) -- identity E .  = . ( .  .   . ) . E .  E -- 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: H :: D b => (a -> b ) -> b ((->) a) H = . (  . ) . E Lawful instances of the class can then be characterized as those that satisfy: I . H =  H . I =  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 E 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.Fbarbies A version of E with g specialized to .GbarbiesDual of 'HbarbiesDecompose a function returning a distributive barbie, into a collection of simpler functions.Ibarbies Recompose a decomposed function.JbarbiesDefault implementation of E based on .DEFGHIJC( Safe-Inferred*/01679:;<=>PONMLKQR) Safe-Inferred*/01679:;<=? STU* Safe-Inferred*/01679:;<=AVbarbiesAll types that admit a generic -0 instance, and have all their occurrences of f under a  admit a generic W instance.Wbarbies$Class of Barbie-types defined using  and can therefore have  versions. Must satisfy: Y . X =  X . Y =  ZbarbiesGeneralization of X to arbitrary functors[barbiesGeneralization of Y to arbitrary functors\barbiesDefault implementation of X based on .]barbiesDefault implementation of X based on . WXYZ[\]V Safe-Inferred*/1679:;<=B WXYZ[ WXYZ[+ Safe-Inferred*/01679:;<=Bc^_`, Safe-Inferred*/01679:;<=Jabarbiesa 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.bbarbiesA + with application, providing operations to:embed an "empty" value (c)align and combine values (d)%It should satisfy the following laws: Naturality of d  (( a b) ->  (f a) (g b)) (u `tprod' v) =  f u `tprod'  g v  Left and right identity  (( _ b) -> b) (c e `tprod' v) = v  (( a _) -> a) (u `tprod' c 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 d and c based on 5. Intuitively, it works on types where the value of c is uniquely defined. This corresponds rougly to record types (in the presence of sums, there would be several candidates for c!), where every field is either a  or covered by the argument f.ebarbies An alias of d.fbarbiesAn equivalent of .gbarbiesAn equivalent of -..hbarbiesAn equivalent of -/.ibarbiesAn equivalent of -0.barbiesDefault implementation of d based on . bcdefghia1 Safe-Inferred*/01679:;<=Wkbarbies0We use the type-families to generically compute 2 c b. Intuitively, if t' f' x' occurs inside t f x, then we should just add 2 t' c to 2 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 2 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.lbarbies;The representation used for the generic computation of the p c t constraints. .mbarbiesm 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 o t. instance. In particular, recursive usages of T f x are allowed.nbarbies Similar to p# but will put the functor argument f between the constraint c and the type a.obarbiesInstances of this class provide means to talk about constraints, both at compile-time, using p%, and at run-time, in the form of , via q.)A manual definition would look like this: data T f a = A (f ) (f  ) | B (f ) (f  ) instance o T where type p c T = (c , c , 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: q :: AllT Show t => t f -> t (  `Product' f) %There is a default implementation of o for * types, so in practice one will simply do: derive instance  (T f a) instance o T pbarbiesp 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 n.rbarbiesLike  but a constraint is allowed to be required on each element of t.sbarbiesLike !* but with a constraint on the elements of t.tbarbiesLike s but with the arguments flipped.barbiesLike 3' but with a constraint on the function.barbiesLike 4* but with a constraint on the elements of t.barbiesLike 5* but with a constraint on the elements of t.barbiesLike 6* but with a constraint on the elements of t.barbies Similar to q but can produce the instance dictionaries "out of the blue".barbiesLike c 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 .opqrstnmlkj Safe-Inferred*/1679:;<=X& !"#$'%&=>?@ABbcdefghi()*+opqnrst& !"#$'%&=>?@ABbcdefghi()*+opqnrst7 Safe-Inferred*/01679:;<=`ubarbiesu 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.vbarbiesA -+ with application, providing operations to:embed an "empty" value (w)align and combine values (x)%It should satisfy the following laws: Naturality of x . (( a b) ->  (f a) (g b)) (u `bprod' v) = . f u `bprod' . g v  Left and right identity . (( _ b) -> b) (w e `bprod' v) = v . (( a _) -> a) (u `bprod' w e) = u   Associativity . (( a ( b c)) ->  ( a b) c) (u `bprod' (v `bprod' w)) = (u `bprod' v) `bprod' w  It is to - 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 x and w based on 5. Intuitively, it works on types where the value of w is uniquely defined. This corresponds rougly to record types (in the presence of sums, there would be several candidates for w!), where every field is either a  or covered by the argument f.ybarbies An alias of x, since this is like a .zbarbiesAn equivalent of .{barbiesAn equivalent of -..|barbiesAn equivalent of -/.}barbiesAn equivalent of -0.~barbiesDefault implementation of x based on . vwxyz{|}u~8 Safe-Inferred*/01679:;<=pobarbies0We use the type-families to generically compute 9 c b. Intuitively, if b' f' occurs inside b f, then we should just add 9 b' c to 9 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 9 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 (  `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 ~ ( ,  ) &For requiring constraints of the form c (f a), use .barbiesLike . 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)Notice that one can use the  class as a way to require several constraiints to hold simultaneously: bmap @(Show & Eq & Enum) rbarbiesLike 2* but with a constraint on the elements of b.barbies with the arguments flipped. Useful when the traversing function is a large lambda: bforC someBarbie $ fa -> ... 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 w 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*/1679:;<=p)-.12345867DEFGHIvwxyz{|})-.12345867DEFGHIvwxyz{|}= Safe-Inferred*/1679:;<=rhbarbies.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*/01679:;<=s barbies7A wrapper for Barbie-types, providing useful instances.? Safe-Inferred*/01679:;<=sbarbies A barbie type without structure.barbiesUninhabited barbie type. Safe-Inferred*/01679:;<=w! barbies Convert a - 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.barbies with the arguments flipped.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 w and c.barbies A version of " specialized to a single argument.barbies'Simultaneous product on both arguments.   Safe-Inferred*/1679:;<=wvwxDE-.12345867FGHIyz{|}bcdopq=> !()*+np"#$'%&?@ABefghirst  Safe-Inferred*/1679:;<=x Safe-Inferred*/1679:;<=x/,90J:;C<~^_`uaQRmPlONMLKkj]\STUV   >>???    ,,11111111%barbies-2.1.1.0-D5srGchWhw2rDX5kXTLlDBarbies.ConstraintsBarbies.InternalData.Functor.Transformer Barbies.BareData.Functor.BarbieBarbies Barbies.BibarbiesBarbies.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.BareBBarbies.Generics.ApplicativeBarbies.Internal.ApplicativeT Data.ListzipWithzipWith3zipWith4Barbies.Internal.ConstraintsTAllTtfoldMaptzipWith tzipWith3 tzipWith4Barbies.Internal.ApplicativeBBarbies.Internal.ConstraintsBAllBbzipWith bzipWith3 bzipWith4Barbies.Internal.ContainersBarbies.Internal.WrappersBarbies.Internal.TrivialClassFGClassFDict requiringDictGenericPRepPtoPfromPGenericNRepNtoNfromNZipRecunRec FilterIndexIndexedParamWearTwoWearCoveredBare GTraversable gtraverseGFunctorgmapFunctorTtmapCanDeriveTraversableTtfor ttraverse_tfor_ tsequence'MonadTtlifttjointembedFunctorBbmap gbmapDefaultCanDeriveTraversableBbfor btraverse_bfor_ 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 ttraverseCtforCCanDeriveApplicativeB ApplicativeBbpurebprodbzipbunzip gbprodDefault gbpureDefault TagSelf0'TagSelf0GAllRepBCanDeriveConstraintsBAllBF& ConstraintsB baddDictsbmapC btraverseCbforC bfoldMapC bzipWithC bzipWith3C bzipWith4CbdictsbpureCbmemptygbaddDictsDefaultErrorContainergetErrorContainer Container getContainerBarbie getBarbieUnitVoidFliprunFlipbtmapbtmap1 bttraverse bttraverse1btfor1 bttraverse_ btfoldMapbtpurebtpure1btprod$fApplicativeTkk'Flip$fTraversableTkk'Flip$fDistributiveTiFlip$fFunctorTkk'Flip$fApplicativeBkFlip$fTraversableBkFlip$fDistributiveBTYPEFlip$fFunctorBkFlip$fEqFlip $fOrdFlip $fReadFlip $fShowFlipbaseGHC.BaseMonoid GHC.MaybeMaybeGHC.ShowShowWrexecWrtell GHC.GenericsGenericRepfromtoGeneric1Rep1from1to1Datatype datatypeName moduleName packageName isNewtype ConstructorconName conFixity conIsRecordSelectorselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUAddrUCharUDoubleUFloatUIntUWorduWord#uInt#uFloat#uDouble#uChar#uAddr#MetaMetaDataMetaConsMetaSel Generically1 GenericallyDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackSourceStrictness SourceLazy SourceStrictNoSourceStrictnessSourceUnpackedness SourceUnpackSourceNoUnpackNoSourceUnpackedness AssociativityLeftAssociativeRightAssociativeNotAssociativeFixityIPrefixIInfixIFixityPrefixInfixprecghc-prim GHC.TypesIntBoolTrueFunctorid gtmapDefaultData.Traversable TraversableData.Functor.ComposeComposefmapData.Functor.IdentityttraverseDefaulttransformers-0.6.1.0Control.Monad.Trans.ReaderReaderTMonad+distributive-0.6.2.1-2ajkunS9Xoq3j6jiVju7hYData.Distributive Distributive getCompose distribute runIdentitygtdistributeDefaultData.Functor.ProductPair ApplicativeGHC.Listunzip gtprodDefault gtpureDefaultString tfoldMapC tzipWithC tzipWith3C tzipWith4CtdictstpureCtmemptymemptygtaddDictsDefaultzipData.Functor.ConstConst Data.EitherEither