Ô­ÎÄ£º http://wiki.python.org/moin/PythonVsHaskell
×¢£º±¾ÎÄÊÇPython¹Ù·½wikiÍøÕ¾ÖеÄһƪÎÄÕ£¬±È½ÏÁËPythonÓëHaskell£¬¸ü¶àµÄ¹ØÓÚPython¼°ÆäËûÓïÑÔµÄÔÚ£ºPythonÓëÆäËûÓïÑԱȽÏ<http://wiki.python.org/moin/LanguageComparisons>
http://wiki.python.org/moin/LanguageComparisons

HaskellÊÇÒ»Öַdz£ÏÖ´úµÄº¯Êýʽ±à³ÌÓïÑÔ£¨ÏñLispµÈ£©¡£ÕâÃÅÓïÑÔ²¢²»ÊǺÜÁ÷Ðе«È´Ó¦ÓÃÔÚһЩʵ¼ÊµÄÏîÄ¿ÖУ¨²»Ö»ÊÇÒ»ÖÖÊÔÑéÐÔÓïÑÔ£©²¢ÇÒÔÚʵ¼ÊÐÐÒµÖÐÓ¦ÓÃÔ½À´Ô½Æձ顣±ÈÈç
darcs °æ±¾¹ÜÀíϵͳ¾ÍÊÇÓà Haskell дµÄ¡£¸ü¶àÐÅÏ¢Çë¿´ http://www.haskell.org

Haskell ºÍ PythonÖ®¼äºÜÄÑÒ»¶ÔÒ»µÄ±È½Ï£¬ÒòΪËûÃÇÔںܶ෽ÃæÏ൱µÄ²»Í¬¡£µ«ÊÇÁ½ÖÖÓïÑԵĴ󲿷ÖÓû§¶¼»áͬÒâËûÃǶ¼Éè¼ÆµÄ·Ç³£ÓÅÑÅ¡£
Functional vs Procedural: º¯Êýʽ vs ¹ý³Ìʽ

Haskell ÊÇÒ»ÖÖLazy £¨ÑÓ³Ù¼ÆË㣩£¬±»³ÆΪ"´¿º¯Êýʽ"
£¨Ã»Óи³Öµ»ò¸±×÷Ó㩵ÄÓïÑÔ¡£Ëüͨ¹ýÀàÐÍÀàÀ´Ö§³Ö²ÎÊý¶à̬£¨ÓÐЩÏñC++µÄÄ£°åµÄ×÷Ó㬵«±ÈÄǸüÇ¿´ó£©ºÍAd-hoc¶à̬¡£
PythonΪ³ÌÐòÔ±ÌṩÁ˷ḻµÄ±à³Ì·¶ÐÍ£¬°üÀ¨¹ý³Ìʽ¡¢º¯ÊýʽÓëÃæÏò¶ÔÏóʽ¡£Lazy±à³Ì¿ÉÒÔͨ¹ý²úÉúÆ÷ºÍµü´úÆ÷À´ÊµÏÖ¡£Python¶ÔÓÚº¯Êýʽ±à³ÌÓÐ
Ò»¶¨µÄÖ§³Ö£¬µ«ÊÇÓÉÓÚ´æÔÚ´óÁ¿µÄ¸±×÷ÓÃÒÔ¼°È±·¦¶ÔβµÝ¹éµÄÄÚ½¨Ö§³Ö£¬Ê¹µÃÔÚPythonÖÐʹÓú¯Êýʽ±à³ÌÏÔµÃÓÐЩ±¿×¾¡£Haskellͨ¹ýMonad(À´
×Ô·¶³ëÂÛ£©À´Ö§³Ö¹ý³Ìʽ±à³Ì£¬ÕâÒ²ÊÇHaskellµÄ´¿º¯ÊýʽÊÀ½çÓëÏÖʵÊÀ½çµÄ¸±×÷ÓõÄÇÅÁº£¨ÈçͼÐνçÃ棬ÊäÈëÊä³ö£¬Îļþϵͳ£¬socketµÈ£©¡£ÃüÁîʽ
±à³Ì²¢·ÇHaskellµÄ£¨Ö÷Òª£©ÒâͼҲ²¢·ÇÆäÇ¿Ïî¡£²»¹ýºÜ¶à Haskell³ÌÐòÔ±Éù³ÆHaskellÊÇËûÃÇ×îϲ»¶µÄÃüÁîʽÓïÑÔ£º£©
Compiled vs Interpreted: ±àÒë vs ½âÊÍ

PythonµÄÖ÷ҪʵÏÖÊÇÒ»¸ö½âÊÍÆ÷¡£HaskellÓÐÒ»°ÑµÄʵÏÖ£¬°üÀ¨Ò»Ð©½âÊÍÆ÷£¨Hugs, GHCi)ºÍһЩÉú³É±¾µØ´úÂëµÄ±àÒëÆ÷£¨GHC,
nhc98)¡£HaskellºÍPythonÒ»Ñù¶¼ÊÇÒ»ÖÖ£¨ºÜ£©¸ß¼¶µÄ±à³ÌÓïÑÔ£¬ËùÒÔ²¢²»Ó¦ÆÚ´ýËü»áÏñC»òÕß»ã±àÒ»ÑùµÄÐÔÄÜ¡£HaskellµÄÀàÐÍϵͳÌá
¹©Á˸ü¶àµÄ±àÒëʱÐÅÏ¢£¬ÕâÑù´ó¶àÊýÇé¿öÏÂhaskellµÄ±¾µØ´úÂë±àÒëÆ÷»á±ÈPython¸üÓÐËÙ¶ÈÓÅÊÆ£º
ËٶȱȽÏ<http://shootout.alioth.debian.org/gp4/benchmark.php?test=all⟨=python&lang2;=ghc>

