Haskell：Where 与 Let

Question

我是 Haskell 的新手，我对 Where 与 Let 感到非常困惑。它们似乎都提供了相似的目的。我读过一些 Where 与 Let 之间的比较，但我很难辨别何时使用它们。有人可以提供一些背景信息或者一些示例来说明何时使用其中一种而不是另一种吗？

哪里与让

where 子句只能在函数定义级别定义。通常，这与 let 定义的范围相同。 唯一的区别是何时使用防护。 where 子句的范围涵盖所有防护。相反，let 表达式的作用域仅为当前函数子句和防护（如果有）。

Haskell 备忘单

Haskell Wiki 非常详细，提供了各种案例，但它使用了假设的示例。我发现它的解释对于初学者来说太简短了。

Let 的优点：

f :: State s a
f = State $ \x -> y
   where y = ... x ...

Control.Monad.State

不起作用，因为 where 指的是 模式匹配 f =，其中没有 x 是在范围之内。相反，如果你有 以 let 开头，然后你就不会 有麻烦了。

Haskell Wiki 关于 Let 的优点

f :: State s a
f = State $ \x ->
   let y = ... x ...
   in  y

Where 的优点：

f x
  | cond1 x   = a
  | cond2 x   = g a
  | otherwise = f (h x a)
  where
    a = w x

f x
  = let a = w x
    in case () of
        _ | cond1 x   = a
          | cond2 x   = g a
          | otherwise = f (h x a)

声明与表达式

Haskell wiki 提到 >Where 子句是声明性的，而 Let 表达式是表达性的。除了风格之外，它们的表现有何不同？

Declaration style                     | Expression-style
--------------------------------------+---------------------------------------------
where clause                          | let expression
arguments LHS:     f x = x*x          | Lambda abstraction: f = \x -> x*x
Pattern matching:  f [] = 0           | case expression:    f xs = case xs of [] -> 0
Guards:            f [x] | x>0 = 'a'  | if expression:      f [x] = if x>0 then 'a' else ...

1. 在第一个示例中，为什么 Let 在范围内，而 Where 不在范围内？
2. 是否可以将Where应用于第一个示例？
3. 有人可以将其应用于变量代表实际表达式的真实示例吗？
4. 何时使用每种方法是否有可遵循的一般经验法则？

---

更新

对于那些稍后通过该线程的人，我发现可以在这里找到最好的解释：“Haskell 简介”。

Let 表达式。

Haskell 的 let 表达式很有用 每当一组嵌套的绑定 必需的。举个简单的例子， 考虑：

令 y = a*b
    fx = (x+y)/y
在 fc + fd

由let创建的绑定集 表达式是相互递归的，并且 模式绑定被视为惰性绑定 模式（即它们带有隐含的 〜）。唯一的声明类型 允许的是类型签名， 函数绑定和模式 绑定。

Where 子句。

有时确定范围很方便 多个受保护的绑定 方程，这需要一个 where 子句：

<前><代码>fxy | y>z = ... | y==z = ... | y

请注意，这不能使用 let 表达式来完成，let 表达式仅作用于它所包含的表达式。仅允许在一组方程或 case 表达式的顶层使用 where 子句。 let 表达式中的绑定的相同属性和约束也适用于 where 子句中的绑定。这两种形式的嵌套作用域看起来非常相似，但请记住，let 表达式是表达式，而 where 子句不是——它是函数声明和 case 表达式语法的一部分。

Answer 1

1：示例中的问题

f :: State s a
f = State $ \x -> y
    where y = ... x ...

是参数x。 where 子句中的事物只能引用函数 f 的参数（没有）和外部作用域中的事物。

2：要在第一个示例中使用 where，您可以引入第二个命名函数
将 x 作为参数，如下所示：

f = State f'
f' x = y
    where y = ... x ...

或如下所示：

f = State f'
    where
    f' x = y
        where y = ... x ...

3: 这是一个不带 ... 的完整示例：

module StateExample where

data State a s = State (s -> (a, s))

f1 :: State Int (Int, Int)
f1 = State $ \state@(a, b) ->
    let
        hypot = a^2 + b^2
        result = (hypot, state)
    in result

f2 :: State Int (Int, Int)
f2 = State f
    where
    f state@(a, b) = result
        where
        hypot = a^2 + b^2
        result = (hypot, state)

4: 何时使用 < code>let 或 where 取决于个人喜好。我使用 let 来强调计算（通过将其移到前面），使用 where 来强调程序流程（通过将计算移到后面）。

Answer 2

虽然 ephemient 指出的守卫方面存在技术差异，但在概念上也存在差异，即您是否要将主公式与下面定义的额外变量（where）一起放在前面，或者您是否想要预先定义所有内容并将公式放在下面 (let)。每种风格都有不同的侧重点，并且您会在数学论文、教科书等中看到两种风格的使用。一般来说，那些非常不直观的变量，如果没有它们，公式就没有意义，应该在上面定义；由于上下文或其名称而直观的变量应在下面定义。例如，在 ehemient 的 hasVowel 示例中，vowels 的含义很明显，因此不需要在其用法之上定义它（忽略 let 由于以下原因而无法工作的事实）警卫）。

Answer 3

合法：

main = print (1 + (let i = 10 in 2 * i + 1))

不合法：

main = print (1 + (2 * i + 1 where i = 10))

合法：

hasVowel [] = False
hasVowel (x:xs)
  | x `elem` vowels = True
  | otherwise = False
  where vowels = "AEIOUaeiou"

不合法：（与 ML 不同）

let vowels = "AEIOUaeiou"
in hasVowel = ...

Answer 4

遗憾的是，这里的大多数答案对于初学者来说都太技术性了。

LHYFGG 有相关章节 - 如果您还没有阅读过，您应该阅读还没有，但本质上：

• where 只是一个语法结构（不是糖），仅在函数定义中有用。
• let ... in 本身就是一个表达式，因此您可以在任何可以放置表达式的地方使用它们。作为一个表达本身，它不能用于绑定守卫的东西。

最后，您也可以在列表推导式中使用 let ：

calcBmis :: (RealFloat a) => [(a, a)] -> [a]
calcBmis xs = [bmi | (w, h) <- xs, let bmi = w / h ^ 2, bmi >= 25.0]
-- w: width
-- h: height

我们在列表理解中包含一个let，就像我们在谓词中一样，只是它不过滤列表，它只绑定到名称。列表推导式中的 let 中定义的名称对于输出函数（| 之前的部分）以及绑定之后的所有谓词和部分可见。所以我们可以让我们的函数只返回 BMI >= 25 的人：

Answer 5

我发现 LYHFGG 中的这个示例很有帮助：

ghci> 4 * (let a = 9 in a + 1) + 2  
42  

let 是一个表达式，因此您可以在表达式可以放置的地方放置 let anywhere(!) 。

换句话说，在上面的示例中，不可能使用 where 来简单地替换 let （也许不使用一些更详细的 case 表达式与 where 结合）。