怎么才叫 lazy 呢？

flw

原帖由 win_hate 于 2009-3-31 22:03 发表

我以前没贴过啊？

Exercise 1.5.  Ben Bitdiddle has invented a test to determine whether the interpreter he is faced with is using applicative-order evaluation or normal-order evaluation. He defines the following two procedures:

(define (p) (p))

(define (test x y)
  (if (= x 0)
      0
      y))

Then he evaluates the expression

(test 0 (p))

What behavior will Ben observe with an interpreter that uses applicative-order evaluation? What behavior will he observe with an interpreter that uses normal-order evaluation? Explain your answer. (Assume that the evaluation rule for the special form if is the same whether the interpreter is using normal or applicative order: The predicate expression is evaluated first, and the result determines whether to evaluate the consequent or the alternative expression.)

roy_hu

原帖由 flw 于 2009-3-31 22:00 发表
哦？
我换成 2 `div` 0 之后确实是可以的。
难道 Haskell 居然是 normal order 的？

拜托把http://en.wikibooks.org/wiki/Haskell/Laziness 和 http://en.wikipedia.org/wiki/Eva ... n-strict_evaluation 看完再来误导新手。

flw

原帖由 roy_hu 于 2009-3-31 22:06 发表


拜托把http://en.wikibooks.org/wiki/Haskell/Laziness 和 http://en.wikipedia.org/wiki/Eva ... n-strict_evaluation 看完再来误导新手。

嗯，这两个页面确实很不错。

win_hate

一些纯函式语言是使用 normal 序的，但 normal 序效率有时候很低，这是早期函式语言面对的一个困难。后来 David Turner 提出了图规约，可以使同名的表达式只求值一次。Haskell 应该也是采用这种技术的。

izhier

原帖由 win_hate 于 2009-3-31 21:59 发表

g=g

f b x y = if b then x else y


执行 g 会陷入无限循环。

f True 1 g 得到 1。

f False 1 g 无限循环。

这个并不能证明 lazy　的特性吧？

下面这个程序和这个差不多吧？
python：

1. 
   
2. >>> def g():
   
3. ...     g()
   
4. ...
   
5. >>> def f(cond, a, b):
   
6. ...     if cond:
   
7. ...             return a
   
8. ...     else:
   
9. ...             b()
   
10. ...
    
11. >>> f(True, 5, g)
    
12. 5
    
13. >>> f(False, 5, g)
    
14. Traceback (most recent call last):
    
15.   File "<stdin>", line 1, in <module>
    
16.   File "<stdin>", line 5, in f
    
17.   File "<stdin>", line 2, in g
    
18. ...
    
19. ...
    
20. ...
    
21. RuntimeError: maximum recursion depth exceeded
    

复制代码

[ 本帖最后由 izhier 于 2009-3-31 23:20 编辑 ]

win_hate

python 里对 g 求值是个函数对象吧？

在 haskell 里， g 是个无限递归的表达式。 只要 g 一下就溢出了。

izhier

原帖由 win_hate 于 2009-3-31 23:35 发表
在 haskell 里， g 是个无限递归的表达式。 只要 g 一下就溢出了。

原来 g 是个表达式！

MMMIX

原帖由 win_hate 于 2009-3-31 22:30 发表
一些纯函式语言是使用 normal 序的，但 normal 序效率有时候很低，这是早期函式语言面对的一个困难。后来 David Turner 提出了图规约，可以使同名的表达式只求值一次。Haskell 应该也是采用这种技术的。

嗯。

flw

原帖由 win_hate 于 2009-3-31 23:35 发表
python 里对 g 求值是个函数对象吧？

在 haskell 里， g 是个无限递归的表达式。 只要 g 一下就溢出了。

嗯，Python 里面等效的写法是 g()。