úÎ1B.°     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 profunctor 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"  Note: Here we use  as an approximate costrength.  Generalizing upstar of a strong  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 "  !"#$%&'()*+,-./01       !"#$%&'()*+,-./012      !" #$%&'()*+,-./012345678profunctors-3.1.3Data.Profunctor.UnsafeData.Profunctor Profunctordimaplmaprmap#..# Prismatic prismatic Lenticular lenticular WrappedArrow WrapArrow unwrapArrowDownStar runDownStarUpStar runUpStarbaseControl.Categoryid. Unsafe.Coerce unsafeCoerce$fProfunctorCokleisli$fProfunctorKleisli$fProfunctorTagged$fProfunctor(->)GHC.BaseFunctorData.Traversable Traversable$fPrismaticDownStarsequence$fPrismaticCokleisli$fPrismaticWrappedArrow$fPrismaticTagged$fPrismaticKleisli$fPrismatic(->)$fLenticularWrappedArrow$fLenticularUpStar$fLenticularKleisli$fLenticular(->)$fProfunctorWrappedArrow$fArrowLoopWrappedArrow$fArrowApplyWrappedArrow$fArrowChoiceWrappedArrow$fArrowZeroWrappedArrow$fArrowWrappedArrow$fCategoryWrappedArrow$fFunctorDownStar$fProfunctorDownStar$fFunctorUpStar$fProfunctorUpStar