我已经看到根据模式定义了很多功能(f .) . g。例如：
countWhere = (length .) . filter
duplicate = (concat .) . replicate
concatMap = (concat .) . map
这是什么意思？
问问题
4975 次
2 回答
93
点运算符（即(.)）是函数组合运算符。定义如下：
infixr 9 .
(.) :: (b -> c) -> (a -> b) -> a -> c
f . g = \x -> f (g x)
如您所见，它接受一个类型函数b -> c和另一个类型函数a -> b并返回一个类型函数a -> c（即，它将第一个函数应用于第二个函数的结果）。
函数组合运算符非常有用。它允许您将一个函数的输出通过管道传输到另一个函数的输入。例如，您可以在 Haskell 中编写一个tac程序，如下所示：
main = interact (\x -> unlines (reverse (lines x)))
不太可读。但是，使用函数组合，您可以将其编写如下：
main = interact (unlines . reverse . lines)
如您所见，函数组合非常有用，但您不能在任何地方使用它。例如，您不能使用函数组合将输出通过管道传输filter到：length
countWhere = length . filter -- this is not allowed
不允许这样做的原因filter是 type (a -> Bool) -> [a] -> [a]。与它相比，a -> b我们发现a是 类型(a -> Bool)和b是 类型[a] -> [a]。这会导致类型不匹配，因为 Haskell 期望length是类型b -> c(ie ([a] -> [a]) -> c)。但是它实际上是 type [a] -> Int。
解决方案非常简单：
countWhere f = length . filter f
但是有些人不喜欢那种额外的悬垂f。他们更喜欢以countWhere无点风格编写如下：
countWhere = (length .) . filter
他们怎么得到这个？考虑：
countWhere f xs = length (filter f xs)
-- But `f x y` is `(f x) y`. Hence:
countWhere f xs = length ((filter f) xs)
-- But `\x -> f (g x)` is `f . g`. Hence:
countWhere f = length . (filter f)
-- But `f . g` is `(f .) g`. Hence:
countWhere f = (length .) (filter f)
-- But `\x -> f (g x)` is `f . g`. Hence:
countWhere = (length .) . filter
如您所见(f .) . g，很简单\x y -> f (g x y)。这个概念其实可以迭代：
f . g --> \x -> f (g x)
(f .) . g --> \x y -> f (g x y)
((f .) .) . g --> \x y z -> f (g x y z)
(((f .) .) .) . g --> \w x y z -> f (g w x y z)
它不漂亮，但它完成了工作。给定两个函数，您还可以编写自己的函数组合运算符：
f .: g = (f .) . g
f .:: g = ((f .) .) . g
f .::: g = (((f .) .) .) . g
使用(.:)运算符，您可以改写countWhere如下：
countWhere = length .: filter
有趣的是，尽管您也可以(.:)使用无点样式编写：
f .: g = (f .) . g
-- But `f . g` is `(.) f g`. Hence:
f .: g = (.) (f .) g
-- But `\x -> f x` is `f`. Hence:
(f .:) = (.) (f .)
-- But `(f .)` is `((.) f)`. Hence:
(f .:) = (.) ((.) f)
-- But `\x -> f (g x)` is `f . g`. Hence:
(.:) = (.) . (.)
同样我们得到：
(.::) = (.) . (.) . (.)
(.:::) = (.) . (.) . (.) . (.)
如您所见(.:)，(.::)和(.:::)只是 的幂(.)（即它们是 的迭代函数(.)）。对于数学中的数字：
x ^ 0 = 1
x ^ n = x * x ^ (n - 1)
同样对于数学中的函数：
f .^ 0 = id
f .^ n = f . (f .^ (n - 1))
如果f是(.)那么：
(.) .^ 1 = (.)
(.) .^ 2 = (.:)
(.) .^ 3 = (.::)
(.) .^ 4 = (.:::)
这使我们接近本文的结尾。对于最后一个挑战，让我们以无点风格编写以下函数：
mf a b c = filter a (map b c)
mf a b c = filter a ((map b) c)
mf a b = filter a . (map b)
mf a b = (filter a .) (map b)
mf a = (filter a .) . map
mf a = (. map) (filter a .)
mf a = (. map) ((filter a) .)
mf a = (. map) ((.) (filter a))
mf a = ((. map) . (.)) (filter a)
mf = ((. map) . (.)) . filter
mf = (. map) . (.) . filter
我们可以进一步简化如下：
compose f g = (. f) . (.) . g
compose f g = ((. f) . (.)) . g
compose f g = (.) ((. f) . (.)) g
compose f = (.) ((. f) . (.))
compose f = (.) ((. (.)) (. f))
compose f = ((.) . (. (.))) (. f)
compose f = ((.) . (. (.))) (flip (.) f)
compose f = ((.) . (. (.))) ((flip (.)) f)
compose = ((.) . (. (.))) . (flip (.))
使用compose你现在可以写成mf：
mf = compose map filter
是的，它有点难看，但它也是一个非常棒的令人难以置信的概念。您现在可以编写任何形式的函数\x y z -> f x (g y z)ascompose f g并且非常简洁。
于 2013-11-29T05:57:44.800 回答
13
这是一个品味问题，但我觉得这种风格令人不快。首先，我将描述它的含义，然后我提出一个我更喜欢的替代方案。
您需要知道这一点，(f . g) x = f (g x)并且(f ?) x = f ? x对于任何运营商而言?。由此我们可以推断
countWhere p = ((length .) . filter) p
= (length .) (filter p)
= length . filter p
所以
countWhere p xs = length (filter p xs)
我更喜欢使用一个名为.:
(.:) :: (r -> z) -> (a -> b -> r) -> a -> b -> z
(f .: g) x y = f (g x y)
然后countWhere = length .: filter。我个人觉得这更清楚。
（也可能在其他地方.:定义。）Data.Composition
于 2013-11-29T08:24:51.120 回答