Re-use `Bifunctor` newtypes where appropriate

[garyb]

For the next round of breaking-change releases.

See #22 (comment)

[hdgarrood]

@joneshf, @MonoidMusician and I were discussing on Slack and here's what we came up with.

@joneshf suggested making the following a superclass of both Bifunctor and Profunctor, in functors:

class Functor1 f where
  rmap :: forall a b c. (b -> c) -> f a b -> f a c

We could then define all of the following in functors:

• newtype Clown f a b = Clown (f a)
• newtype Joker f a b = Joker (f b)
• newtype Wrap f a b = Wrap (f a b), with the instance Functor1 f => Functor (Wrap f a)
• newtype Flip f a b = Flip (f b a)
• newtype Product2 f g a b = Product2 (f a b) (g a b), so as not to overlap with the Product which is already in functors
• newtype Star f a b = Star (a -> f b)
• newtype Costar f b a = Costar (f b -> a)
• newtype Split f a b = Split (exists x. Tuple3 (a -> x) (x -> b) (f x))

All of these can have Functor1 instances, and additionally, we would define the following instances in bifunctors or profunctors as appropriate, in the same module as the class:

• Functor f => Bifunctor (Clown f)
• Contravariant f => Profunctor (Clown f)
• Functor f => Bifunctor (Joker f)
• Functor f => Profunctor (Joker f)
• Bifunctor f => Bifunctor (Wrap f)
• Profunctor f => Profunctor (Wrap f)
• Bifunctor f => Bifunctor (Flip f)
• no Profunctor (Flip f), as it's not possible without some "flipped profunctor" class
• Bifunctor f, Bifunctor g => Bifunctor (Product2 f g)
• Profunctor f, Profunctor g => Profunctor (Product2 f g)
• no Bifunctor (Star f), as it's not possible
• Functor f => Profunctor (Star f)
• Contravariant f => Bifunctor (Costar f)
• Functor f => Profunctor (Costar f)
• no Bifunctor (Split f), as it's not possible
• Profunctor (Split f)

The only potentially difficult instance is Profunctor f => Contravariant (Flip f a), as it needs to be in the same module as either Contravariant or Flip but it also needs to have Profunctor in scope. Maybe we can just accept defeat on that one and let Cowrap continue to exist in profunctors.

A nice bonus of this is that there is no longer any need to have two separate rmap functions.

[garyb]

Functor1 seems a little odd to me, I spent quite a while thinking about it, and finally realised why: rmap isn't really even something that needs to exist - it should always just be map. This is a case where quantified constraints would be great:

class (forall x. Functor (f x)) <= Bifunctor f where
  bimap :: forall a b c d. (a -> b) -> (c -> d) -> f a c -> f b d
  lmap :: forall a b c. (a -> b) -> f a c -> f b c

class (forall x. Functor (f x)) <= Profunctor f where
  dimap :: forall a b c d. (a -> b) -> (c -> d) -> f b c -> f a d
  lcmap :: forall a b c. (a -> b) -> f b c -> f a c

[hdgarrood]

Right, but I think, even if we had quantified constraints, it can still be useful sometimes to draw attention to the fact that you're mapping over the right-hand type variable in a type of kind Type -> Type -> Type (as opposed to just any Functor), so I think I would still appreciate the existence of an rmap. Also, I think the hierarchy is probably easier to grok with the formulation involving rmap.

[masaeedu]

@hdgarrood Can Clown really have a Functor1 instance?

EDIT: yes it can, b is phantom :)

[garyb]

Not really important, but I think the Functor1 here is more like FunctorR or something, since

class Functor1 t where
  map1 ∷ ∀ f g. (f ~> g) → t f → t g

[JordanMartinez]

Looking over this issue, so the final class name should be FunctorR then rather than Functor1?

[kl0tl]

Given purescript/purescript-bifunctors#17, should we rather name it FunctorRight (or rename ApplyLeft, ApplicativeLeft, BindLeft and MonadLeft to ApplyL, ApplicativeL, BindL and MonadL)?

[hdgarrood]

Using full words rather than abbreviations here sounds good to me.

[JordanMartinez]

I'll get started on this.

[JordanMartinez]

Flip can't be defined in functors because it's Functor instance depends on the p having a Bifunctor instance:

instance functorFlip :: Bifunctor p => Functor (Flip p a) where
  map f (Flip a) = Flip (lmap f a)

[JordanMartinez]

First PR here: purescript/purescript-functors#27