功能组合是否依赖部分应用程序？

Question

函数组合是否依赖部分应用程序？

这是我的理解：

观察以下函数调用重复的函数：

let updateCells (grid:Map<(int * int), Cell>) =

    grid |> Map.toSeq
         |> Seq.map snd
         |> Seq.fold (fun grid c -> grid |> setReaction (c.X, c.Y)) grid

let mutable _cells = ObservableCollection<Cell>( grid |> Map.toSeq
                                                      |> Seq.map snd
                                                      |> Seq.toList )
let cycleHandler _ = 

    self.Cells <- ObservableCollection<Cell>( grid |> cycleThroughCells
                                                   |> Map.toSeq
                                                   |> Seq.map snd
                                                   |> Seq.toList )

如果您注意到，以下代码出现在所有三个函数中：

grid |> Map.toSeq
     |> Seq.map snd

功能组合

在函数式编程中，我们可以将函数融合在一起，使它们成为一个函数。

为此，让我们从重复的函数序列中创建一个新函数：

let getCells = Map.toSeq >> Seq.map snd >> Seq.toList

现在，如果您细心，您会注意到我们在使用函数组合时不使用任何参数。因此，不使用网格值。这背后的原因是因为部分应用。

部分申请

我仍在学习所有这些函数式编程技术。但是，我的理解是，部分应用程序是函数式编程中的一种技术，它推迟了接受给定函数的完整参数集的需要。换句话说，部分应用是延迟接受给定函数的完整参数集的行为，其中期望最终客户端稍后将提供其余参数。至少，这是我的理解。

我们现在可以采用如下函数：

let updateCells (grid:Map<(int * int), Cell>) =

    grid |> Map.toSeq
         |> Seq.map snd
         |> Seq.fold (fun grid c -> grid |> setReaction (c.X, c.Y)) grid

并将其重构为：

let updateCells (grid:Map<(int * int), Cell>) =

    grid |> getCells
         |> Seq.fold (fun grid c -> grid |> setReaction (c.X, c.Y)) grid

我对函数组合与部分应用相结合的想法是否准确？

Answer 1

泛型

其实，如果你拿这个表达方式

let getCells = Map.toSeq >> Seq.map snd >> Seq.toList

并尝试将其编译为独立表达式，您将收到编译器错误：

错误 FS0030：值限制。值“getCells”已被推断为具有泛型类型 val getCells : (Map -> '_b 列表) 当 '_a : 比较
将“getCells”的参数设为显式，或者，如果您不希望它是通用的，请添加类型注释。

它在您的情况下起作用的原因是因为您使用getCells 函数与grid，这意味着编译器推断它具有受约束的类型。

为了保持通用性，您可以使用显式参数重新表述它：

let getCells xs = xs |> Map.toSeq |> Seq.map snd |> Seq.toList

此表达式是Map<'a,'b> -> 'b list when 'a : comparison 类型的有效独立表达式。

无积分

与>> 函数组合运算符一起使用的样式称为point-free。它适用于部分应用程序，但并不完全相同。

应用

不过，这个例子中有一个偏函数应用的例子：

let getCells xs = xs |> Map.toSeq |> Seq.map snd |> Seq.toList

函数snd有以下类型：

'a * 'b -> 'b

这是一个接受单个参数的函数。

你也可以编写上面的getCells函数没有部分应用snd函数：

let getCells xs = xs |> Map.toSeq |> Seq.map (fun x -> snd x) |> Seq.toList

请注意，您可以传递一个 lambda 表达式，而不是传递给 Seq.map 的部分应用函数。 getCells函数仍然是由其他函数组成的函数，但不再依赖于snd的部分应用。

因此，部分（双关语）回答您的问题：函数组合不必依赖部分函数组合。

柯里化

在 F# 中，函数默认为 curried。这意味着所有函数都采用 one 参数，并返回一个值。有时（通常），返回值是另一个函数。

以Seq.map 函数为例。如果使用 one 参数调用它，则返回值为 another 函数：

Seq.map snd

这个表达式的类型是seq<'a * 'b> -> seq<'b>，因为Seq.map snd的返回值是另一个函数。

Eta 减少

这意味着您可以对上述 lambda 表达式 fun x -> snd x 执行 Eta 归约，因为 x 出现在表达式的两侧。结果就是snd，整个表达式变成了

let getCells xs = xs |> Map.toSeq |> Seq.map snd |> Seq.toList

如您所见，部分应用对于函数组合来说并不是必要的，但它确实使它更容易。

公正

上述使用管道运算符 (|>) 的组合仍然依赖于函数 Map.toSeq、Seq.map 等的部分应用。为了证明组合不依赖于部分应用，这里有一个“不偏不倚”（partial 的反义词？（双关语））替代方案：

let getCells xs =
    xs
    |> (fun xs' -> Map.toSeq xs')
    |> (fun xs' -> Seq.map (fun x -> snd x) xs')
    |> (fun xs' -> Seq.toList xs')

请注意，此版本广泛使用 lambda 表达式而不是部分应用程序。

我不会以这种方式编写函数；我只包括这个替代方案来证明它是可以做到的。

Answer 2

组合依赖于一等函数，而不是真正依赖于部分应用程序。

实现组合需要的是：

• 函数必须能够作为参数并作为返回值返回
• 函数签名必须是有效类型（如果您希望组合是强类型）

部分应用程序为组合创造了更多机会，但原则上您可以轻松定义没有它的函数组合。

例如，C#没有部分应用*，但你仍然可以将两个函数组合在一起，只要签名匹配即可：

Func<a, c> Compose<a, b, c>(this Func<a, b> f, 
                            Func<b, c> g) 
{
    return x => g(f(x));
}

这只是>>，语法更丑：f.Compose(g)。

但是，组合和部分应用之间有一个有趣的联系。 >> 运算符的定义是：

let (>>) f g x = g(f(x))

因此，当您编写foo >> bar 时，您确实部分应用(>>) 函数，即省略x 参数以获得fun x = g(f(x)) 部分结果。

但是，正如我上面所说，这不是绝对必要的。上面的Compose函数相当于F#的>>操作符，不涉及任何偏应用； lambda 以稍微冗长的方式执行相同的角色。

---

* 除非您手动实现它，否则没人会这样做。 IE。而不是写

string foo(int a, int b) 
{ 
    return (a + b).ToString(); 
}

你必须写

Func<int, string> foo(int a) 
{ 
    return b => (a + b).ToString(); 
}

然后您就可以像在 F# 中一样分别传递每个参数。