http://shootout.alioth.debian.org/gp4/benchmark.php?test=all⟨=python...>

Pythonic µÄ±à³ÌÕÜѧ£º°ÑÐÔÄܹؼü²¿·Ö¶ª¸øC£¬Í¬ÑùÊÊÓÃÓÚHaskell¡£Í¨¹ý FFI (foreign function interface),
haskellµÄº¯Êý¿ÉÒÔµ÷ÓÃC³ÌÐò£¬»òÕß±»C³ÌÐòµ÷Óá£
ÁíÒ»ÖÖ¿ÉÑ¡µÄ×ö·¨ÊÇͨ¹ý±àÒëÆ÷Ìض¨µÄÀ©Õ¹£¨ÌرðÊÇghc£©ºÍ¸üÑϸñµÄ±ê¼Ç£¬Õâ¿ÉÒÔÈÃËûÃÇÖ®¼äµÄ±äµÃÌú°åÒ»¿é¡£
Static vs Dynamic Typing: ¾²Ì¬ÀàÐÍ vs ¶¯Ì¬ÀàÐÍ

HaskellºÍPython¶¼¾ßÓÐÇ¿ÀàÐÍ£¬Ò²¾ÍÊÇ˵ÀàÐ͵ÄʾÀý²»Äܱ»ÓÃ×÷ÁíÒ»ÖÖÀàÐÍ¡£±ØÐëʹÓÃÏÔʾµÄת»»¡£²»Í¬Ö®´¦ÔÚÓÚ
HaskellÊǾ²Ì¬ÀàÐÍ£¬¶øPythonÊǶ¯Ì¬ÀàÐÍ¡£ÔÚHaskellÖУ¬Ã¿Ò»¸ö±í´ïʽºÍÖµ£¨Òë×¢1£©µÄÀàÐÍÔÚ±àÒëʱ¶¼ÊÇÒÑ֪ȷ¶¨µÄ£¬¶øÔÚPython
Öбí´ïʽºÍ±äÁ¿²¢Ã»ÓÐÀàÐÍ--ËûÃÇËùÒýÓõĶÔÏóÓÐÀàÐÍ£¬µ«ÊÇÖ±µ½ÔËÐÐʱ²ÅÄÜÖªµÀ£¬²¢ÇÒ¶ÔÏó¿ÉÒÔͨ¹ýÌṩÕýÈ·µÄº¯Êý£¨Èç __length__ µÈ)
À´¼Ù×°³ÉÁíÒ»ÖÖÀàÐÍ¡£ÒòΪÀàÐÍϵͳÊÇHaskellÖзdz£»ù´¡µÄ²¿·Ö£¨ÕâʹµÃÕâÃÅÓïÑÔдµÄ³ÌÐòÈÝÒ×±»ÑéÖ¤£©£¬ÕâÒ»µãÊÇÓëPythonµÄÒ»¸ö»ù´¡µÄ²»Í¬µã¡£
²»¹ý£¬¶ÔÓÚÄÇЩÏ뵽ÿ´ÎÓÃÒ»¸ö±äÁ¿Ç°¶¼ÒªÏÈд int
i¾Í·¢¶¶µÄpythonÓû§£¬´ó¿É¿íÐÄ£ºHaskellµÄ±àÒëÆ÷ºÍ½âÊÍÆ÷×ã¹»µÄ´ÏÃ÷¼¸ºõ×ÜÊÇ¿ÉÒÔÍƶϳöÄãµÄ±í´ïʽµÄÀàÐÍ£¬ËùÒÔÄã¿ÉÒÔ²»±ØдËûÃÇ¡££¨Òë×¢ 2£©
±ÈÈ磬°Ñ5µÄÖµ·ÖÅäµ½Ò»¸ö±íʾ·û 'a' £¬ÔÚPythonºÍHaskellÖеĴúÂëÊÇÍêÈ«Ò»ÑùµÄ£º

