function - 部分应用Haskell中的几个函数

Question

假设，在 Haskell 中，我有一堆函数，它们都依赖于相同的参数类型:

f :: Par -> a -> b
g :: Par -> b -> c

当我编写更多仍然依赖于此参数类型的函数时，我可以执行类似的操作

h :: Par -> a -> c
h par = myg . myf
    where myf = f par
          myg = g par

但是我仍然需要编写这些 where 行。问题是:这可以避免吗？

[编辑:我试图提供一个最小的示例来说明问题，但显然这个示例太小而无法说明我想要的内容。实际问题中h当然不仅仅是f和g的复合。所以这里是一些实际的代码:

有功能

apply :: ChamberLattice -> ChLatword -> ChLatWord
reduce :: ChamberLattice -> ChLatWord -> ChLatWord

我正在定义一个函数

chaseTurn :: ChamberLattice -> Turn -> Parity -> ChLatWord -> ChLatWord
chaseTurn cl Straight _ xs = xs
chaseTurn cl t parity xs = if ((turn parity xs) == t)
                           then case myApply xs of
                               (y1:y2:ys) -> (y1:y2:(myChaseTurn t parity ys))
                               ys -> ys
                           else myReduce xs
where myApply = apply cl
      myChaseTurn = chaseTurn cl
      myReduce = reduce cl

]

(这个问题本质上与 Grouping functions in Haskell但我在那里使用了一些不幸的词语分散了人们的注意力。)

Answer 1

在 Haskell 中，所有函数都采用一个输入参数。但有时，应用函数的返回值是一个新函数。那么，作为第一步，您可以通过在函数的返回值 f 两边加上括号来使其更加明确。和g :

f :: Par -> (a -> b)
g :: Par -> (b -> c)

函数也是类型，因此我们可以任意决定别名 a -> b至φ (phi 而不是 f)和 b -> c至γ (gamma 而不是 g)。 (是的，当你用完字母时，你就可以使用希腊字母!)

这意味着您可以将函数视为具有类型

f :: Par -> φ
g :: Par -> γ

这些都是所谓的“reader monad”的自动实例，它也是一个(应用)仿函数。特别是(->) Par ，或者，如果有帮助的话，Par -> ，是 Applicative实例。这意味着您可以使用 pure和<*>有了它。

作为第一次尝试，您可以编写类似的内容

pure (\x y -> (x, y)) <*> f <*> g

为了简单地理解该组合物是如何工作的。该表达式的类型为 Par -> (φ, γ) ， 可以这么说。该 lambda 表达式只需 x来自f “容器”和 y来自g '容器'，并将它们组合在一个元组中。元组的第一个元素的类型为 φ ，第二个元素的类型为 γ .

插入 φ 的定义和γ ，您得到类型 Par -> (a -> b, b -> c) .

您想要组合这些函数，而不是作为函数元组的返回值。您可以使用函数组合运算符 .为此:

h = pure (\x y -> y . x) <*> f <*> g

请注意，函数是从右向左组成的，因此 x ( a -> b ) 首先出现，然后是 y (b -> c)。

但是，您可以翻转 f和g周围:

h = pure (\y x -> y . x) <*> g <*> f

该显式 lambda 表达式可以被 eta 简化为:

h = pure (.) <*> g <*> f

最后，不要写 pure (.) <*>您可以使用中缀 <$>运算符:

h = (.) <$> g <*> f

该函数的类型为 Par -> a -> c .