普通函数组合的类型为
(.) :: (b -> c) -> (a -> b) -> a -> c
我认为这应该适用于类似以下类型：
(.) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
diffsq a b = (a - b) ^ 2，但是感觉上我应该能够组合 (-) 和 (^2) 来编写类似于 diffsq = (^2) . (-) 的东西。(-) 的输入，通过使用 uncurry 进行转换，但这并不相同。我偏爱的实现方式是
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 次可以用于实现深度为 n 的 fmap！
由于函数形成一个 Functor，这为 n 个参数的处理提供了管道。
更多信息请参见Conal Elliott的语义编辑组合器。
fmap.first.fmap.second ::（Functor g，Functor f）=>（b-> c）-> f（g（d1，b），d）-> f（g（d1，c），d）。这些组合非常容易编写和阅读，因为它们提供了一条路径，穿过整个被编辑的值类型到实际被修改的子值。 - Conal.:，其定义为 .: = (.).(.)。 - fuzfmap或result组合子比.:方法更直观和有用，因为.:方法没有线性数量的实现方式。 - Edward Kmett(.) 实际上就是对函子 (->) c 进行特化的 fmap。 - Tsuyoshi Itoa -> b -> c 的函数是具有两个参数以及返回类型为 c 的函数，实际上它是一个具有一个参数以及返回类型为 b -> c 的函数。这是因为函数类型从右向左结合（即与 a -> (b -> c) 相同）。这使得我们无法使用标准的函数组合运算符。g :: c -> d 和 f :: a -> (b -> c) 的两个函数应用于类型为 (y -> z) -> (x -> y) -> (x -> z) 的 (.) 运算符。这意味着我们必须将 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
sumSq a = (^2) . (+a)。通过为第一个参数命名并应用它，我们构建了一个类型为 b -> c 的函数，可与常规组合函数一起使用。 - Thomas M. DuBuissoncompose2让我感到困惑。我一定会学会的。 - jameshfisher(g .) . f，但我承认它与节(section)一起看起来有点令人困惑 ((^2) .) . (-)。 - Maxx = [x]，那么它就会出现，因此 x = [[x]] = [[[x]]] 等等。顺便提一下，这让我想起了正则公理。 - LRDPRDX我不知道是否有一个标准库函数可以实现这个功能，但是实现它的点号模式是组合组合函数：
(.) . (.) :: (b -> c) -> (a -> a1 -> b) -> a -> a1 -> c
let (f .. g) a b = f (g a b)，但是 .. 是用于其他语法的。而 ... 看起来也不太对。 - dave4420(.) 如何与只有一个参数的函数交互。 - mightybyte我本来想在评论中写这个，但它有点长，并且涉及到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提到的链接fmap），定义下一级别是多么的容易。
(.***) = (.) . (.**)
实际上，从compose12开始，写函数名比写运算符更短。
f .*********** g
f `compose12` g
虽然数星号很繁琐，所以我们可能希望在4或5个星号处停止惯例。
[编辑] 另一个随机的想法，我们可以使用 .: 表示compose2，.:. 表示compose3，.:: 表示compose4，.::.表示compose5，.:::表示compose6，让点号的数量（除了初始点号之外）在视觉上标记需要深入的参数数目。不过我认为我还是更喜欢星号。
.：，compose3是.：。，那么compose必须是“..”，但它不是！这太不公平了！ - Rotsordiffsq = ((^ 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
我认为以下是实现你想要的优雅方式。 Functor 类型类提供了一种将函数“推入”容器中的方法，以便您可以使用 fmap 将其应用于每个元素。 您可以将函数 a -> b 视为一个容器，其中每个元素由 a 的一个元素索引，并且其值为 b。 因此，自然而然地创建此实例：
instance Functor ((->) a) where
fmap f g = f . g
我认为您可以通过导入适当的库来实现这一点，但我记不清是哪个库了。
现在，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而无需编写任何其他代码。
result在Hackage上的DeepArrow中以不同的一般形式定义。 - Conalo2更简单。 - Conal
blackbird :: (c -> d) -> (a -> b -> c) -> a -> -> b -> d。你可以将它视为对普通函数应用进行“后变换器”的应用。 - stephen tetleyuncurry (-)的解决方案，因为它比其他方案更简单，并指向了潜在的问题。 - George Co