# Profunctor

Profunctor is a typeclass provided by the profunctors package in Data.Profunctor.

See the "Remarks" section for a full explanation.

# (->) Profunctor

(->) is a simple example of a profunctor: the left argument is the input to a function, and the right argument is the same as the reader functor instance.

instance Profunctor (->) where
    lmap f g = g . f
    rmap f g = g . g

# Syntax

  • dimap :: Profunctor p => (a -> b) -> (c -> d) -> p b c -> p a d
  • lmap :: Profunctor p => (a -> b) -> p b c -> p a c
  • rmap :: Profunctor p => (b -> c) -> p a b -> p a c
  • dimap id id = id
  • lmap id = id
  • rmap id = id
  • dimap f g = lmap f . rmap g
  • lmap f = dimap f id
  • rmap f = dimap id f

# Remarks

Profunctors are, as described by the docs on Hackage, "a bifunctor where the first argument is contravariant and the second argument is covariant."

So what does this mean? Well, a bifunctor is like a normal functor, except that it has two parameters instead of one, each with its own fmap-like function to map on it.

Being "covariant" means that the second argument to a profunctor is just like a normal functor: its mapping function (rmap) has a type signature of Profunctor p => (b -> c) -> p a b -> p a c. It just maps the function on the second argument.

Being "contravariant" makes the first argument a little weirder. Instead of mapping like a normal functor, its mapping function (lmap) has a type signature of Profunctor p => (a -> b) -> p b c -> p a c. This seemingly backward mapping makes most sense for inputs to a function: you would run a -> b on the input, and then your other function, leaving the new input as a.

Note: The naming for the normal, one argument functors is a little misleading: the Functor typeclass implements "covariant" functors, while "contravariant" functors are implemented in the Contravariant typeclass in Data.Functor.Contravariant, and previously the (misleadingly named) Cofunctor typeclass in Data.Cofunctor.