úÎćňĐŹ˙›      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ Ą˘Ł¤ĽŚ§¨ŠŞŤŹ­ŽŻ°ą˛ł´ľśˇ¸šşťź˝žżŔÁÂĂÄĹĆÇČÉĘËĚÍÎĎĐŃŇÓÔŐÖ×ŘŮÚŰÜÝŢßŕáâăäĺćçčéęëěíîďđńňóôőö÷řůúűüýţ˙                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ] ^ _ ` 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 { | } ~  €  ‚ ƒ „ … † ‡ ˆ‰Š‹ŒŽ‘’“”•–—˜™š(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> provisionalportable TrustworthyTFormally, the class  represents a profunctor from Hask -> Hask.nIntuitively it is a bifunctor where the first argument is contravariant and the second argument is covariant.You can define a  by either defining  or by defining both  and .If you supply , you should ensure that:  › › "a ›If you supply  and  , ensure:  › "a ›  › "a › +If you supply both, you should also ensure:  f g "a  f œ  gThese ensure by parametricity:  (f œ g) (h œ i) "a  g h œ  f i  (f œ g) "a  g œ  f  (f œ g) "a  f œ  g )Map over both arguments at the same time.  f g "a  f œ  g'Map the first argument contravariantly.  f "a  f ›$Map the second argument covariantly.  "a  ›“Strictly map the second argument argument covariantly with a function that is assumed operationally to be a cast, such as a newtype constructor.Note: This operation is explicitly unsafe- since an implementation may choose to use  unsafeCoerceh to implement this combinator and it has no way to validate that your function meets the requirements.'If you implement this combinator with  unsafeCoerceo, then you are taking upon yourself the obligation that you don't use GADT-like tricks to distinguish values.If you import Data.Profunctor.Unsafe‚ you are taking upon yourself the obligation that you will only call this with a first argument that is operationally identity.\The semantics of this function with respect to bottoms should match the default definition: () "a \f -> \p -> p `seq`  f p–Strictly map the first argument argument contravariantly with a function that is assumed operationally to be a cast, such as a newtype constructor.Note: This operation is explicitly unsafe- since an implementation may choose to use  unsafeCoerceh to implement this combinator and it has no way to validate that your function meets the requirements.'If you implement this combinator with  unsafeCoerceo, then you are taking upon yourself the obligation that you don't use GADT-like tricks to distinguish values.If you import Data.Profunctor.Unsafeƒ you are taking upon yourself the obligation that you will only call this with a second argument that is operationally identity. () "a \p -> p `seq` \f ->  f p   9 8(C) 2011-2015 Edward Kmett, BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> provisionalportableNoneOQRTWrap an arrow for use as a .Lift a  into a  (backwards).Lift a  into a  (forwards).$ !"#$%&'()*+,-./012 !"#$%&'()*+,-./0120(C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimentalportableNoneOQRT3456789:;<=>?@A3456789:9:A@?678>=345<; 3456789:;<=>?@A(C) 2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimentalnon-portable, MPTCs, fundepsNone<=?OQRTBCDBCDBCDBCD(C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> provisional Rank2TypesNone %&<=OQRT ECopastro -| Cotambara%Copastro freely constructs costrengthH(Cotambara cofreely constructs costrengthJ Analogous to ž, Ÿ = KMPastro -| Tambara #Pastro p ~ exists z. Costar ((,)z)  Procompose p  Procompose Star ((,)z) M freely makes any  R.OO cofreely makes any  R.R Generalizing  of a strong Note: Every & in Haskell is strong with respect to (,).RThis describes profunctor strength with respect to the product structure of Hask. <http://www-kb.is.s.u-tokyo.ac.jp/~asada/papers/arrStrMnd.pdfV V œ W "a › W œ V "a › W V œ W "a › W œ V "a › X X œ Y "a › Y œ X "a › Y X œ Y "a › Y œ X "a › „  is R ĄCEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡EFGHIJKLMNOPQRSTUVWXYRSTUOPQVWMNJKLHIXYEFG9EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡(C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> provisional Rank2TypesNone %&<=OQRT ˆCopastroSum -| CotambaraSumˆ. freely constructs costrength with respect to ˘ (aka •)‹‹0 cofreely constructs costrength with respect to ˘ (aka •)PastroSum -| TambaraSum<PastroSum freely constructs strength with respect to Either.’?TambaraSum is cofreely adjoins strength with respect to Either.Note: this is not dual to . It is $ with respect to a different tensor.•The generalization of  of ! that is strong with respect to ˘.Note: This is also a notion of strength, except with regards to another monoidal structure that we can choose to equip Hask with: the cocartesian coproduct.˜ ˜ œ ™ "a › ™ œ ˜ "a › ™ ˜ œ ™ "a › ™ œ ˜ "a › š š œ › "a › › œ š "a › › š œ › "a › › œ š "a › žŁ approximates  costrength:ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ Ą˘Ł¤ĽŚ§¨ŠŞŤŹ­ŽŻ°ą˛ł´ľśˇ¸šşťź˝žżŔÁˆ‰Š‹ŒŽ‘’“”•–—˜™š›•–—’“”˜™‘Ž‹Œš›ˆ‰Š0ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ Ą˘Ł¤ĽŚ§¨ŠŞŤŹ­ŽŻ°ą˛ł´ľśˇ¸šşťź˝žżŔÁ(C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimentalportableNone %&<=OQRTÄÄ adjoins a Ç structure to any . Analogous to  for R.ÇBA strong profunctor allows the monoidal structure to pass through.@A closed profunctor allows the closed structure to pass through.Ę Ę œ Ë "a › Ë œ Ę "a › Ë Ę œ Ë "a › Ë œ Ę "a › 'ÂĂÄĹĆÇČɤĽĘËĚÍÎĎĐŃŇÓÔŐÖ×ŘŮÚŰÜÝŢßŕáâăäĺć ÂĂÄĹĆÇČÉĘË ÇČÄĹĆĘËÂĂÉ#ÂĂÄĹĆÇČɤĽĘËĚÍÎĎĐŃŇÓÔŐÖ×ŘŮÚŰÜÝŢßŕáâăäĺćNone%&2OTç "FreeTraversing -| CofreeTraversingěNote: Definitions in terms of î are much more efficient!)çčéęëěí¨ŠŞŤďđŹńň­Žóôőö÷řůúűüýţ˙ çčéęëěíîďđńň ěíîéęëçčďđńň çčéęëěí¨ŠŞŤďđŹńň­Žóôőö÷řůúűüýţ˙ None%&OT FreeMapping -| CofreeMapping      !"#$                  !"#$(C) 2011-2015 Edward Kmett, BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> provisionalportable TrustworthyOQRT#JKLRSTUŽ•–—ÇČÉ#RSTU•–—ÇČÉJKLŽ (C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimentalportableNone1Cayley transforms Comonads in Hask into comonads on Prof2Cayley transforms Monads in Hask into monads on Prof%&'()*+,-./0123%&'%&'3210/.-,+*)( %&'()*+,-./0123 (C) 2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> provisionalMPTCs, fundepsSafe9:;<=?4A  p is a 4 on f if it is a subprofunctor of  f.!That is to say it is a subset of  Hom(f-,=) closed under  and .*Alternately, you can view it as a cosieve in the comma category f/Hask.6A  p is a 6 on f if it is a subprofunctor of  f.!That is to say it is a subset of  Hom(-,f=) closed under  and .(Alternately, you can view it as a sieve in the comma category Hask/f. 456789:;<=>?45676745 456789:;<=>? (C) 2011-2015 Edward Kmett, BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> provisional Type-FamiliesSafe%&9:;DOQRT C C -|  :: [Hask, Hask] -> ProfThis gives rise to a monad in Prof, ( 'Star'.'Prep'), and a comonad in  [Hask,Hask] ( 'Prep'.'Star')EA  p is E if there exists a  f such that p d c is isomorphic to f d -> c.HA  p is H if there exists a  f such that p d c is isomorphic to d -> f c.KDefault definition for S given that p is H.LDefault definition for T given that p is H.MJ and 7# form two halves of an isomorphism./This can be used with the combinators from the lens package. M :: H p => Iso' (d -> I p c) (p d c)NDefault definition for K given that p is E.ODefault definition for L given that p is E.PDefault definition for Č given that p is EQG and 5# form two halves of an isomorphism./This can be used with the combinators from the lens package. Q :: F f p => Iso' (f d -> c) (p d c)V @ -|  :: [Hask, Hask]^op -> Prof>Like all adjunctions this gives rise to a monad and a comonad.#This gives rise to a monad on Prof ('Costar'.'Coprep') and a comonad on [Hask, Hask]^op given by ('Coprep'.'Costar') which is a monad in  [Hask,Hask]'@ABCDEFGŻHIJKLMNOPQRSTUVWXYZ[\]^_`abcde@ABCDEFGHIJKLMNOPQRSTUVWXYHIJMKLEFGQNOPCDRSTU@ABVWXY @ABCDEFGŻHIJKLMNOPQRSTUVWXYZ[\]^_`abcde (C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimentalGADTs, TFs, MPTCs, RankNNone %&<=DOQRT f(This represents the right Kan lift of a  q along a  pâ in a limited version of the 2-category of Profunctors where the only object is the category Hask, 1-morphisms are profunctors composed and compose with Profunctor composition, and 2-morphisms are just natural transformations.ii p q is the  composition of the s p and q.For a good explanation of 2 composition in Haskell see Dan Piponi's article: :http://blog.sigfpe.com/2011/07/profunctors-in-haskell.htmll(->)! functions as a lax identity for  composition.This provides an ° for the lens1 package that witnesses the isomorphism between i (->) q d c and q d c", which is the left identity law. l ::  q => Iso' (i (->) q d c) (q d c) m(->)! functions as a lax identity for  composition.This provides an ° for the lens1 package that witnesses the isomorphism between i q (->) d c and q d c#, which is the right identity law. m ::  q => Iso' (i q (->) d c) (q d c) nThe associator for  composition.This provides an ° for the lens1 package that witnesses the isomorphism between i p (i q r) a b and i (i p q) r a b, which arises because Prof7 is only a bicategory, rather than a strict 2-category.o composition generalizes  composition in two ways.$This is the first, which shows that exists b. (a -> f b, b -> g c) is isomorphic to  a -> f (g c). o ::  f => Iso' (i ( f) ( g) d c) ( (ą f g) d c)p composition generalizes  composition in two ways.%This is the second, which shows that exists b. (f a -> b, g b -> c) is isomorphic to  g (f a) -> c. p ::  f => Iso' (i ( f) ( g) d c) ( (ą g f) d c)qThis is a variant on o that uses ˛ instead of . q :: ł f => Iso' (i (˛ f) (˛ g) d c) (˛ (ą f g) d c)rThis is a variant on p that uses ´ instead of . r ::  f => Iso' (i (´ f) (´ g) d c) (´ (ą g f) d c)s,The 2-morphism that defines a left Kan lift. Note: When p is right adjoint to f p (->) then s is the D of the adjunction.ta Ą that is also a  is a ľ in Profwf p p forms a ł in the . 2-category, which is isomorphic to a Haskell Ą instance.‚The composition of two H s is H. by the composition of their representations.#fghij°klmnopqrstuvwxyz{|}~€‚ƒ„…†‡fghijklmnopqrstuijklmntuoqprfghs fghij°klmnopqrstuvwxyz{|}~€‚ƒ„…†‡'(C) 2013-2015 Edward Kmett and Dan Doel BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> provisionalRank2Types, TFsNoneDOQRTˆ-This represents the right Kan extension of a  p\ along itself. This provides a generalization of the "difference list" trick to profunctors.‹-This represents the right Kan extension of a  q along a  pâ in a limited version of the 2-category of Profunctors where the only object is the category Hask, 1-morphisms are profunctors composed and compose with Profunctor composition, and 2-morphisms are just natural transformations.Ž2The 2-morphism that defines a right Kan extension. Note: When q is left adjoint to ‹ q (->) then Ž is the counit of the adjunction.–‹ p p forms a ł in the . 2-category, which is isomorphic to a Haskell Ą instance.ˆ‰Š‹ŒŽ‘’“”•–—˜™š ˆ‰Š‹ŒŽ‘’ ‹ŒŽ‘ˆ‰Š’ˆ‰Š‹ŒŽ‘’“”•–—˜™šś !""#$%&''())*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUUVWWXYZ[[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’““”••–—˜™™šš›œžŸ Ą˘Ł¤ĽŚ§¨ŠŞŤŹ­ŽŻ°ą˛ł´ľśˇ¸šşťź˝žżŔÁÂĂÄĹĆÇČÉÉĘĘËĚÍÎĎĐŃŇÓÔŐÖ×ŘŮÚŰÜÝŢßŕáâăäĺćçčéęëěěííîďđńňóôőö÷řůúűüýţ˙                          ! " # $ % & & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ @ A B 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 [ \ ] ^ _ ` a b c d d e f f g h i j k l m n o p q r s t u v w x y z { | } ~  €  ‚ ƒ„„…††‡ˆ‰Š‹ŒŽ‘’“”•–—•–˜•™š•›œ•›•›ž•–Ÿ• Ą˘Ł¤ĽŚ§§¨ŠŠŞŤŹ­ Ž Ž•Ż°•›ą•™˛˘Łł•™´ľ&profunctors-5.2-LKNUVgHZrZeF6OSV63bAZXData.Profunctor.UnsafeData.Profunctor.TypesData.Profunctor.MonadData.Profunctor.AdjunctionData.Profunctor.StrongData.Profunctor.ChoiceData.Profunctor.ClosedData.Profunctor.TraversingData.Profunctor.MappingData.Profunctor.CayleyData.Profunctor.SieveData.Profunctor.RepData.Profunctor.CompositionData.Profunctor.RanProfuctor.Unsafe#.Data.Profunctor.TambaraTambaraData.Profunctor Profunctordimaplmaprmap.#$fProfunctorTannen$fProfunctorProduct$fProfunctorBiff$fProfunctorJoker$fProfunctorClown$fProfunctorCokleisli$fProfunctorKleisli$fProfunctorTagged$fProfunctor(->)Forget runForget WrappedArrow WrapArrow unwrapArrowCostar runCostarStarrunStar:->$fTraversableForget$fFoldableForget$fFunctorForget$fProfunctorForget$fProfunctorWrappedArrow$fArrowLoopWrappedArrow$fArrowApplyWrappedArrow$fArrowChoiceWrappedArrow$fArrowZeroWrappedArrow$fArrowWrappedArrow$fCategoryTYPEWrappedArrow $fMonadCostar$fApplicativeCostar$fFunctorCostar$fDistributiveCostar$fProfunctorCostar$fDistributiveStar$fMonadPlusStar $fMonadStar$fAlternativeStar$fApplicativeStar $fFunctorStar$fProfunctorStarProfunctorComonad proextract produplicateProfunctorMonad proreturnprojoinProfunctorFunctorpromap$fProfunctorComonadProduct$fProfunctorComonadTannen$fProfunctorMonadSum$fProfunctorMonadTannen$fProfunctorFunctorSum$fProfunctorFunctorProduct$fProfunctorFunctorTannenProfunctorAdjunctionunitcounitCopastro runCopastro CotambaraCostrongunfirstunsecondPastro runTambaraStrongfirst'second'uncurry'tambara untambara cotambara uncotambara$fCostrongCopastro$fProfunctorMonadCopastro$fProfunctorFunctorCopastro'$fProfunctorAdjunctionCopastroCotambara$fProfunctorCopastro$fFunctorCotambara$fCostrongCotambara$fProfunctorComonadCotambara$fProfunctorFunctorCotambara$fProfunctorCotambara$fCostrongProduct$fCostrongTannen$fCostrongCokleisli$fCostrongKleisli$fCostrongWrappedArrow$fCostrongTagged$fCostrongCostar$fCostrong(->)$fStrongPastro#$fProfunctorAdjunctionPastroTambara$fProfunctorMonadPastro$fProfunctorFunctorPastro$fProfunctorPastro$fMonoidTambara$fAlternativeTambara$fApplicativeTambara$fFunctorTambara$fArrowPlusTambara$fArrowZeroTambara$fArrowLoopTambara$fArrowApplyTambara$fArrowChoiceTambara$fArrowTambara$fCategoryTYPETambara$fStrongTambara$fProfunctorComonadTambara$fProfunctorFunctorTambara$fProfunctorTambara$fStrongTannen$fStrongProduct $fStrongClown$fStrongForget$fStrongWrappedArrow $fStrongStar$fStrongKleisli $fStrong(->) CopastroSumrunCopastroSum CotambaraSumCochoiceunleftunright PastroSum TambaraSum runTambaraSumChoiceleft'right' tambaraSum untambaraSum cotambaraSumuncotambaraSum$fCochoiceCopastroSum$fProfunctorMonadCopastroSum$fProfunctorFunctorCopastroSum-$fProfunctorAdjunctionCopastroSumCotambaraSum$fProfunctorCopastroSum$fFunctorCotambaraSum$fCochoiceCotambaraSum$fProfunctorComonadCotambaraSum$fProfunctorFunctorCotambaraSum$fProfunctorCotambaraSum$fCochoiceProduct$fCochoiceTannen$fCochoiceStar$fCochoiceCostar$fCochoice(->)$fChoicePastroSum$fProfunctorMonadPastroSum$fProfunctorFunctorPastroSum)$fProfunctorAdjunctionPastroSumTambaraSum$fProfunctorPastroSum$fFunctorTambaraSum$fCategoryTYPETambaraSum$fChoiceTambaraSum$fProfunctorTambaraSum$fProfunctorComonadTambaraSum$fProfunctorFunctorTambaraSum$fChoiceTambara$fChoiceTannen$fChoiceProduct $fChoiceJoker$fChoiceForget$fChoiceWrappedArrow$fChoiceTagged$fChoiceCostar$fChoiceCokleisli $fChoiceStar$fChoiceKleisli $fChoice(->) EnvironmentClosure runClosureClosedclosedcurry'closeunclose$fClosedEnvironment($fProfunctorAdjunctionEnvironmentClosure$fProfunctorMonadEnvironment$fProfunctorFunctorEnvironment$fProfunctorEnvironment$fMonoidClosure$fAlternativeClosure$fApplicativeClosure$fFunctorClosure$fArrowPlusClosure$fArrowZeroClosure$fArrowLoopClosure$fArrowClosure$fCategoryTYPEClosure$fStrongClosure$fClosedClosure$fProfunctorComonadClosure$fProfunctorFunctorClosure$fProfunctorClosure$fClosedTannen$fClosedProduct$fClosedKleisli $fClosedStar$fClosedCokleisli$fClosedCostar $fClosed(->)$fClosedTaggedFreeTraversingCofreeTraversingrunCofreeTraversing Traversing traverse'wanderfirstTraversingsecondTraversingleftTraversingrightTraversing$fProfunctorMonadFreeTraversing!$fProfunctorFunctorFreeTraversing$fTraversingFreeTraversing$fChoiceFreeTraversing$fStrongFreeTraversing$fProfunctorFreeTraversing#$fProfunctorComonadCofreeTraversing#$fProfunctorFunctorCofreeTraversing$fTraversingCofreeTraversing$fChoiceCofreeTraversing$fStrongCofreeTraversing$fProfunctorCofreeTraversing$fTraversingStar$fTraversingKleisli$fTraversing(->)$fProfunctorBaz$fTraversableBaz $fFoldableBaz$fProfunctorBazaar$fApplicativeBazaar$fFunctorBazaar $fFunctorBaz FreeMapping CofreeMappingrunCofreeMappingMappingmap'traverseMapping closedMapping$fProfunctorMonadFreeMapping$fProfunctorFunctorFreeMapping$fMappingFreeMapping$fTraversingFreeMapping$fClosedFreeMapping$fChoiceFreeMapping$fStrongFreeMapping$fProfunctorFreeMapping $fProfunctorComonadCofreeMapping $fProfunctorFunctorCofreeMapping$fMappingCofreeMapping$fTraversingCofreeMapping$fClosedCofreeMapping$fChoiceCofreeMapping$fStrongCofreeMapping$fProfunctorCofreeMapping $fMappingStar$fMappingKleisli $fMapping(->)Cayley runCayley$fArrowPlusCayley$fArrowZeroCayley$fArrowLoopCayley$fArrowChoiceCayley $fArrowCayley$fCategoryTYPECayley$fChoiceCayley$fStrongCayley$fProfunctorCayley$fProfunctorComonadCayley$fProfunctorMonadCayley$fProfunctorFunctorCayleyCosievecosieveSievesieve$fCosieveCostarf$fCosieveTaggedProxy$fCosieveCokleisliw$fCosieve(->)Identity$fSieveForgetConst $fSieveStarf$fSieveKleislim$fSieve(->)IdentityCoprep runCoprepPrepCorepresentableCorep cotabulate RepresentableReptabulatefirstRep secondRep tabulated unfirstCorep unsecondCorep closedCorep cotabulatedprepAdj unprepAdjprepUnit prepCounit coprepAdj uncoprepAdj coprepUnit coprepCounit$fFunctorCoprep $fMonadPrep$fApplicativePrep $fFunctorPrep$fCorepresentableCostar$fCorepresentableTagged$fCorepresentableCokleisli$fCorepresentable(->)$fRepresentableForget$fRepresentableStar$fRepresentableKleisli$fRepresentable(->)RiftrunRift Procompose procomposedidlidrassocstarscostarskleislis cokleislis decomposeRiftetamu$$fProfunctorAdjunctionProcomposeRift$fCategoryTYPERift $fFunctorRift$fProfunctorRift$fProfunctorComonadRift$fProfunctorFunctorRift$fCostrongProcompose$fClosedProcompose$fChoiceProcompose$fStrongProcompose$fCorepresentableProcompose$fCosieveProcomposeCompose$fRepresentableProcompose$fSieveProcomposeCompose$fFunctorProcompose$fProfunctorProcompose$fProfunctorMonadProcompose$fProfunctorFunctorProcompose Codensity runCodensityRanrunRan decomposeRan precomposeRancurryRan uncurryRandecomposeCodensity$fCategoryTYPECodensity$fFunctorCodensity$fProfunctorCodensity$fCategoryTYPERan $fFunctorRan$fProfunctorRan$fProfunctorComonadRan$fProfunctorFunctorRanbaseControl.Categoryid.GHC.BaseFunctor Control.Arrow ArrowLooploopArrowCategory Data.EitherEither comonad-5-D4OfCscNX7vGdhDagIJJlzControl.ComonadextracthitheryonBazrunBazBazaar runBazaarswapEsellsoldIsoData.Functor.ComposeComposeKleisliMonad CokleisliMonoid