haskell - "n+k patterns"是什么？为什么 Haskell 2010 禁止它们？

Question

阅读Wikipedia's entry on Haskell 2010时我偶然发现了这个:

-- using only prefix notation and n+k-patterns (no longer allowed in Haskell 2010)
factorial 0 = 1
factorial (n+1) = (*) (n+1) (factorial n)

“n+k 模式”是什么意思？我猜这是第二行，但我不明白它可能有什么问题。谁能解释一下那里有什么问题吗？为什么 Haskell 2010 中不更多地允许这些 n + k 模式？

Answer 1

n+k 模式是什么？看看这个:

$ ghci
GHCi, version 6.12.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Loading package ffi-1.0 ... linking ... done.
Prelude> let f 0 = 0 ; f (n+5) = n
Prelude> :t f
f :: (Integral t) => t -> t
Prelude> f 0
0
Prelude> f 1
*** Exception: <interactive>:1:4-24: Non-exhaustive patterns in function f

Prelude> f 2
*** Exception: <interactive>:1:4-24: Non-exhaustive patterns in function f

Prelude> f 3
*** Exception: <interactive>:1:4-24: Non-exhaustive patterns in function f

Prelude> f 4
*** Exception: <interactive>:1:4-24: Non-exhaustive patterns in function f

Prelude> f 5
0
Prelude> f 6
1

它们基本上是模式匹配的一个极其特殊的情况，它只适用于数字，并且......好吧，让我们礼貌地称其为这些数字的“意外事件”。

这里我有一个函数f，它有两个子句。第一个子句匹配 0 并且仅匹配 0。第二个子句匹配 Integral 类型且值为 5 或更大的任何值。绑定(bind)名称(n，在本例中)的值等于您传入的数字减 5。至于为什么它们已从 Haskell 2010 中删除，我希望您现在能明白原因只需一点思考。 (提示:考虑“最小意外原则”以及它在这里可能适用或不适用的情况。)

<小时/>

编辑添加:

既然这些结构被禁止，自然会出现一个问题:“你用什么来代替它们？”

$ ghci
GHCi, version 6.12.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Loading package ffi-1.0 ... linking ... done.
Prelude> let f 0 = 0 ; f n | n >= 5 = n - 5
Prelude> :t f
f :: (Num t, Ord t) => t -> t
Prelude> f 0
0
Prelude> f 1
*** Exception: <interactive>:1:4-33: Non-exhaustive patterns in function f

Prelude> f 2
*** Exception: <interactive>:1:4-33: Non-exhaustive patterns in function f

Prelude> f 3
*** Exception: <interactive>:1:4-33: Non-exhaustive patterns in function f

Prelude> f 4
*** Exception: <interactive>:1:4-33: Non-exhaustive patterns in function f

Prelude> f 5
0
Prelude> f 6
1

您会从类型语句中注意到它们并不完全相等，但使用防护是“足够相等”。在表达式中使用 n-5 可能会在多个地方使用它的任何代码中变得乏味且容易出错。答案是使用 where 子句:

Prelude> let f 0 = 0 ; f n | n >= 5 = n' where n' = n - 5
Prelude> :t f
f :: (Num t, Ord t) => t -> t
Prelude> f 0
0
Prelude> f 5
0
Prelude> f 6
1

where 子句允许您在多个位置使用计算表达式，而不会出现输入错误的风险。仍然存在必须在函数定义中的两个不同位置编辑边界值(在本例中为 5)的烦恼，但我个人认为这对于认知理解的提高来说是一个很小的代价。

<小时/>

进一步编辑以添加:

如果您更喜欢 let 表达式而不是 where 子句，这是一个替代方案:

Prelude> let f 0 = 0 ; f n | n >= 5 = let n' = n - 5 in n'
Prelude> :t f
f :: (Num t, Ord t) => t -> t
Prelude> f 0
0
Prelude> f 5
0

就是这样。我现在真的完成了。