(c→d) → (a→b→c) → (a→b→d) 类型的 Haskell 函数组合算子

Question

普通函数组合的类型

(.) :: (b -> c) -> (a -> b) -> a -> c

我认为这应该概括为以下类型：

(.) :: (c -> d) -> (a -> b -> c) -> a -> b -> d

一个具体的例子：计算差异平方。我们可以写diffsq a b = (a - b) ^ 2，但感觉我应该能够编写(-) 和(^2) 来写diffsq = (^2) . (-) 之类的东西。

我当然不能。我可以做的一件事是使用一个元组而不是(-) 的两个参数，通过使用uncurry 对其进行转换，但这不一样。

有可能做我想做的事吗？如果不是，我有什么误解让我认为它应该是可能的？

---

注意：这实际上已经被问到here，但没有给出答案（我怀疑必须存在）。

Answer 1

我的首选实现是

fmap . fmap :: (Functor f, Functor f1) => (a -> b) -> f (f1 a) -> f (f1 b)

如果只是因为它很容易记住。

分别将 f 和 f1 实例化为 (->) c 和 (->) d 时，您会得到类型

(a -> b) -> (c -> d -> a) -> c -> d -> b

这是

的类型

(.) . (.) ::  (b -> c) -> (a -> a1 -> b) -> a -> a1 -> c

但是fmap . fmap 版本更容易说出来，它可以推广到其他仿函数。

有时这写成fmap fmap fmap，但写成fmap . fmap 它可以更容易地扩展以允许更多参数。

fmap . fmap . fmap 
:: (Functor f, Functor g, Functor h) => (a -> b) -> f (g (h a)) -> f (g (h b))

fmap . fmap . fmap . fmap 
:: (Functor f, Functor g, Functor h, Functor i) => (a -> b) -> f (g (h (i a))) -> f (g (h (i b))

等等

一般fmap与自己组成n次可以用到fmapn个层次！

由于函数形成Functor，这为n个参数提供了管道。

有关详细信息，请参阅 Conal Elliott 的 Semantic Editor Combinators。

Answer 2

误解是你认为a -> b -> c 类型的函数是两个返回类型为c 的参数的函数，而实际上它是一个返回类型为b -> c 的参数的函数，因为函数类型关联到右边（即它与a -> (b -> c) 相同。这使得无法使用标准函数组合运算符。

要了解原因，请尝试将 (y -> z) -> (x -> y) -> (x -> z) 类型的运算符 (.) 应用于两个函数 g :: c -> d 和 f :: a -> (b -> c)。这意味着我们必须将y 与c 以及b -> c 统一起来。这没有多大意义。 y 怎么可能既是 c 又是返回 c 的函数？那必须是无限类型。所以这行不通。

仅仅因为我们不能使用标准的组合运算符，它并不能阻止我们定义自己的。

 compose2 :: (c -> d) -> (a -> b -> c) -> a -> b -> d
 compose2 g f x y = g (f x y)

 diffsq = (^2) `compose2` (-)

通常最好避免在这种情况下使用无点样式，而直接使用

 diffsq a b = (a-b)^2

Answer 3

我不知道执行此操作的标准库函数，但实现它的无点模式是组合组合函数：

(.) . (.) :: (b -> c) -> (a -> a1 -> b) -> a -> a1 -> c

Answer 4

我本来打算在评论中写这个，但是有点长，而且它来自于mightybyte和hammar。

我建议我们围绕运算符进行标准化，例如 .* 对应 compose2 和 .** 对应 compose3。使用mightybyte的定义：

(.*) :: (c -> d) -> (a -> b -> c) -> (a -> b -> d)
(.*) = (.) . (.)

(.**) :: (d -> e) -> (a -> b -> c -> d) -> (a -> b -> c -> e)
(.**) = (.) . (.*)

diffsq :: (Num a) => a -> a -> a
diffsq = (^2) .* (-)

modminus :: (Integral a) => a -> a -> a -> a
modminus n = (`mod` n) .* (-)

diffsqmod :: (Integral a) => a -> a -> a -> a
diffsqmod = (^2) .** modminus

是的，modminus 和 diffsqmod 是非常随机且毫无价值的函数，但它们很快并且显示了重点。请注意，通过在另一个 compose 函数中组合来定义下一个级别是多么容易（类似于 Edward 提到的链接 fmaps）。

(.***) = (.) . (.**)

实际上，从compose12 开始，写函数名比写操作符要短

f .*********** g
f `compose12` g

虽然计算星号很累，所以我们可能想在 4 或 5 停止约定。

---

[edit] 另一个随机的想法，我们可以使用 .: 代表 compose2，.:. 代表 compose3，.:: 代表 compose4，.::. 代表 compose5，.::: 代表 compose6，让点数（之后第一个）直观地标记要向下钻取的参数数量。不过我觉得我更喜欢星星。

Answer 5

正如Max 在comment 中指出的那样：

diffsq = ((^ 2) .) . (-)

您可以将f . g 视为将一个参数应用于g，然后将结果传递给f。 (f .) . g 将两个参数应用于g，然后将结果传递给f。 ((f .) .) . g 将三个参数应用于g，依此类推。

\f g -> (f .) . g :: (c -> d) -> (a -> b -> c) -> a -> b -> d

如果我们用某个函数f :: c -> d 左切组合运算符（左侧带有f 的部分应用程序），我们得到：

(f .) :: (b -> c) -> b -> d

所以我们有了这个新函数，它需要来自b -> c 的函数，但我们的g 是a -> b -> c，或者等效地是a -> (b -> c)。我们需要先申请a，然后才能得到我们需要的东西。好吧，让我们再迭代一次：

((f .) .) :: (a -> b -> c) -> a -> b -> d

Answer 6

我认为这是实现您想要的一种优雅的方式。 Functor 类型类提供了一种将函数“推送”到容器中的方法，因此您可以使用 fmap 将其应用于每个元素。您可以将函数a -> b 视为bs 的容器，其中每个元素由a 的元素索引。所以很自然的做这个实例：

instance Functor ((->) a) where
  fmap f g = f . g

（我想你可以通过import找到一个合适的库来获得它，但我不记得是哪个了。）

现在f 与g 的通常组合只是fmap：

o1 :: (c -> d) -> (b -> c) -> (b -> d)
f `o1` g = fmap f g

a -> b -> c 类型的函数是c 类型元素的容器容器。所以我们只需要将函数f 向下推两次。给你：

o2 :: (c -> d) -> (a -> (b -> c)) -> a -> (b -> d)
f `o2` g = fmap (fmap f) g

在实践中，您可能会发现您不需要o1 或o2，只需fmap。如果你能找到我忘记位置的图书馆，你可能会发现你可以直接使用fmap而不用写 任何额外的代码。