无点样式并使用 $

Question

如何结合使用$ 和无点样式？

一个明显的例子是下面的实用函数：

times :: Int -> [a] -> [a]
times n xs = concat $ replicate n xs  

只写concat $ replicate 会产生错误，同样你也不能写concat . replicate，因为concat 需要一个值而不是一个函数。

那么你会如何把上面的函数变成无点样式呢？

Answer 1

你可以使用这个组合器：（冒号暗示后面跟着两个参数）

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

它可以让你摆脱n:

time = concat .: replicate

Answer 2

您可以轻松地编写一个几乎没有点的版本

times n  =  concat . replicate n

使用显式 curry 和 uncurry 可以实现完全无点的版本：

times  =  curry $ concat . uncurry replicate

Answer 3

上 freenode 并询问 lambdabot ;)

<jleedev> @pl \n xs -> concat $ replicate n xs
<lambdabot> (join .) . replicate

Answer 4

在 Haskell 中，函数组合是关联的¹：

f . g . h == (f . g) . h == f . (g . h)

任何infix operator 都只是一个很好的函数：

2 + 3 == (+) 2 3
f 2 3 = 2 `f` 3

composition operator 也只是一个二进制函数，higher-order 一个，它接受 2 个函数并返回一个函数：

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

因此，任何组合运算符都可以这样重写：

f . g == (.) f g
f . g . h == (f . g) . h == ((.) f g) . h == (.) ((.) f g) h
f . g . h == f . (g . h) == f . ((.) g h) == (.) f ((.) g h)

由于默认情况下currying，Haskell 中的每个函数都可以是partially applied。中缀运算符可以以非常简洁的方式部分应用，使用sections：

(-) == (\x y -> x - y)
(2-) == (-) 2 == (\y -> 2 - y)
(-2) == flip (-) 2 == (\x -> (-) x 2) == (\x -> x - 2)
(2-) 3 == -1
(-2) 3 == 1

由于组合运算符只是一个普通的二元函数，你也可以分段使用：

f . g == (.) f g == (f.) g == (.g) f

另一个有趣的二元运算符是$，它只是函数应用程序：

f x == f $ x
f x y z == (((f x) y) z) == f x y z
f(g(h x)) == f $ g $ h $ x == f . g . h $ x == (f . g . h) x

有了这些知识，我如何将concat $ replicate n xs 转换为无点样式？

times n xs = concat $ replicate n xs
times n xs = concat $ (replicate n) xs
times n xs = concat $ replicate n $ xs
times n xs = concat . replicate n $ xs
times n    = concat . replicate n
times n    = (.) concat (replicate n)
times n    = (concat.) (replicate n) -- concat is 1st arg to (.)
times n    = (concat.) $ replicate n
times n    = (concat.) . replicate $ n
times      = (concat.) . replicate

¹^{Haskell 基于category theory。范畴论中的范畴由 3 个事物组成：一些对象、一些态射和态射的组合概念。每个态射单向连接一个源对象和一个目标对象。范畴论要求态射的组合是关联的。 Haskell 中使用的一个类别称为 Hask，其对象是类型，而其态射是函数。函数f :: Int -> String 是将对象Int 连接到对象String 的态射。因此范畴论要求 Haskell 的函数组合具有关联性。}

Answer 5

通过扩展 FUZxxl 的答案，我们得到了

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

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

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

...

非常好。

奖金

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

嗯...所以也许我们应该说

(.1) = .

(.2) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
(.2) = (.1).(.1)

(.3) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
(.3) = (.1).(.2)
-- alternatively, (.3) = (.2).(.1)

(.4) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f
(.4) = (.1).(.3)
-- alternative 1 -- (.4) = (.2).(.2)
-- alternative 2 -- (.4) = (.3).(.1)

更好。

我们也可以把它扩展到

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

fmap4 :: (Functor f, Functor g, Functor h, functro i) 
   => (a -> b) -> f (g (h (i a))) -> f (g (h (i b)))
fmap4 f = fmap2 (fmap2 f)

遵循相同的模式。

将应用fmap 或(.) 的时间参数化会更好。但是，那些fmap 或(.)s 实际上在类型上有所不同。所以这样做的唯一方法是使用编译时间计算，例如TemplateHaskell。

对于日常使用，我只是建议

Prelude> ((.).(.)) concat replicate 5 [1,2]
[1,2,1,2,1,2,1,2,1,2]
Prelude> ((.).(.).(.)) (*10) foldr (+) 3 [2,1]
60