假设我们有这个函数:

foo n = let comp      n = n * n * n + 10 
            otherComp n = (comp n) + (comp n) 
        in  (otherComp n) + (otherComp n) 

comp n 实际执行了多少次？ 1个还是4个？ Haskell 是否在 let 的范围内“存储”函数结果？

请您参考如下方法:

在 GHCi 中，没有优化，四次。

> import Debug.Trace 
> :{ 
| f x = let comp n      = trace "A" n 
|           otherComp n = comp n + comp n 
|       in  otherComp x + otherComp x 
| :} 
> f 10 
A 
A 
A 
A 
40 

通过优化，GHC 可能能够内联函数并优化所有内容。但是，在一般情况下，我不会指望 GHC 将多个调用优化为一个。这将需要内存和/或 CSE(公共(public)子表达式消除)，这并不总是一种优化，因此 GHC 对此相当保守。

作为经验法则，在评估性能时，期望代码中的每个(评估的)调用都对应于运行时的实际调用。

以上讨论仅适用于函数 绑定(bind)。对于仅由一个变量组成的简单模式绑定(bind)，例如

let x = g 20 
in x + x 

然后 g 20 将被计算一次，绑定(bind)到 x，然后 x + x 将重复使用相同的值两次。有一个条件:x 被分配了一个单态类型。

如果 x 被分配了一个带有类型类约束的多态类型，那么它就会伪装成一个函数。

> let x = trace "A" (200 * 350) 
> :t x 
x :: Num a => a 
> x + x 
A 
A 
140000 

上面，200 * 350 被重新计算了两次，因为它有一个多态类型。

这主要只发生在 GHCi 中。在常规的 Haskell 源文件中，GHC 使用 Dreaded Monomorphism Restriction提供 x 单态类型，正是为了避免重新计算变量。如果做不到，需要重复计算，GHC 宁愿抛出一个错误，也不愿默默地重新计算。 (在 GHCi 中，DMR 被禁用以使更多代码按原样工作，并且会发生重新计算，如上所示。)

总结:变量绑定(bind) let x = ... 在源代码中应该没问题，并且可以按预期工作而无需重复计算。如果您想完全确定，请使用显式单态类型注释来注释 x。