haskell - 笛卡尔(Profunctor)的例子？

Question

我正在检查以下代码示例，发现一旦实现“first”并成为Cartisian的成员，就很难弄清楚如何使用(->)和(Star f)。

有人可以为他们提供一些易于理解的示例吗？谢谢。

-- Intuitively a profunctor is cartesian if it can pass around additional
-- context in the form of a pair.

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

  second :: p a b -> p (c, a) (c, b)
  second = dimap swapP swapP . first

instance Cartesian (->) where
  first :: (a -> b) -> (a, c) -> (b, c)
  first f = f `cross` id

instance Functor f => Cartesian (Star f) where
  first :: Star f a b -> Star f (a, c) (b, c)
  first (Star f) = Star $ (\(fx, y) -> (, y) <$> fx) . (f `cross` id)

Answer 1

注意，提前发表意见!

断言者有点过于抽象。 IMO，我们首先应该谈论类别；实际上，大多数发音者都是类别，反之亦然。该profunctor类可能具有有效的用途，但实际上受到的限制更大，并且与 Hask 类别相关。我更愿意通过讨论其箭头构造函数是最后一个参数中的 Hask -functors和pænultimate参数中相反的 Hask -functors的类别来使之明确。是的，这是一个令人mouth舌的问题，但这就是重点:这实际上是一个非常具体的情况，而且通常事实证明您确实只需要一个不太具体的类别。
具体而言，Cartesian更自然地被视为一类类别，而不是发音者:

class Category k => Cartesian k where
  swap :: k (a,b) (b,a)
  (***) :: k a b -> k a' b' -> k (a,a') (b,b')

哪个许可

first :: Cartesian k => k a b -> k (a,c) (b,c)
first f = f *** id
second :: Cartesian k => k a b -> k (c,a) (c,b)
second f = id *** f

这是category-agnostic id 。 (您还可以根据***，second和first来定义second f=swap.first f.swap和f***g=first f.second g，但这与IMO的纠缠不清。)

为了了解为什么我更喜欢这样而不是使用profunctor，我想举一个简单的例子，而不是profunctor:线性映射。

newtype LinearMap v w = LinearMap {
  runLinearMap :: v->w  -- must be linear, i.e. if v and w are finite-dimensional
                        -- vector spaces, the function can be written as matrix application.
 }

这是而不是的发音者:尽管您可以使用此特定实现编写dimag f g (LinearMap a) = LinearMap $ dimap f g a，但这不会保留线性。但是，这是笛卡尔类别:

instance Category LinearMap where
  id = LinearMap id
  LinearMap f . LinearMap g = LinearMap $ f . g
instance Cartesian LinearMap where
  swap = LinearMap swap
  LinearMap f *** LinearMap g = LinearMap $ f *** g

好的，这看起来很琐碎。为什么这很有趣？线性映射可以有效地存储为矩阵，但从概念上讲，它们首先是函数。因此，有必要像处理功能一样处理它们。在这种情况下，.有效地实现了矩阵乘法，并且***以类型安全的方式将block diagonal matrix放在一起。

显然，您还可以使用不受限制的函数来完成所有这些操作，因此instance Cartesian (->)确实是微不足道的。但是，我给出了线性映射的示例，以激发Cartesian类可以完成一些不需要它的琐碎工作。
Star变得非常有趣。

newtype Star f d c = Star{runStar :: d->f c}
instance Monad f => Category (Star f) where
  id = Star pure
  Star f . Star g = Star $ \x -> f =<< g x
instance Monad f => Cartesian (Star f) where
  swap = Star $ pure . swap
  Star f *** Star g = Star $ \(a,b) -> liftA2 (,) (f a) (g b)

Star是kleisli category的前身，您可能已经听说过，它是使用monadic计算链接的一种方法。因此，让我们直接来看一个IO示例:

readFile' :: Star IO FilePath String
readFile' = Star readFile

writeFile' :: Star IO (FilePath,String) ()
writeFile' = Star $ uncurry writeFile

现在我可以做类似的事情

copyTo :: Star IO (FilePath, FilePath) ()
copyTo = writeFile' . second readFile'

我为什么要这样呢？关键是，我已经将IO操作链接在一起，而没有使用可以窥视/修改传递的数据的接口。这对于安全应用程序可能会很有趣。 (我只是编造了这个示例；我敢肯定可以找到较少人为的示例。)

无论如何，到目前为止，我还没有真正回答这个问题，因为您不是在询问笛卡尔类别，而是在询问strong profunctors。那些确实提供了几乎相同的界面:

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

因此，我也可以进行微小的更改

copyTo :: Star IO (FilePath, FilePath) ()
copyTo = writeFile' . second' readFile'

保留基本上相同的示例，但使用Strong而不是Cartesian。我仍然在使用Category组合。我相信，没有任何组成，我们将无法建立非常复杂的示例。

最大的问题是:为什么会使用protunctor界面而不是基于类别的界面来？没有组合就必须解决哪些问题？答案很大程度上在于Category的Star实例:在这里，我对Monad f的要求很高。对于profunctor实例，这不是必需的:这些仅需要Functor f。因此，对于大多数关注的Star例子，它是一个强大的发音器，您需要查看的不是函子/单子的基本函子。在Van Laarhoven lenses中，与此类函子相关的重要应用程序以及这些函子的内部实现确实可能为强者提供了最有见地的例子。每当我浏览镜头库的源代码时，我都会一直感到头晕，但是我认为Strong Indexed是一个非常有影响力的实例。