h$pidI      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                          (C) 2011-2018 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  provisionalportable Trustworthy profunctorsFormally, the class  represents a profunctor from Hask -> Hask.Intuitively 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:    D If you supply  and  , ensure:   D    D  +If you supply both, you should also ensure:  f g D  f   gThese ensure by parametricity:  (f  g) (h  i) D  g h   f i  (f  g) D  g   f  (f  g) D  f   g  profunctors)Map over both arguments at the same time.  f g D  f   g profunctors'Map the first argument contravariantly.  f D  f  profunctors$Map the second argument covariantly.  D   profunctorsStrictly 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  unsafeCoerce to implement this combinator and it has no way to validate that your function meets the requirements.'If you implement this combinator with  unsafeCoerce, 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: () D \_ -> \p -> p `seq`   p profunctorsStrictly 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  unsafeCoerce to implement this combinator and it has no way to validate that your function meets the requirements.'If you implement this combinator with  unsafeCoerce, 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. () D \p -> p `seq` \f ->   p9 8(C) 2011-2015 Edward Kmett, BSD-style (see the file LICENSE)Edward Kmett  provisionalportable Trustworthy.e profunctors has a polymorphic kind since 5.6. profunctorsWrap an arrow for use as a . has a polymorphic kind since 5.6. profunctorsLift a  into a  (backwards). has a polymorphic kind since 5.6. profunctorsLift a  into a  (forwards). has a polymorphic kind since 5.6. profunctors() has a polymorphic kind since 5.6.2 profunctorsVia Monoid r => (a -> r)3 profunctorsVia Semigroup r => (a -> r)0(C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  experimentalportableSafe.9 profunctorsLaws: :  @ f D f  : :  ; D  @ :  ; D  ;  ; D @ ;  ; < profunctorsLaws: @ f  = D =  f >  = D  >  @ = D  >  > D >  @ > ? profunctors? has a polymorphic kind since 5.6.@ profunctorsLaws: @ f  @ g D @ (f  g) @  D  9;:<>=?@?@<>=9;:(C) 2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  experimentalnon-portable, MPTCs, fundepsSafeH profunctorsLaws: I  J D  J  I D  HJIHJI(C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  provisional Rank2TypesSafe '(&:K profunctorsCopastro -| Cotambara%Copastro freely constructs costrengthN profunctors(Cotambara cofreely constructs costrengthP profunctors Analogous to ,  = QQ profunctorsLaws: Q D R      (,()) D Q   (,()) Q   ( f) D Q   ( f) Q  Q = Q   assoc unassoc where assoc ((a,b),c) = (a,(b,c)) unassoc (a,(b,c)) = ((a,b),c) R profunctorsLaws: R D Q      ((),) D R   ((),) R   ( f) D R   ( f) R  R = R   unassoc assoc where assoc ((a,b),c) = (a,(b,c)) unassoc (a,(b,c)) = ((a,b),c) S profunctorsPastro -| Tambara #Pastro p ~ exists z. Costar ((,)z)  Procompose p  Procompose Star ((,)z) S freely makes any  X.U profunctorsU cofreely makes any  X.X profunctors Generalizing  of a strong Note: Every & in Haskell is strong with respect to (,).This describes profunctor strength with respect to the product structure of Hask. 8http://www.riec.tohoku.ac.jp/~asada/papers/arrStrMnd.pdfY profunctorsLaws: Y D     Z   D    Y  (Z f)  Y D  (Z f)  Y Y  Y D  assoc unassoc  Y where assoc ((a,b),c) = (a,(b,c)) unassoc (a,(b,c)) = ((a,b),c) Z profunctorsLaws: Z D     Y   D    Z  (Y f)  Z D  (Y f)  Z Z  Z D  unassoc assoc  Z where assoc ((a,b),c) = (a,(b,c)) unassoc (a,(b,c)) = ((a,b),c) ] profunctors ] (^ f) D f ^ (] f) D f ^ profunctors ] (^ f) D f ^ (] f) D f _ profunctors _ (` f) D f ` (_ f) D f ` profunctors _ (` f) D f ` (_ f) D f a profunctors a  b D  b  a D  b profunctors a  b D  b  a D  h profunctors is X KLMNOPQRSTUVWXYZ[\]^_`abXYZ[\UVW]^ST_`PQRNOabKLM(C) 2014-2018 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  experimentalportable Trustworthy '(0) profunctors adjoins a  structure to any . Analogous to  for X. profunctorsA strong profunctor allows the monoidal structure to pass through.A closed profunctor allows the closed structure to pass through. profunctorsLaws:  ( f)   D  ( f)      D        (())   D   profunctors    D     D   profunctors    D     D   (C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  provisional Rank2TypesSafe '(  b a swapE =     (  absurd) D    (  absurd) Q   ( f) D Q   ( f)    D   # assocE unassocE where assocE ::  ( a b) c ->  a ( b c) assocE ( ( a)) =  a assocE ( ( b)) =  ( b) assocE ( c) =  ( c) unassocE ::  a ( b c) ->  ( a b) c unassocE ( a) =  ( a) unassocE ( ( b)) =  ( b) unassocE ( ( c)) =  c  profunctorsLaws:  D    swapE swapE where swapE ::  a b ->  b a swapE =     ( absurd ) D    ( absurd ) R   ( f) D R   ( f)    D   # unassocE assocE where assocE ::  ( a b) c ->  a ( b c) assocE ( ( a)) =  a assocE ( ( b)) =  ( b) assocE ( c) =  ( c) unassocE ::  a ( b c) ->  ( a b) c unassocE ( a) =  ( a) unassocE ( ( b)) =  ( b) unassocE ( ( c)) =  c  profunctorsPastroSum -| TambaraSum  b a swapE =      D      ( f)   D  ( f)      D  assocE unassocE   where assocE ::  ( a b) c ->  a ( b c) assocE ( ( a)) =  a assocE ( ( b)) =  ( b) assocE ( c) =  ( c) unassocE ::  a ( b c) ->  ( a b) c unassocE ( a) =  ( a) unassocE ( ( b)) =  ( b) unassocE ( ( c)) =  c  profunctorsLaws:  D  swapE swapE   where swapE ::  a b ->  b a swapE =      D      ( f)   D  ( f)      D  unassocE assocE   where assocE ::  ( a b) c ->  a ( b c) assocE ( ( a)) =  a assocE ( ( b)) =  ( b) assocE ( c) =  ( c) unassocE ::  a ( b c) ->  ( a b) c unassocE ( a) =  ( a) unassocE ( ( b)) =  ( b) unassocE ( ( c)) =  c  profunctors    D     D   profunctors    D     D   profunctors    D     D   profunctors    D     D   profunctors approximates  costrengthSafe'(5? profunctors "FreeTraversing -| CofreeTraversing profunctorsNote: Definitions in terms of  are much more efficient! profunctorsLaws:  D      f D  ( f)      D           D   profunctors0This combinator is mutually defined in terms of  profunctorsA definition of  for $ instances that define an explicit . profunctors, may be a more efficient implementation of  than the default produced from . profunctors+ is the same as the default produced from . (C) 2015-2018 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  experimentalportableSafe'(5A profunctors FreeMapping -| CofreeMapping profunctorsLaws:    f D  ( f)      D           D   (C) 2011-2015 Edward Kmett, BSD-style (see the file LICENSE)Edward Kmett  provisionalportableSafeBK$PQRXYZ[$XYZ[PQR (C) 2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  provisionalMPTCs, fundeps Trustworthy>?E profunctorsA  p is a  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. profunctorsA  p is a  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. (C) 2011-2015 Edward Kmett, BSD-style (see the file LICENSE)Edward Kmett  provisional Type-FamiliesSafe'(.>?M profunctors has a polymorphic kind since 5.6. profunctors  -|  :: [Hask, Hask] -> ProfThis gives rise to a monad in Prof, (.), and a comonad in  [Hask,Hask] (.) has a polymorphic kind since 5.6. profunctorsA  p is  if there exists a  f such that p d c is isomorphic to f d -> c. profunctorsLaws:    D     D   profunctorsA  p is  if there exists a  f such that p d c is isomorphic to d -> f c. profunctorsLaws:    D     D   profunctorsDefault definition for Y given that p is . profunctorsDefault definition for Z given that p is . profunctors and # form two halves of an isomorphism./This can be used with the combinators from the lens package.  ::  p => Iso' (d ->  p c) (p d c) profunctorsDefault definition for Q given that p is . profunctorsDefault definition for R given that p is . profunctorsDefault definition for  given that p is  profunctors and # form two halves of an isomorphism./This can be used with the combinators from the lens package.  ::  f p => Iso' (f d -> c) (p d c) profunctors  -|  :: [Hask, Hask]^op -> Prof>Like all adjunctions this gives rise to a monad and a comonad.#This gives rise to a monad on Prof (.) and a comonad on [Hask, Hask]^op given by (.) which is a monad in  [Hask,Hask] (C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  experimentalGADTs, TFs, MPTCs, RankNSafe '(.Z  profunctors(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. has a polymorphic kind since 5.6. profunctors 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.html has a polymorphic kind since 5.6. profunctors(->)! functions as a lax identity for  composition.This provides an  for the lens1 package that witnesses the isomorphism between  (->) q d c and q d c", which is the left identity law.  ::  q => Iso' ( (->) q d c) (q d c)  profunctors(->)! functions as a lax identity for  composition.This provides an  for the lens1 package that witnesses the isomorphism between  q (->) d c and q d c#, which is the right identity law.  ::  q => Iso' ( q (->) d c) (q d c)  profunctorsThe associator for  composition.This provides an  for the lens1 package that witnesses the isomorphism between  p ( q r) a b and  ( p q) r a b, which arises because Prof7 is only a bicategory, rather than a strict 2-category. profunctors 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).  ::  f => Iso' ( ( f) ( g) d c) ( ( f g) d c) profunctors 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.  ::  f => Iso' ( ( f) ( g) d c) ( ( g f) d c) profunctorsThis is a variant on  that uses  instead of .  ::  f => Iso' ( ( f) ( g) d c) ( ( f g) d c) profunctorsThis is a variant on  that uses  instead of .  ::  f => Iso' ( ( f) ( g) d c) ( ( g f) d c) profunctors,The 2-morphism that defines a left Kan lift. Note: When p is right adjoint to  p (->) then  is the J of the adjunction. profunctorsa  that is also a  is a  in Prof profunctorsThe composition of two  s is . by the composition of their representations. profunctors p p forms a  in the . 2-category, which is isomorphic to a Haskell  instance. '(C) 2013-2015 Edward Kmett and Dan Doel BSD-style (see the file LICENSE)Edward Kmett  provisionalRank2Types, TFsSafe._u profunctors-This represents the right Kan extension of a  p along itself. This provides a generalization of the "difference list" trick to profunctors. has a polymorphic kind since 5.6. 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. has a polymorphic kind since 5.6. profunctors2The 2-morphism that defines a right Kan extension. Note: When q is left adjoint to  q (->) then  is the counit of the adjunction. profunctors p p forms a  in the . 2-category, which is isomorphic to a Haskell  instance.  (C) 2014-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  experimentalportable Trustworthy.aM profunctorsStatic arrows. Lifted by . has a polymorphic kind since 5.6. profunctorsCayley transforms Comonads in Hask into comonads on Prof profunctorsCayley transforms Monads in Hask into monads on Prof(C) 2017 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  provisionalRank2Types, TFs Trustworthy '(d! profunctors?This is the cofree profunctor given a data constructor of kind  * -> * -> * profunctors >   D    > D  > D   profunctors >   D    > D   = =  profunctors   : D  :   D  ; D   profunctors   ; D  ;   D   D :   !"#$$%&'())*++,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^^_`abbcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                           (profunctors-5.6.2-Ivkd7jruTXmDcAM0K5DKjcData.Profunctor.UnsafeData.Profunctor.TypesData.Profunctor.MonadData.Profunctor.AdjunctionData.Profunctor.StrongData.Profunctor.ClosedData.Profunctor.ChoiceData.Profunctor.TraversingData.Profunctor.MappingData.Profunctor.SieveData.Profunctor.RepData.Profunctor.CompositionData.Profunctor.RanData.Profunctor.CayleyData.Profunctor.YonedaProfuctor.Unsafe#.Data.Profunctor.TambaraTambaraData.Profunctor Profunctordimaplmaprmap.#$fProfunctorTannen$fProfunctorSum$fProfunctorProduct$fProfunctorBiff$fProfunctorJoker$fProfunctorClown$fProfunctorCokleisli$fProfunctorKleisli$fProfunctorTagged$fProfunctor->Forget runForget WrappedArrow WrapArrow unwrapArrowCostar runCostarStarrunStar:->$fContravariantStar$fCategoryTYPEStar$fDistributiveStar$fMonadPlusStar $fMonadStar$fAlternativeStar$fApplicativeStar $fFunctorStar$fProfunctorStar $fMonadCostar$fApplicativeCostar$fFunctorCostar$fDistributiveCostar$fProfunctorCostar$fProfunctorWrappedArrow$fArrowLoopWrappedArrow$fArrowApplyWrappedArrow$fArrowChoiceWrappedArrow$fArrowZeroWrappedArrow$fArrowWrappedArrow$fCategorykWrappedArrow$fMonoidForget$fSemigroupForget$fContravariantForget$fTraversableForget$fFoldableForget$fFunctorForget$fProfunctorForgetProfunctorComonad proextract produplicateProfunctorMonad proreturnprojoinProfunctorFunctorpromap$fProfunctorFunctorTYPETYPESum"$fProfunctorFunctorTYPETYPEProduct!$fProfunctorFunctorTYPETYPETannen$fProfunctorMonadSum$fProfunctorMonadTannen$fProfunctorComonadProduct$fProfunctorComonadTannenProfunctorAdjunctionunitcounitCopastro runCopastro CotambaraCostrongunfirstunsecondPastro runTambaraStrongfirst'second'uncurry'strongtambara untambarapastrounpastro cotambara uncotambara$fStrongTannen $fStrongSum$fStrongProduct $fStrongClown$fStrongForget$fStrongWrappedArrow $fStrongStar$fStrongKleisli $fStrong->$fMonoidTambara$fSemigroupTambara$fAlternativeTambara$fApplicativeTambara$fFunctorTambara$fArrowPlusTambara$fArrowZeroTambara$fArrowLoopTambara$fArrowApplyTambara$fArrowChoiceTambara$fArrowTambara$fCategoryTYPETambara$fStrongTambara$fProfunctorComonadTambara"$fProfunctorFunctorTYPETYPETambara$fProfunctorTambara$fStrongPastro#$fProfunctorAdjunctionPastroTambara$fProfunctorMonadPastro!$fProfunctorFunctorTYPETYPEPastro$fProfunctorPastro$fFunctorPastro $fCostrongSum$fCostrongProduct$fCostrongTannen$fCostrongCokleisli$fCostrongKleisli$fCostrongWrappedArrow$fCostrongTagged$fCostrongCostar $fCostrong->$fFunctorCotambara$fCostrongCotambara$fProfunctorComonadCotambara$$fProfunctorFunctorTYPETYPECotambara$fProfunctorCotambara$fCostrongCopastro$fProfunctorMonadCopastro#$fProfunctorFunctorTYPETYPECopastro'$fProfunctorAdjunctionCopastroCotambara$fProfunctorCopastro$fFunctorCopastro EnvironmentClosure runClosureClosedclosedcurry'closeunclose$fClosedTannen $fClosedSum$fClosedProduct$fClosedKleisli $fClosedStar$fClosedCokleisli$fClosedCostar $fClosed->$fClosedTagged$fMonoidClosure$fSemigroupClosure$fAlternativeClosure$fApplicativeClosure$fFunctorClosure$fArrowPlusClosure$fArrowZeroClosure$fArrowLoopClosure$fArrowClosure$fCategoryTYPEClosure$fStrongClosure$fClosedClosure$fProfunctorComonadClosure"$fProfunctorFunctorTYPETYPEClosure$fProfunctorClosure$fClosedEnvironment($fProfunctorAdjunctionEnvironmentClosure$fProfunctorMonadEnvironment&$fProfunctorFunctorTYPETYPEEnvironment$fProfunctorEnvironment$fFunctorEnvironment CopastroSumrunCopastroSum CotambaraSumCochoiceunleftunright PastroSum TambaraSum runTambaraSumChoiceleft'right' tambaraSum untambaraSum cotambaraSumuncotambaraSum$fChoiceTambara$fChoiceTannen $fChoiceSum$fChoiceProduct $fChoiceJoker$fChoiceForget$fChoiceWrappedArrow$fChoiceTagged$fChoiceCokleisli $fChoiceStar$fChoiceKleisli $fChoice->$fFunctorTambaraSum$fCategoryTYPETambaraSum$fChoiceTambaraSum$fProfunctorTambaraSum$fProfunctorComonadTambaraSum%$fProfunctorFunctorTYPETYPETambaraSum$fChoicePastroSum$fProfunctorMonadPastroSum$$fProfunctorFunctorTYPETYPEPastroSum)$fProfunctorAdjunctionPastroSumTambaraSum$fProfunctorPastroSum$fFunctorPastroSum$fCochoiceForget $fCochoiceSum$fCochoiceProduct$fCochoiceTannen$fCochoiceStar$fCochoiceCostar $fCochoice->$fFunctorCotambaraSum$fCochoiceCotambaraSum$fProfunctorComonadCotambaraSum'$fProfunctorFunctorTYPETYPECotambaraSum$fProfunctorCotambaraSum$fCochoiceCopastroSum$fProfunctorMonadCopastroSum&$fProfunctorFunctorTYPETYPECopastroSum-$fProfunctorAdjunctionCopastroSumCotambaraSum$fProfunctorCopastroSum$fFunctorCopastroSumFreeTraversingCofreeTraversingrunCofreeTraversing Traversing traverse'wanderfirstTraversingsecondTraversingdimapWandering lmapWandering rmapWanderingleftTraversingrightTraversing$fProfunctorBazaar$fApplicativeBazaar$fProfunctorBaz$fTraversableBaz $fFoldableBaz$fTraversingTannen$fTraversingStar$fTraversingKleisli$fTraversingForget$fTraversing->#$fProfunctorComonadCofreeTraversing+$fProfunctorFunctorTYPETYPECofreeTraversing$fTraversingCofreeTraversing$fChoiceCofreeTraversing$fStrongCofreeTraversing$fProfunctorCofreeTraversing$fProfunctorMonadFreeTraversing)$fProfunctorFunctorTYPETYPEFreeTraversing$fTraversingFreeTraversing$fChoiceFreeTraversing$fStrongFreeTraversing$fProfunctorFreeTraversing$fFunctorFreeTraversing $fFunctorBaz$fFunctorBazaar FreeMapping CofreeMappingrunCofreeMappingMappingmap'roam wanderMappingtraverseMapping closedMapping$fMappingTannen $fMappingStar$fMappingKleisli $fMapping-> $fProfunctorComonadCofreeMapping($fProfunctorFunctorTYPETYPECofreeMapping$fMappingCofreeMapping$fTraversingCofreeMapping$fClosedCofreeMapping$fChoiceCofreeMapping$fStrongCofreeMapping$fProfunctorCofreeMapping$fProfunctorMonadFreeMapping&$fProfunctorFunctorTYPETYPEFreeMapping$fMappingFreeMapping$fTraversingFreeMapping$fClosedFreeMapping$fChoiceFreeMapping$fStrongFreeMapping$fProfunctorFreeMapping$fFunctorFreeMapping $fFunctorBarCosievecosieveSievesieve$fSieveForgetConst $fSieveStarf$fSieveKleislim$fSieve->Identity$fCosieveCostarf$fCosieveTaggedProxy$fCosieveCokleisliw$fCosieve->IdentityCoprep runCoprepPrepCorepresentableCorep cotabulate RepresentableReptabulatefirstRep secondRep tabulated unfirstCorep unsecondCorep closedCorep cotabulatedprepAdj unprepAdjprepUnit prepCounit coprepAdj uncoprepAdj coprepUnit coprepCounit$fRepresentableForget$fRepresentableStar$fRepresentableKleisli$fRepresentable->$fCorepresentableCostar$fCorepresentableTagged$fCorepresentableCokleisli$fCorepresentable-> $fMonadPrep$fApplicativePrep $fFunctorPrep$fFunctorCoprepRiftrunRift Procompose procomposedidlidrassocstarscostarskleislis cokleislis decomposeRiftetamu$fCostrongProcompose$fMappingProcompose$fTraversingProcompose$fClosedProcompose$fChoiceProcompose$fStrongProcompose$fCorepresentableProcompose$fCosieveProcomposeCompose$fRepresentableProcompose$fSieveProcomposeCompose$fFunctorProcompose$fProfunctorProcompose$fProfunctorMonadProcompose"$fProfunctorFunctorTYPEkProcompose$$fProfunctorAdjunctionProcomposeRift$fCategorykRift $fFunctorRift$fProfunctorRift$fProfunctorComonadRift$fProfunctorFunctorTYPEkRift Codensity runCodensityRanrunRan decomposeRan precomposeRancurryRan uncurryRandecomposeCodensity$fCategorykRan $fFunctorRan$fProfunctorRan$fProfunctorComonadRan$fProfunctorFunctorkTYPERan$fCategorykCodensity$fFunctorCodensity$fProfunctorCodensityCayley runCayley mapCayley$fArrowPlusCayley$fArrowZeroCayley$fArrowLoopCayley$fArrowChoiceCayley $fArrowCayley$fCategorykCayley$fMappingCayley$fTraversingCayley$fClosedCayley$fCochoiceCayley$fChoiceCayley$fCostrongCayley$fStrongCayley$fProfunctorCayley$fProfunctorComonadCayley$fProfunctorMonadCayley!$fProfunctorFunctorTYPETYPECayleyCoyonedaYoneda runYoneda extractYonedaduplicateYonedareturnCoyoneda joinCoyoneda$fTraversingYoneda$fMappingYoneda$fClosedYoneda$fCochoiceYoneda$fCostrongYoneda$fChoiceYoneda$fStrongYoneda$fCategoryTYPEYoneda$fProfunctorMonadYoneda$fProfunctorComonadYoneda!$fProfunctorFunctorTYPETYPEYoneda$fFunctorYoneda$fProfunctorYoneda$fTraversingCoyoneda$fMappingCoyoneda$fClosedCoyoneda$fCochoiceCoyoneda$fCostrongCoyoneda$fChoiceCoyoneda$fStrongCoyoneda$fCategoryTYPECoyoneda$fProfunctorMonadCoyoneda$fProfunctorComonadCoyoneda#$fProfunctorFunctorTYPETYPECoyoneda$fProfunctorCoyoneda$fFunctorCoyonedabaseControl.Categoryid.ghc-primGHC.PrimcoerceGHC.BaseFunctor Control.Arrow ArrowLooploop Data.TupleswapsecondfirstfstsndArrowCategoryuncurrycurryconst$ Data.EitherEithereitherRightLeftrightleft$comonad-5.0.8-EA0Scey7jOW6LX5RvNTIb8Control.ComonadextractData.TraversabletraversefmapData.Functor.ComposeCompose getComposeData.Functor.IdentityIdentity runIdentityIsoKleisliMonad CokleisliMonoid Applicative