a = 5 £¨Òë×¢3£©

ʵ¼ÊÉÏHaskell±àÒëÆ÷°ÑËüÍƶϳÉÒ»¸ö Integer ÀàÐÍ¡£
List Comprehension Syntax:

±ØÐëÖ¸³öµÄÊÇËûÃÇÓÐÒ»¸öÏàËƵ㣺 ÁбíÄÚº­Ê½Óï·¨
PythonµÄÁбíÄÚº­Ê½Óï·¨ÊÇÖ±½Ó´ÓHaskellÄùýÀ´µÄ¡££¨µ±È»ÓÐһЩËöËé¹Ø¼ü×ֺͷûºÅµÄÐ޸ģ© ÁбíÄÚº­ÕâÖ÷ÒâʵÔÚÌ«°ôÁËû°ì·¨¾Ü¾ø¡£
Significant Whitespace: Ëõ½øÓï·¨

ËûÃǶ¼°ÑËõ½ø×÷ΪÓï·¨¡£ÔÚPythonÖУ¬ tab/¿Õ¸ñÊÇÓï·¨£¬¶øHaskellÖÐ
tab/¿Õ¸ñÊǶ¨ÒåÁ¼ºÃµÄÓï·¨ÌÇ£¬£¨×îÖÕ£©×ª»»³ÉÀ¨ºÅºÍ·ÖºÅµÄ³ÌÐò¿éµÄÓï·¨¡£ÓÐÈË»á˵HaskellµÄ·½Ê½ÊÇËõ½øÓï·¨ÕâÖÖÏë·¨µÄÒ»¸ö½ø²½£¬Í¨¹ýÔÊÐí³ÌÐòÔ±
ʹÓÃÏÔʽµÄÀ¨ºÅºÍ·ÖºÅ±ê¼ÇµÄÓï·¨¿é¿ÉÒÔ±ÜÃâºÜ¶àÍ·ÌÛµÄÎÊÌ⣬ÈçÔÚÍøÒ³ÉÏ¿½±´Õ³Ìù´úÂë¡«¡«
Learning Curve: ѧϰÇúÏß

¶ÔÓÚûÓк¯Êýʽ±à³Ì¾­ÑéµÄ³ÌÐòÔ±À´ËµHaskellµÄѧϰÇúÏßÏ൱¶¸ÇÍ¡£ºÜ¶àÇé¿öÏ£¬ÑÓ³Ù¼ÆËã¶ÔÃüÁîʽÓïÑÔ½þÅݳöÀ´µÄ´óÄÔÀ´ËµÏÔµÃÎ¥·´Ö±¾õºÍ³£Ê¶£¬Äã±ØÐëÍüȴһЩ×èÖ¹ÄãµÄ³ÌÐò³Ô¹âÄÚ´æµÄ¼¼Êõ¡£

