haskell 初学问疑

Question

2. f x =
3.   case x of
4.     1->-1
5.     2->2
6.     _->0
8. ERROR:
9. Syntax error in case expression (unexpected symbol "->-")

复制代码
1.以上代码出错可否判断 haskell 的运算符匹配是贪婪型的 ?

2.haskell 中大量运用递归，是否对程序的效率有影响 ?

3.python　中的 generator 是不是有 lazy　的影子 ?

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

Answer 1

原帖由 flw 于 2009-3-27 10:57 发表
yield 的语义，你真的明白了吗？

不是太明白你说的语义是什么？

generator　不是只有在需要返回值时，才再次运行函数吗？
难道这没有 lazy　吗？
是不是我对 lazy　的概念有点不清呀？

Answer 2

原帖由 izhier 于 2009-3-27 10:58 发表

python 中读文件时：

f = open("file.txt", 'r')
for each_line in f:
    do_something

以上也是一句一句的读文件，并不是一次性的把文件读完呀

注意语义。
f 是一个文件句柄，
而 readFile 返回的是一个字符串，且从语义上讲，这个字符串就是文件的所有内容。

我再强调一次，一定要搞清楚语义。
Python 的确可以一行一行的读文件，这很好。大多数语言都支持这个功能。

Answer 3

原帖由 flw 于 2009-3-27 00:14 发表
再比如 readFile "1G.file"，它的语义是把整个 1G 文件的内容都返回，
但是实际运行的时候，它并不会真的读 1G，也是需要多少就读多少。
这才是 lazy 的意思：语义承诺很多，但是实际做到刚好。

python 中读文件时：

2. f = open("file.txt", 'r')
3. for each_line in f:
4.     do_something

复制代码
以上也是一句一句的读文件，并不是一次性的把文件读完呀

Answer 4

原帖由 izhier 于 2009-3-27 10:53 发表

python generator 也可以由此功能呀！

>>> def gen():
...     n = 0
...     while True:
...             yield n
...             n += 1
...
>>> g = gen()
>>> g.next()
0
>>> g.next()
...

yield 的语义，你真的明白了吗？

yield 是一个流程控制语句，它的语义明明确确，除了保存函数调用栈之外，我想不出它和 return 有什么分别。

[ 本帖最后由 flw 于 2009-3-27 10:59 编辑 ]

Answer 5

原帖由 izhier 于 2009-3-26 20:24 发表

f x =
  case x of
    1->-1
    2->2
    _->0

ERROR:
Syntax error in case expression (unexpected symbol "->-")

1.以上代码出错可否判断 haskell 的运算符匹配是贪婪型的 ?

可以，而且它本来就是。

Answer 6

原帖由 flw 于 2009-3-27 00:14 发表
而 Haskell 的 lazy 是指，语义和行为不吻合。
比如 [1..]，它的语义是个无限列表，但是实际使用它的时候，比如 take 10 [1..]，并没有真的产生这个无限列表。

python generator 也可以由此功能呀！

2. >>> def gen():
3. ...     n = 0
4. ...     while True:
5. ...             yield n
6. ...             n += 1
7. ...
8. >>> g = gen()
9. >>> g.next()
10. 0
11. >>> g.next()
12. 1
13. >>> g.next()
14. 2
15. ...

复制代码

Answer 7

原帖由 win_hate 于 2009-3-27 00:11 发表
楼主不如先介绍一下 Python 中的 generator？ 懂 lazy 影子的人不一定懂 Python 啊。

虽然学习 python 不精，但愿抛砖引玉，如果有哪些不对，还望指正，改之

python generator:

在 python 中，generator function 是一个可以保存状态的函数，用 yield 指令(不是 return )返回一个值，保存当前整个函数执行状态，等待下一次调用，
当需要该函数返回值时，该 generator function 恢复整个函数执行状态，直至再次遇到 yield 指令，再次返回一个值，再次保存当前函数执行状态，再次等待。
如此循环往复，直至函数末尾，发生　StopIteration　异常。

generator 利用 next() method　来获取 generator　的下一个返回值。这样，generator在需要返回中间值时，
调用 next() method，获取 generator　的下一个返回值，保存当前函数状态，等待下一次的返回要求。

先看一个例子吧：

2. >>> def num_gen(n):
3. ...     for i in range(n):
4. ...             yield i*2
5. ...
6. >>> g = num_gen(6)
7. >>> g
8. <generator object at 0xb806f76c>
9. >>> g.next()
10. 0
11. >>> g.next()
12. 2
13. >>> g.next()
14. 4
15. >>> g.next()
16. 6
17. >>> g.next()
18. 8
19. >>> g.next()
20. 10
21. >>> g.next()
22. Traceback (most recent call last):
23.   File "<stdin>", line 1, in <module>
24. StopIteration

复制代码

函数里只要有了yield，这个函数就会被编译成一个 generator 函数，以上定义的 num_gen　函数就是一个 generator function，
num_gen(6) 返回一个 generator object，赋值于　g，　当 g 对象调用 next()　时，返回该 generator 的下一个值

！也就是说：当我们需要 generator 的返回值时，调用　next()　就可以了，
只有需要时，才会调用函数，取得返回值

好像有一点 lazy

Answer 8

Haskell 可以任意制造新的运算符，
因此在做词法分析时，依赖空格来分隔 token 应该可以理解。
其实说来也怪，我学别的语言的时候，都会去学习它的词法分析过程，
但是学 Haskell 从来没关心过这个。

至于递归麽，递归有一种叫做尾递归，编译期可以优化成循环的，
不是尾递归的，也有一部分可以转化成尾递归，这个理论上编译期都可以做优化。
剩下那些不能优化的，递归的时候就会影响性能，尤其是栈的消耗，
不过栈有大小限制，超过大小就会出错。

至于 Python 的生成器么，绝对不是 lazy，因为它的语义就是那样，语义和实际的行为是吻合的。
而 Haskell 的 lazy 是指，语义和行为不吻合。
比如 [1..]，它的语义是个无限列表，但是实际使用它的时候，比如 take 10 [1..]，并没有真的产生这个无限列表。
再比如 readFile "1G.file"，它的语义是把整个 1G 文件的内容都返回，
但是实际运行的时候，它并不会真的读 1G，也是需要多少就读多少。
这才是 lazy 的意思：语义承诺很多，但是实际做到刚好。

Answer 9

楼主不如先介绍一下 Python 中的 generator？ 懂 lazy 影子的人不一定懂 Python 啊。

ps: 如果楼主对 Python 比较熟悉，介绍一下 Python 中的函式支持也不错。

[ 本帖最后由 win_hate 于 2009-3-27 00:12 编辑 ]