Nuva 语言的渊源（3）之惰性计算

# Nuva 语言的渊源（3）之惰性计算

Nuva 语言的渊源 之 惰性计算

本文简要介绍了 Nuva 语言的渊源，主要包括 Nuva 语言的一些特色功能及其设计决策，说明 Nuva 语言缘何成为现在的样子，以及这些设计的考虑因素（其中也包括参考的其他编程语言，适合广大的编程语言爱好者阅读）。

Nuva 语言的介绍请参考 [Nuva 语言官方主页](http://macrobject.com/cn/nuva_language/index.htm)。

（续上文）

惰性计算也称懒惰计算，目的是省略一些计算步骤或者推迟计算的时间，从而提高机器的计算性能。

与惰性计算相对应的是积极计算，或者叫先行计算。之所以叫先行计算是因为这种计算是表达式的语法树按照后序遍历的方式进行计算，语法树中的子节点先于其父节点计算而得名。

大多数编程语言都是采用积极计算的方式来进行表达式计算。

从上面惰性计算定义的描述中可以看出，惰性计算也包括两种：短路计算和延迟计算。

短路计算通常用在逻辑表达式中，如果从逻辑表达式的第一个部分（或先计算的某个部分）就能推测整个逻辑表达式的值，从而免去计算整个表达式的部分时间，因此可以明显得到性能的提升。

Nuva 语言的逻辑表达式就是采用短路计算的。

如下的 Nuva 代码：

```
     <.
      function T1()
        result = true
        ?? 'T1'
      end function
      
      function T2()
        result = true
        ?? 'T2'
      end function
      
      function F1()
        result = false
        ?? 'F1'
      end function
      
      ?? T1() and T2() and F1()
      ?? '-------------------------------'
      ?? T1() and ( T2() or F1() )
      ?? '-------------------------------'
      ?? F1() or T1() and T2()
      ?? '-------------------------------'
      ?? F1() and T1() and T2()
      ?? '-------------------------------'
      ?? F1() or F1() and T1() and T2()
      ?? '-------------------------------'
      ?? not F1() or F1() and T1() and T2()
      ?? '-------------------------------'
    .>
```

可以得到如下的计算结果：

T1
T2
F1
False
-------------------------------
T1
T2
True
-------------------------------
F1
T1
T2
True
-------------------------------
F1
False
-------------------------------
F1
F1
False
-------------------------------
F1
True
-------------------------------

短路计算除了可以提高计算性能以外，还有一些明显的好处，看如下的代码：

```
    <.
      var node
      if (node <> nil and node.Parent <> nil)
        ?? 'node <> nil and node.Parent <> nil'
      end if

if (node = nil or node.Parent = nil)
        ?? 'node = nil or node.Parent = nil'
      end if
    .>
```

如果在不支持逻辑表达式短路计算的编程语言中执行上面的代码，就会有可能出现异常，因为上面的变量 node 有可能为空。这样必须采用下面的代码才能避免异常：

```
    <.
      var node
      if (node <> nil)
        if (node.Parent <> nil)
          ?? 'node <> nil and node.Parent <> nil'
        end if
      end if

if (node = nil)
        ?? 'node = nil or node.Parent = nil'
      elseif (node.Parent = nil)
        ?? 'node = nil or node.Parent = nil'
      end if
    .>
```

因此，短路计算除了能够提高计算性能，还能明显的改善程序的书写，更加简洁并且易读。

早期的 Basic 和 Pascal 都不支持短路计算，C 语言则从一开始就支持，Ada 语言对于两种计算都予以支持，可以让程序员选择采用哪种计算方式。

Basic 从 VB9 开始也加入了短路计算符，Pascal 也很早就从编译选项里支持短路计算。

现代的编程语言几乎都支持短路计算。

另一种惰性计算叫做延迟计算。延迟计算并不是为了提高计算的性能，而是这种计算能够创造出一种新型的和无限灵活的计算模型。

延迟计算主要用在函数式语言中，是 Lambda 演算的某种起点。

在 Lambda 演算的函数复合中，延迟计算起了关键的作用，试想如果函数作为参数被带入另一个函数时，如果立即参加计算，则函数复合就立即失去了意义，整个 Lambda 演算也就失去了意义。

在 Python 中，集合或者序列的运算中，经常用到基于 Lambda 演算的延迟计算。

Nuva 语言也有延迟计算的使用，主要用于循环和集合操作中，示例如下：

```
     <.
      var Set = ['a', "b", 'c']
      foreach (i = Set | i = 'b')
        ?? i
      end foreach
      
      var set1 = [i = Set | i = 'b']
      foreach (i = set1)
        ?? i
      end foreach
    .>
```

上面的代码得到如下的结果：

b
b

Nuva 语言中的延迟计算是 Lambda 的一种特例，其中要计算的延迟表达式只能有一个非函数自变量。

在下一版本中，Nuva 语言将支持完整的 Labmda 演算，加入函数式语言的一些特征。

（未完待续）

[Nuva 语言的渊源（1）](/wisdom-zh/archive/2006/08/20/493270.html): [http://www.cnblogs.com/wisdom-zh/archive/2006/08/20/493270.html](/wisdom-zh/archive/2006/08/20/493270.html)
[Nuva 语言的渊源（2）](/wisdom-zh/archive/2006/08/21/493269.html): [http://www.cnblogs.com/wisdom-zh/archive/2006/08/21/493269.html](/wisdom-zh/archive/2006/08/21/493269.html)