¶ÔÎÒ¶øÑÔ£¨NioateÔ­×÷Õߣ©£¬Ñ§Ï°OCamlÈÃÎұȽÏƽ»¬µÄ¹ý¶Éµ½Haskell£¬ÒòΪMLÓÐÒ»¸öºÍHaskellÀàËƵÄÀàÐÍϵͳ¡£Àí½âÁËÀàÐÍ
ϵͳºó£¬ÌøÈëHaskellÔòÊǺÁ²»ÓÌÔ¥µÄ£¬ ³ýÁËһЩеÄÓï·¨£¬Ö»ÐèҪѧϰÈçºÎÀûÓÃÑÓ³Ù¼ÆË㣬ÀàÐÍÀàºÍMonad¡££¨²»ÒªÈà Monad
Ïŵ½Ä㣬ÏÈѧϰListºÍMaybe monad.£©(Òë×¢4)
¶ÔÎÒ¶øÑÔ£¨albertleeÒë×÷Õߣ©£¬Ñ§Ï°haskell֮ǰ¶ÌÔݵÄѧϰ¹ýErlang £¬¶øÔÚÄÇ֮ǰÔòÊÇLisp,
schemeºÍPython£¬¾¡¹ÜΪFP×öÁ˺ܶàµÄÆ̵棬µ«½øÈëHaskellµÄÊÀ½çÒÀÈ»Óöµ½Á˺ܶàµÄÀ§ÄÑ£¬ÓÈÆäÊÇMonad£¬ type class
¡£±Ï¾¹¹úÄÚÕâ·½ÃæµÄÖÐÎÄ×ÊÁϱȽÏÉÙ£¬Ñ§Ï°µÄ»ï°éÒ²±È½ÏÉÙ¡£

