尝试用Python实现消息传递编程风格

引用

本文站在一个难以名状的角度上研究了 Python 语言中消息发送的编程风格。原文是使用 JavaScript 描述的。文章作者 lichray 只把文章的上篇改成了 Python，因为下篇对于 Python 来说是没有意义的。lichray 是个 ECMAScript 的狂热追随者，mozilla.org 邮件列表里的无名潜水员。
文章中使用了 Python 解释器，行开头有 ">>>" 表示那是输入，输入下一行没有这个标记的表示解释器回馈消息。省略了多余的回馈。
PS: 文章用处不大。

[size=9]一. 对象和消息
考虑一下我们平常怎么说话的。我们叫某某人做某事，用下面的句式：
forest run!
其中"!"是语气的标志，对于编程语言来说是没有意义的，全部换成"."：
forrest run.
不知道如果我告诉大家上面这句话就是 Smalltalk 语言中一个合法语句大家会怎么想。好了，不谈这个。这样我们就得到了一种语法，"宾"谓结构：

ObjectVerb::
	Object Verb.

如果让它支持多个 Verb，比如
forrest run, jump, stop.
可以扩展成这样：

ObjectVerb::
	Object VerbList.
VerbList::
	Verb
	Verb , VerbList

很明显，对于 Python 来说，上面的 BNF 不可能和任何一个产生式匹配。问题出在哪儿？我们要帮 Python 指定，谁是 Object，谁是 Verb。鉴于 Object 只有一个，Verb 有多个，我们可以用括号来区分它们，然后把最后那个句号去掉：

ObjectVerb::
	Object ( VerbList )

这样上面的那句话就变成了下面的形式：
forrest (run, jump, stop)
很像函数调用，是吧？不过还有一个问题，现在这些 Verb(s) 对于 Python 来说是“裸词”（Perl 语），我们可以避开再去定义这些标识符，用字符串代替；最后再说明一下 Object 是什么：
forrest ('run', 'jump', 'stop')
那么现在我们第一个“模仿”自然语言的程序版本出现了，加上下面针对 Python 的文法：

Object::
	Identifier
Verb::
	StringLiteral

二. 实现消息传递
有了文法，一切都好办。看得出来，我们下面的工作是定义能创建一个新 Object 的函数，函数中有一些动作，产生的新 Object 是一个能处理这些消息的函数。创建 Forrest Gump 的函数还可以创建 Tom，Mike 等等；他们都是 People：

def People ():
	def run ():
		print("I'm running!")
	
	def jump ():
		print("I'm jumping!")
	
	def stop ():
		print("I can't stop!")
		
	def _dispatch_ (verb):
		if verb == 'run': run()
		elif verb == 'jump': jump()
		elif verb == 'stop': stop()

	return _dispatch_

当然，我们可以用 lambda 和 eval() 替换显式的 _dispatch_ 函数。需要注意是，使用 eval() 要先保存上层执行环境：

def People ():
	def run ():
		print("I'm running!")
	
	def jump ():
		print("I'm jumping!")
	
	def stop ():
		print("I can't stop!")
		
	local = locals()
	return (lambda verb: eval(verb, globals() ,local)())

Ok。现在我们来试一试这个智商低于 85 的 Forrest Gump 怎么样：
>>> forrest = People()
>>> forrest('run')
I'm running!
>>> forrest('jump')
I'm jumping!
>>> forrest('stop')
I can't stop!
事情就是这样。我们成功地创造了对象，还让他做动作、说话。
不过，这个实现并不是我们上文中最后一个文法所指出的。它不支持连续发送指令。改一改。要加入顺序执行指令的办法：

def People ():
	def run ():
		print("I'm running!")
	
	def jump ():
		print("I'm jumping!")
	
	def stop ():
		print("I can't stop!")
	
	local = locals()
	return lambda *verblist: map((lambda verb: (eval(verb, globals(), local))()), verblist)

这下似乎比较像样了：
>>> forrest = People()
>>> forrest('jump','run','jump','stop')
I'm jumping!
I'm running!
I'm jumping!
I can't stop!

三. 利用消息传递处理状态
什么是状态？我们在进行面向对象编程时，把状态表示为对象的一组数据，我们称之为“属性(property)”。在我们的消息传递编程风格中，可以直接把这些数据堆到产生对象的那个函数中去。下面给 Forrest 加入一个状态，Forrest 口袋里的钱。先得声明原先有多少钱：
forrest = People(1000)
然后，我们希望可以执行这样的代码，让 forrest 支出 200 美元：
forrest('pay', 200)
但很明显，我们无法分清 200 是 Verb 还是 'pay' 所要求的数据。我们只得简化文法，只允许一次发送一个消息，以保全我们的脑细胞：
forrest('pay')(200)
也就是说，我们需要让 forrest('pay') 这一表达式返回一个能改变状态的函数，而不仅仅是调用函数来显示一句话。也就是说，如果我们想让 Forrest 急得跳起来，我们先得跳起来：
forrest('jump')()
新时代的 Forrest 实现如下（省略了一点多余的代码）：

