úÎ4$0é     portable provisionalEdward Kmett <ekmett@gmail.com>UnsafeFormally, the class  represents a profunctor  from Hask -> Hask. HIntuitively 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   to implement this combinator 2 and it has no way to validate that your function  meets the requirements. &If you implement this combinator with  $, 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 3 will only call this with a first argument that is  operationally identity. 7The 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 1 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   to implement this combinator 2 and it has no way to validate that your function  meets the requirements. &If you implement this combinator with  $, 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 4 will only call this with a second argument that is  operationally identity. () "a \p -> p `seq` \f ->  f p portable provisionalEdward Kmett <ekmett@gmail.com> TrustworthyThe generalization of  of a "costrong"  Minimal complete definition:  or  Note: We use   and !& as approximate costrength as needed.  Generalizing upstar of a strong  Minimal complete definition:   or   Note: Every  in Haskell is strong. Wrap an arrow for use as a . Lift a  into a  (backwards). Lift a  into a  (forwards). "# approximates  costrength $! approximates  costrength . %&'"$()*+,-./0123456789:;<=>   "   %&'"$()*+,-./0123456789:;<=>?      !"#$%&'()*%+,-./0123456789:;<=>?@ABCDEFGprofunctors-3.3.0.1Data.Profunctor.UnsafeData.ProfunctorProfuctor.Unsafe#. Profunctordimaplmaprmap.#Choiceleft'right'Strongfirst'second'Forget runForget WrappedArrow WrapArrow unwrapArrowDownStar runDownStarUpStar runUpStarbaseControl.Categoryid. Unsafe.Coerce unsafeCoerce$fProfunctorCokleisli$fProfunctorKleisli$fProfunctorTagged$fProfunctor(->)GHC.BaseFunctorData.Traversabletraverse comonad-3.1Control.Comonadextract$fChoiceDownStarsequence$fChoiceCokleisli$fChoiceForget$fChoiceWrappedArrow$fChoiceTagged$fChoiceUpStar$fChoiceKleisli $fChoice(->)$fStrongForget$fStrongWrappedArrow$fStrongUpStar$fStrongKleisli $fStrong(->)$fTraversableForget$fFoldableForget$fFunctorForget$fProfunctorForget$fProfunctorWrappedArrow$fArrowLoopWrappedArrow$fArrowApplyWrappedArrow$fArrowChoiceWrappedArrow$fArrowZeroWrappedArrow$fArrowWrappedArrow$fCategoryWrappedArrow$fFunctorDownStar$fProfunctorDownStar$fFunctorUpStar$fProfunctorUpStar