9

我想了解阴影和嵌套函数的机制是如何工作的。例如：

let func y =
    let dup y = y + y
    let z = dup y
    let dup y =
        let dup z =
            let y = y * z
            y
        let z = y
        y
    dup z + z;;

val func : int -> int

> func 3;;
val it : int = 12

有人可以解释这里发生了什么吗？

4

2 回答 2

17

您的代码等效于以下代码，其中我只是对您的姓名实例进行了编号，以帮助您可视化阴影是如何发生的。

let func y0 = 
  let dup0 y1 = y1 + y1
  let z0 = dup0 y0
  let dup1 y2 = 
    let dup2 z1 = 
      let y3 = y2 * z1 
      y3
    let z2 = y2 
    y2 
  dup1 z0 + z0

当然，这可以进一步简化。由于dup2和z2从未使用过，dup1等价于let dup1 y2 = y2，整个函数等价于

let func y0 =
  let dup0 y1 = y1 + y1
  let z0 = dup0 y0
  dup1 z0 + z0

这相当于

let func y0 =
  let z0 = y0 + y0
  z0 + z0

通过替换。这与

let func y0 = 4 * y0

这有帮助吗？

于 2010-03-19T14:57:00.527 回答
14

我认为@kvb给出了一个很好的解释，说明了代码是如何评估的。该代码以一种非常令人困惑的方式结合了嵌套函数和阴影:-)。我认为分开看这两个概念很有用。

阴影允许您通过声明中的新值或构造let中的值绑定来隐藏值。match这意味着您将无法再访问原始值。这是一个更简单的例子：

let foo num =
  let num = num + 20 // Line 2
  let num = num * 2  // Line 3
  num

在这里，我们声明一个函数，它接受一个名为 的参数num。假设我们以 1 作为参数调用函数。在第二行，我们声明了一个同名的新值——初始化为1 + 20即21。第三行再次声明一个新值并将其初始化为21 * 2（因为它看到最后声明的num符号，其值为21）。在第 4 行，我们再次访问最后声明的num符号并返回42。

这主要是有用的，当你有一些计算来计算一些应该被所有后续计算使用的新值时。阴影允许您隐藏以前的值，因此不会有意外使用原始值的危险。

当您需要使用外部函数的参数进行一些局部效用计算时，嵌套函数非常有用。例如：

let times x nums = 
  let timesUtil y = y * x
  for n in nums do
    printfn "%d" (timesUtil n)

在这里，我们声明了一个实用程序嵌套函数timesUtil，它将任意数字乘以值x（这是times函数的参数）。然后我们可以稍后（在最后一行）使用它来执行操作，而无需x再次将值作为参数传递。因此，嵌套函数的主要有趣之处在于它们可以访问由外部函数声明的值。

于 2010-03-19T15:23:59.693 回答