Òë×¢1£º Öµ£¬Ô­ÎÄΪ variable , µ« haskellÖв¢Ã»ÓÐ variable Õâ¸ö¸ÅÄî¡£
Òë×¢2£º ÎҶԴ˱íʾ»³ÒÉ¡­¡­²»¹ýÿ´Î¶¼Ð´ÉÏÀàÐ͵ÄÉúÃüÊÇÒ»¸öºÃµÄÏ°¹ß£¬ÕâÓÐÖúÓÚ˼¿¼¡£
Òë×¢3£º ²»¹ýÔÚÁ½ÖÖÓïÑÔÖУ¬ËûÃǵĺ¬ÒåÊÇÍêÈ«²»Ò»ÑùµÄ£¬PythonÖоÍÊÇÒ»¸ö±äÁ¿¸³Öµ£¬¶øhaskellÖÐÔòÊÇÉùÃ÷ÁËÒ»¸öº¯Êýa£¬Õâ¸öº¯ÊýµÄÖµÊdz£Á¿5.
Òë×¢4£º List ±¾Éí¾ÍÊÇ Monad
Using both Python & Haskell with ctypes (-;

½áºÏpythonºÍHaskellµÄÓŵ㣬½«Haskell±àÒë³ÉDLL£¬ÔÚPythonÖÐʹÓÃctypesµ÷Óãº
¼û£º http://www.kamang.net/node/24



http://www.kamang.net
-------------- 下一部分 --------------
Ò»¸öHTML¸½¼þ±»ÒƳý...
URL: http://python.cn/pipermail/python-chinese/attachments/20070424/d38ce55d/attachment.html 

收藏！
http://wiki.woodpecker.org.cn/moin/PythonVsOthers

咔咔咔！ AlbertLee 一向以教唆"非主流"（中国的）语言技术为容的！
感谢此类行者替大家搜寻计算机技术森林中的奇珍异宝！


On 4/24/07, Albert Lee <hanzhupeng在gmail.com> wrote:
>
>
> 原文： http://wiki.python.org/moin/PythonVsHaskell
> 注：本文是Python官方wiki网站中的一篇文章，比较了Python与Haskell，更多的关于Python及其他语言的在：Python与其他语言比较
>  http://wiki.python.org/moin/LanguageComparisons
>
> Haskell是一种非常现代的函数式编程语言（像Lisp等）。这门语言并不是很流行但却应用在一些实际的项目中（不只是一种试验性语言）并且在实际行业中应用越来越普遍。比如
> darcs 版本管理系统就是用 Haskell 写的。更多信息请看 http://www.haskell.org
>
> Haskell 和
> Python之间很难一对一的比较，因为他们在很多方面相当的不同。但是两种语言的大部分用户都会同意他们都设计的非常优雅。
> Functional vs Procedural: 函数式 vs 过程式
>
> Haskell 是一种Lazy （延迟计算），被称为"纯函数式"
> （没有赋值或副作用）的语言。它通过类型类来支持参数多态（有些像C++的模板的作用，但比那更强大）和Ad-hoc多态。
> Python为程序员提供了丰富的编程范型，包括过程式、函数式与面向对象式。Lazy编程可以通过产生器和迭代器来实现。Python对于函数式编程有
> 一定的支持，但是由于存在大量的副作用以及缺乏对尾递归的内建支持，使得在Python中使用函数式编程显得有些笨拙。Haskell通过Monad(来
> 自范畴论）来支持过程式编程，这也是Haskell的纯函数式世界与现实世界的副作用的桥梁（如图形界面，输入输出，文件系统，socket等）。命令式
> 编程并非Haskell的（主要）意图也并非其强项。不过很多
> Haskell程序员声称Haskell是他们最喜欢的命令式语言：）
> Compiled vs Interpreted: 编译 vs 解释
>
> Python的主要实现是一个解释器。Haskell有一把的实现，包括一些解释器（Hugs,
> GHCi)和一些生成本地代码的编译器（GHC,
> nhc98)。Haskell和Python一样都是一种（很）高级的编程语言，所以并不应期待它会像C或者汇编一样的性能。Haskell的类型系统提
> 供了更多的编译时信息，这样大多数情况下haskell的本地代码编译器会比Python更有速度优势： 速度比较
>
> http://shootout.alioth.debian.org/gp4/benchmark.php?test=all⟨=python...
>
> Pythonic 的编程哲学：把性能关键部分丢给C，同样适用于Haskell。通过 FFI (foreign
> function interface), haskell的函数可以调用C程序，或者被C程序调用。
>  另一种可选的做法是通过编译器特定的扩展（特别是ghc）和更严格的标记，这可以让他们之间的变得铁板一块。
> Static vs Dynamic Typing: 静态类型 vs 动态类型
>
> Haskell和Python都具有强类型，也就是说类型的示例不能被用作另一种类型。必须使用显示的转换。不同之处在于
> Haskell是静态类型，而Python是动态类型。在Haskell中，每一个表达式和值（译注1）的类型在编译时都是已知确定的，而在Python
> 中表达式和变量并没有类型--他们所引用的对象有类型，但是直到运行时才能知道，并且对象可以通过提供正确的函数（如
> __length__ 等)
> 来假装成另一种类型。因为类型系统是Haskell中非常基础的部分（这使得这门语言写的程序容易被验证），这一点是与Python的一个基础的不同点。
> 不过，对于那些想到每次用一个变量前都要先写 int
> i就发抖的python用户，大可宽心：Haskell的编译器和解释器足够的聪明几乎总是可以推断出你的表达式的类型，所以你可以不必写他们。（译注
> 2） 比如，把5的值分配到一个表示符 'a' ，在Python和Haskell中的代码是完全一样的：
>
> a = 5 （译注3）
>
> 实际上Haskell编译器把它推断成一个 Integer 类型。
> List Comprehension Syntax:
>
> 必须指出的是他们有一个相似点： 列表内涵式语法
>  Python的列表内涵式语法是直接从Haskell拿过来的。（当然有一些琐碎关键字和符号的修改）
> 列表内涵这主意实在太棒了没办法拒绝。
> Significant Whitespace: 缩进语法
>
> 他们都把缩进作为语法。在Python中， tab/空格是语法，而Haskell中
> tab/空格是定义良好的语法糖，（最终）转换成括号和分号的程序块的语法。有人会说Haskell的方式是缩进语法这种想法的一个进步，通过允许程序员
> 使用显式的括号和分号标记的语法块可以避免很多头疼的问题，如在网页上拷贝粘贴代码～～
> Learning Curve: 学习曲线
>
> 对于没有函数式编程经验的程序员来说Haskell的学习曲线相当陡峭。很多情况下，延迟计算对命令式语言浸泡出来的大脑来说显得违反直觉和常识，你必须忘却一些阻止你的程序吃光内存的技术。
>
> 对我而言（Nioate原作者），学习OCaml让我比较平滑的过渡到Haskell，因为ML有一个和Haskell类似的类型系统。理解了类型
> 系统后，跳入Haskell则是毫不犹豫的， 除了一些新的语法，只需要学习如何利用延迟计算，类型类和Monad。（不要让
> Monad 吓到你，先学习List和Maybe monad.）(译注4)
>  对我而言（albertlee译作者），学习haskell之前短暂的学习过Erlang ，而在那之前则是Lisp,
> scheme和Python，尽管为FP做了很多的铺垫，但进入Haskell的世界依然遇到了很多的困难，尤其是Monad，
> type class 。毕竟国内这方面的中文资料比较少，学习的伙伴也比较少。
>
> 译注1： 值，原文为 variable , 但 haskell中并没有 variable 这个概念。
>  译注2： 我对此表示怀疑……不过每次都写上类型的生命是一个好的习惯，这有助于思考。
>  译注3：
> 不过在两种语言中，他们的含义是完全不一样的，Python中就是一个变量赋值，而haskell中则是声明了一个函数a，这个函数的值是常量5.
>  译注4： List 本身就是 Monad
> Using both Python & Haskell with ctypes (-;
>
> 结合python和Haskell的优点，将Haskell编译成DLL，在Python中使用ctypes调用：
>  见： http://www.kamang.net/node/24
>
>
> http://www.kamang.net
>
>  --~--~---------~--~----~------------~-------~--~----~
>  '''邮件来自Groups "python-cn"--China Py User Group
>  详情: http://groups-beta.google.com/group/python-cn
>  发言: python-cn在googlegroups.com
>  退订: python-cn-unsubscribe在googlegroups.com
>  维基: http://wiki.woodpecker.org.cn/moin/CPUG
>  同类列表: http://python.cn/mailman/listinfo/python-chinese
>  社区事务: http://groups.google.com/group/CPUG
>  北京事务: http://groups.google.com/group/bpug
>  东南事务: http://groups.google.com/group/cpug-eastchina
>  '''
>  -~----------~----~----~----~------~----~------~--~---
>
>


-- 
'''Time is unimportant, only life important!
http://zoomquiet.org
blog在http://blog.zoomquiet.org/pyblosxom/
wiki在http://wiki.woodpecker.org.cn/moin/ZoomQuiet
scrap在http://floss.zoomquiet.org
douban在http://www.douban.com/people/zoomq/
____________________________________
Pls. use OpenOffice.org to replace M$ Office.
     http://zh.openoffice.org
Pls. use 7-zip to replace WinRAR/WinZip.
     http://7-zip.org/zh-cn/
You can get the truely Freedom 4 software.
'''

大概看了一下，感觉挺先进的，不过跟程序员通常的思维方式差的有点远，入门有 
点困难哈，欲练此绝技必先废除所有武功，哈哈

Zoom.Quiet 写道:
> 收藏！
> http://wiki.woodpecker.org.cn/moin/PythonVsOthers
>
> 咔咔咔！ AlbertLee 一向以教唆"非主流"（中国的）语言技术为容的！
> 感谢此类行者替大家搜寻计算机技术森林中的奇珍异宝！
>
>
> On 4/24/07, Albert Lee <hanzhupeng at gmail.com> wrote:
>
> Haskell是一种非常现代的函数式编程语言（像Lisp等）。这门语言并不是很流行但却应用在一些实际的项目中（不只是一种试验性语言）并且在实际行业中应用越来越普遍。比如
> darcs 版本管理系统就是用 Haskell 写的。更多信息请看 http://www.haskell.org
>   

On Wed, Apr 25, 2007 at 09:16:04AM +0800, amingsc wrote:
> 大概看了一下，感觉挺先进的，不过跟程序员通常的思维方式差的有点远，入门有 
> 点困难哈，欲练此绝技必先废除所有武功，哈哈
函数式编程和过程式编程思维方式不同。只不过我们现在一般都接触到过程式的，其实函数式编程非常有魅力，而且不用废除武功:)

On 4/25/07, Ken Lai <soulhacker511在163.com> wrote:
> 函数式编程和过程式编程思维方式不同。只不过我们现在一般都接触到过程式的，其实函数式编程非常有魅力，而且不用废除武功:)

我看了几章的 SICP，感觉碰到莫些问题时，很自然的就想用递归。
这些东西离我们很近，只是不常见。

引用 Zoom.Quiet 的话
感谢AlbertLee替大家搜寻计算机技术森林中的奇珍异宝！