我知道这是一个老问题，但这里有一个明确的WHNF, HNF和NF的数学定义。在纯lambda演算中:

如果一个项的形式是这样的，那么它就是NF λx1。λ x2. ...λ xn. (x t1 t2…tm) 其中x是一个变量，t1, t2，…， tm在NF中。 一个术语是HNF，如果它的形式是 λx1。λ x2. ...λ xn. (x e1 e2…em) 其中x是一个变量，e1, e2，…， em是任意的术语。 在WHNF中，如果一个项是任意项e的λ项xe，或者它是这样的形式 X e1 e2…新兴市场 其中x是一个变量，e1, e2，…， em是任意的术语。

现在考虑一种具有构造函数a,b,c…集合na, nb, nc…，这意味着无论何时t1, t2，…， tm在NF中，那么术语a t1 t2…Tm，其中m = na是一个redex，可以计算。例如，Haskell中的加法构造函数+具有arity 2，因为它只在给出两个标准形式的参数时才计算值(在本例中，整数本身可以被视为null构造函数)。

A term is in NF if it is of the form λ x1. λ x2. ... λ xn. (x t1 t2 ... tm) where x is either a variable or a constructor of arity n with m < n, and t1, t2, ..., tm are in NF. A term is in HNF if it is of the form λ x1. λ x2. ... λ xn. (x e1 e2 ... em) where x is either a variable or a constructor of arity n, and e1, e2, ... em are arbitrary terms so long as the first n arguments are not all in NF. A term is in WHNF if it is either a lambda term λ x. e for any term e or if it is of the form x e1 e2 ... em where x is either a variable or a constructor of arity n, and e1, e2, ... em are arbitrary terms so long as the first n arguments are not all in NF.

特别地，NF中的任何项都在HNF中，HNF中的任何项都在WHNF中，但不是相反的。

Haskell程序是表达式，它们通过执行求值来运行。

要计算表达式，请将所有函数应用程序替换为它们的定义。这样做的顺序并不重要，但仍然很重要:从最外层的应用程序开始，从左到右;这被称为惰性求值。

例子:

   take 1 (1:2:3:[])
=> { apply take }
   1 : take (1-1) (2:3:[])
=> { apply (-)  }
   1 : take 0 (2:3:[])
=> { apply take }
   1 : []

当没有剩余的功能应用程序需要替换时，计算就会停止。结果是标准形式(或简化标准形式，RNF)。无论以何种顺序求值表达式，最终都会得到相同的标准形式(但只有在求值结束时)。

对于惰性求值的描述略有不同。也就是说，你应该只计算弱头范式。表达式在WHNF中有三种情况:

构造函数:构造函数expression_1 expression_2… 内置函数的参数太少，比如(+)2或平方根 一个lambda表达式:\x ->表达式

换句话说，表达式的头(即最外层的函数应用程序)不能再求值，但函数参数可以包含未求值的表达式。

WHNF的例子:

3 : take 2 [2,3,4]   -- outermost function is a constructor (:)
(3+1) : [4..]        -- ditto
\x -> 4+5            -- lambda expression

笔记

WHNF中的“头”不是指列表的头，而是指最外层的函数应用程序。 有时，人们称未求值的表达式为“thunk”，但我不认为这是理解它的好方法。 头部标准型(HNF)与Haskell无关。它与WHNF的不同之处在于，lambda表达式的主体也在某种程度上被求值。

在图约简的实现中，对HNF的惰性求值迫使您处理lambda演算的名称捕获问题，而对WHNF的惰性求值则可以避免这个问题。

Simon Peyton Jones的《函数式编程语言的实现》第11章对此进行了解释。

http://foldoc.org/Weak+Head+Normal+Form上给出了一个很好的例子解释，头部范式甚至简化了函数抽象中的表达式位，而“弱”头部范式则止步于函数抽象。

从源头看，如果你有:

\ x -> ((\ y -> y+x) 2)

这是弱头部正常形式，但不是头部正常形式……因为可能的应用程序被卡在一个还不能求值的函数中。

实际的头部标准形式将难以有效地实现。这需要在函数内部进行操作。因此，弱头标准形式的优点是，您仍然可以将函数作为不透明类型来实现，因此它与编译语言和优化更加兼容。

WHNF不希望对lambdas的主体进行计算，因此

WHNF = \a -> thunk
HNF = \a -> a + c

seq希望它的第一个参数在WHNF中，因此

let a = \b c d e -> (\f -> b + c + d + e + f) b
    b = a 2
in seq b (b 5)

计算结果为

\d e -> (\f -> 2 + 5 + d + e + f) 2

而不是，什么会使用HNF

\d e -> 2 + 5 + d + e + 2

我知道这是一个老问题，但这里有一个明确的WHNF, HNF和NF的数学定义。在纯lambda演算中:

如果一个项的形式是这样的，那么它就是NF λx1。λ x2. ...λ xn. (x t1 t2…tm) 其中x是一个变量，t1, t2，…， tm在NF中。 一个术语是HNF，如果它的形式是 λx1。λ x2. ...λ xn. (x e1 e2…em) 其中x是一个变量，e1, e2，…， em是任意的术语。 在WHNF中，如果一个项是任意项e的λ项xe，或者它是这样的形式 X e1 e2…新兴市场 其中x是一个变量，e1, e2，…， em是任意的术语。

现在考虑一种具有构造函数a,b,c…集合na, nb, nc…，这意味着无论何时t1, t2，…， tm在NF中，那么术语a t1 t2…Tm，其中m = na是一个redex，可以计算。例如，Haskell中的加法构造函数+具有arity 2，因为它只在给出两个标准形式的参数时才计算值(在本例中，整数本身可以被视为null构造函数)。

A term is in NF if it is of the form λ x1. λ x2. ... λ xn. (x t1 t2 ... tm) where x is either a variable or a constructor of arity n with m < n, and t1, t2, ..., tm are in NF. A term is in HNF if it is of the form λ x1. λ x2. ... λ xn. (x e1 e2 ... em) where x is either a variable or a constructor of arity n, and e1, e2, ... em are arbitrary terms so long as the first n arguments are not all in NF. A term is in WHNF if it is either a lambda term λ x. e for any term e or if it is of the form x e1 e2 ... em where x is either a variable or a constructor of arity n, and e1, e2, ... em are arbitrary terms so long as the first n arguments are not all in NF.

特别地，NF中的任何项都在HNF中，HNF中的任何项都在WHNF中，但不是相反的。