Simple Haskell implementation for Profunctor and Strong Profunctor to analyse Strong Profunctor laws

ProfunctorAndStrong.hs

swap (a, b) = (b, a)

class Profunctor p where
  dimap :: (aa -> a) -> (b -> bb) -> p a b -> p aa bb

  lmap ::  (aa -> a) ->              p a b -> p aa b
  lmap f = dimap f id

  rmap ::               (b -> bb) -> p a b -> p a  bb
  rmap = dimap id
  
instance Profunctor (->) where
  dimap aa bb ab = bb . ab . aa

class Profunctor p => Strong p where
  first  :: p a b -> p (a, c) (b, c)
  first = dimap swap swap . second
  second :: p a b -> p (c, a) (c, b)
  second = dimap swap swap . first

instance Strong (->) where
  first ab = \(a,c) -> (ab a, c)