def People (money):
	local = locals()
	def pay (dollars):
		local['money'] = local['money'] - dollars
	
	def restMoney ():
		return local['money']
	
	def run ():
		print("I'm running!")
	
	local = locals()
	return lambda verb: eval(verb, globals(), local)

试一下。先支出 200 美元，然后看看他还剩多少钱：
>>> forrest=People(1000)
>>> forrest('restMoney')()
1000
>>> forrest('pay')(200)
>>> forrest('restMoney')()
800
当然，我们的 Forrest 还可以赚钱。下面这个版本比较彻底地说明了消息传递编程风格的一切。可以直接修改钱之后，我们可以不需要在创建 Object 的时候就说明原有多少钱；当然，使用注释中的版本更自然：

def People ():
	# def People (money):
	money = 0  # money = money or 0
	local = locals()
	def setMoney (dollars):
		local['money'] = dollars
	
	def addMoney (dollars):
		local['money'] = local['money'] + dollars
	
	def pay (dollars):
		local['money'] = local['money'] - dollars
	
	def restMoney ():
		return local['money']
	
	local = locals()
	return lambda verb: eval(verb, globals(), local)

试一下吧：
>>> forrest = People()
>>> forrest('addMoney')(1000)
>>> forrest('restMoney')()
1000
>>> forrest('pay')(200)
>>> forrest('restMoney')()
800

四. 小结
消息传递的编程风格指的是，把函数 A 的执行上下文当作对象的数据环境，在此定义对象的动词（函数），然后从此上下文中返回一个可以接受、处理消息的函数（常为匿名）。用函数 A 产生消息处理器作为对象，向此对象传递参数作为消息，以此执行函数 A 环境中定义的动作，这些动作还可能改变所在上下文中用一组数据定义的对象状态。
[/size]

弄错了，最后两个函数写了各两句 local = locals()。只要保留各自的第二个就行了。

这个，俗话叫脱了裤子放屁

forest.run.jump.stop

不是一样么？还不用自己做消息分发
说起这个消息，貌似很时髦似的
Smalltalk里面“调用方法”就叫“传递消息”

""Smalltalk里面“调用方法”就叫“传递消息”""
没错啊，我写这篇文章就是想说明“消息”是什么。

PS: 在Python3000中可以用 nonlocal 关键字指定引用上级名字空间中的变量，这样在最后两个例子中就可以不始终用 local['name']了。

LZ虽然写了很多，但是偶赞同gigix的看法(虽然gigix的那行代码貌似有点问题)。
从python的attribute查找机制来看，楼主的做法是自己把这个查找机制作了一个非常非常非常简陋而且低效的实现。
http://www.cafepy.com/article/python_attributes_and_methods/python_attributes_and_methods.html.

而且，LZ的代码风格有些问题。在python中，对locals()得回的东西进行update的结果是未定义的和微妙的.这一点和对globals()的操作不同。
http://mail.python.org/pipermail/python-list/2005-October/343950.html
虽然在这个例子里面不会有问题。但是最直接了当的解决办法是对付money只需要

local = { 'money':0 }

而对付那个lambda返回值中eval的参数，直接调用locals().

不明白楼主为啥要用python来做这个事情。个人觉得用汇编之类的会比较说明问题，只有对这类本身没有提供这样一个抽象层次的语言而言，这个做法才有意义(就这个角度而言，javascript是基于对象的，而python是面向对象的)。而对于python这类对象机制既为强悍的语言，再用函数方式来模仿消息传递，实在有点多余。

""而对付那个lambda返回值中eval的参数，直接调用locals().""
这样的话会找不到内层名字空间，我试过了。

呼呼~~你们说 Python 面向对象机制强悍，我还说 Python 函数式编程机制失败呢——都说了原文是用 JavaScript，写的而且仅仅是 show 着玩儿的，说明一下问题而已。下次不用 Python，但是我用的那些语言 JavaEye 上看得懂的人有多少？

PS: 别以为 Python 面向对象机制有多强悍。实话说，我见过的语言中数它最差（本来反对 OOP 的语言除外）。

我记得以前TrustNo1讲解FP用的就是Python示例
红色这句彪悍

综上所述猜测:牛的有点大!

我见过的语言中数它最差
Smalltalk Ruby JavaScript Lua E Scala Groovy Self
其中 E 的面向对象机制已经到了“高山仰止，境行行止”的地步。
http://www.erights.org
Python 的面向对象机制超过哪个了？
此外一些比较“硬”的语言，其机制我不喜欢，不提了。

hehe. 这个是我的疏忽。忘了在交互环境下测试一下。在这个lambda里面执行locals()，找到的是该匿名函数的locals，而不是那个外层函数的。在你这个例子中，通常会采用的是如下的方式：

lambda verb(local=locals()): eval(verb, globals(), local)