把Parameterized Module作为一个Erlang的语法特性而不扯到OOP上去,可能更好理解: )
本文回答Erlang Parameterized Module是什么?有什么用?怎么实现的?我们能不能用?什么时候使用?
和很多人一样我也是从mochiweb项目中第一次看到parameterized module的应用,mochiweb项目地址:
http://code.google.com/p/mochiweb/
-module(mochiweb_request, [Socket, Method, RawPath, Version, Headers]).
-author('bob@mochimedia.com').
-include_lib("kernel/include/file.hrl").
-include("internal.hrl").
-define(QUIP, "Any of you quaids got a smint?").
当时不明白-module(mochiweb_request, [Socket, Method, RawPath, Version, Headers]).甚至不知道如何称呼这种做法;只能从形式上描述成module的attribute,在搜索引擎里面按照Erlang module attribute的线索搜索,在Stack Overflow的下面这个提问中找到了更多线索:
Erlang: module attribute - Stack Overflow
是什么?有什么用?
首先要明确的这种Erlang编程实践的并不是叫什么"Erlang module attribute",而是被称为Parameterized Module(还有一个名字:abstract module).提出这种方法的论文在这里:http://www.erlang.se/workshop/2003/paper/p29-carlsson.pdf 这篇论文里面可以看到Parameterized Erlang的简单介绍:
A parameterized, or abstract module, is a module with free variables, much like a lambda expression (or \fun expression"). A lambda expression evaluates to a closure,which is a functional value and can be applied like any function. Similarly, an abstract module can be instantiated to yield a module instance,which can be used in a qualied function call just like any module name.
论文中描述的问题域并没有带来多少共鸣,从看到的开源项目的实践Parameterized Module带来的最大的好处就是模块实例自己维护了部分状态,而不必所有状态和参数都通过方法的参数传递;下面我们就看看,Parameterized Module是怎么使用的,以及状态是怎么维护的:
怎么用?如何实现的?
我们新建一个最简单的Parameterized Module的例子:
-module(p,[Name,ID]).
-compile(export_all).
test() ->
{Name,ID}.
dump(Data) ->
Data.
为了方便做比较再建一个普通的module:
-module(p2).
-compile(export_all).
test(Name,ID) ->
{Name,ID}.
dump(Data) ->
Data.
编译后调用:
Eshell V5.9 (abort with ^G)
1> P=p:new(zen,23).
{p,zen,23}
2> P:test().
{zen,23}
3> P:dump(12).
12
4> p:dump(12).
** exception error: undefined function p:dump/1
%%复习一下Function cal
1> list_to_tuple([a,b,c]).
{a,b,c}
2> tuple_to_list({a,b,c}).
[a,b,c]
3>
4> F={lists,append}.
{lists,append}
5> F([1,2],[3,4]).
[1,2,3,4]
6> fun lists:append/2([a,b],[c,d]).
[a,b,c,d]
7>
上面的代码首先创建了p模块的实例,然后调用P:test().虽然并没有传入什么参数,还是可以看到Name,ID的输出;后面直接调用p:dump(12).的时候抛出了异常:undefined function p:dump/1 ;这就驱使我们查看p模块的module_info,果然如此,{dump,2}dump的参数是标记成两个!!!!
5> p:module_info().
[{exports,[{new,2},
{instance,2},
{test,1},
{dump,2}, %注意dump的参数是两个
{module_info,0},
{module_info,1}]},
{imports,[]},
{attributes,[{vsn,[214441158221151374600508513707091486952]},
{abstract,[true]}]},
{compile,[{options,[error_summary]},
{version,"4.8"},
{time,{2012,2,16,7,23,32}},
{source,"/ligaoren/src/p.erl"}]}]
6>
dump参数数量变化的事情
暂且放下,咱们先来明确一个更为基础的问题,Parameterized Module自己维护了部分状态,那这部分状态在哪里呢?
我们第一行 P=p:new(zen,23).创建了一个p模块的实例,这个实例是什么样的呢?{p,zen,23}这就是P.也就是说实例化的结果实际上返回了一个{模块+状态}的结构;继续做一些实验来看:
7> P2=p:new(zen,23).
{p,zen,23}
8> P2=:= P.
true
9> {p,zen,34}:test().
{zen,34}
不错吧,参数相同两个实例也是相同的,使用同样结构的tuple{p,zen,34}作为模块名进行调用{p,zen,34}:test().效果和创建p:new(zen,34).实例一样.
对比一下p2模块的元数据:
11> p2:module_info().
[{exports,[{test,2},
{dump,1},
{module_info,0},
{module_info,1}]},
{imports,[]},
{attributes,[{vsn,[248741352456702936001456553656546909458]}]},
{compile,[{options,[error_summary]},
{version,"4.8"},
{time,{2012,2,16,7,26,8}},
{source,"/ligaoren/src/p2.erl"}]}]
能看到p模块比p2模块的差异:
- 导出的方法多了{new,2},{instance,2}
- 模块attributes 多了一个{abstract,[true]}
显然这样的信息太少了,我们把这两个模块的Core Erlang代码编译出来,看看内部实现的差别!p2模块是比较中规中矩的,基本上都是意料之中的内容:
module 'p2' ['dump'/1,
'module_info'/0,
'module_info'/1,
'test'/2]
attributes []
'test'/2 =
%% Line 10
fun (_cor1,_cor0) ->
%% Line 11
{_cor1,_cor0}
'dump'/1 =
%% Line 13
fun (_cor0) ->
_cor0
'module_info'/0 =
fun () ->
call 'erlang':'get_module_info'
('p2')
'module_info'/1 =
fun (_cor0) ->
call 'erlang':'get_module_info'
('p2', _cor0)
end
p模块包含的信息量就比较大了,几乎包含了之前所有问题的答案:
module 'p' ['dump'/2,
'instance'/2,
'module_info'/0,
'module_info'/1,
'new'/2,
'test'/1]
attributes ['abstract' =
['true']]
'new'/2 =
fun (_cor1,_cor0) ->
apply 'instance'/2
(_cor1, _cor0)
'instance'/2 =
fun (_cor1,_cor0) ->
{'p',_cor1,_cor0}
'test'/1 =
%% Line 11
fun (_cor0) ->
case _cor0 of
<THIS = {_cor2,Name,ID}> when 'true' ->
%% Line 12
{Name,ID}
( <_cor1> when 'true' ->
( primop 'match_fail'
({'function_clause',_cor1})
-| [{'function_name',{'test',1}}] )
-| ['compiler_generated'] )
end
'dump'/2 =
%% Line 15
fun (_cor1,_cor0) ->
case <_cor1,_cor0> of
<Data,THIS = {_cor4,Name,ID}> when 'true' ->
%% Line 16
Data
( <_cor3,_cor2> when 'true' ->
( primop 'match_fail'
({'function_clause',_cor3,_cor2})
-| [{'function_name',{'dump',2}}] )
-| ['compiler_generated'] )
end
'module_info'/0 =
fun () ->
call 'erlang':'get_module_info'
('p')
'module_info'/1 =
fun (_cor0) ->
call 'erlang':'get_module_info'
('p', _cor0)
end
-module(q,[Name]). -compile(export_all). dump()-> THIS. Erlang Shell中调用: 2> Q=q:new(zen). {q,zen} 3> Q:dump(). {q,zen}
我们上面已经判断出来实例的创建过程实际上就是构造了{module,State}的结构,来验证下:
'new'/2 =
fun (_cor1,_cor0) ->
apply 'instance'/2
(_cor1, _cor0)
'instance'/2 =
fun (_cor1,_cor0) ->
{'p',_cor1,_cor0} %%GOTCHA!!!!!
上面遗留的dump参数的问题至此也就昭然了,看代码实现:
'dump'/2 =
%% Line 15
fun (_cor1,_cor0) ->
case <_cor1,_cor0> of
<Data,THIS = {_cor4,Name,ID}> when 'true' ->
%% Line 16
Data
( <_cor3,_cor2> when 'true' ->
( primop 'match_fail'
({'function_clause',_cor3,_cor2})
-| [{'function_name',{'dump',2}}] )
-| ['compiler_generated'] )
end
也就是说答案是:最后一个参数是模块的实例,实验一下
6> p:dump(12,{p,zen,23}).
12
GOTCHA!!!
When to Use
Parameterized Module通常适用的场景就是用它来维护部分状态,不必每个方法都传递一堆参数;立涛写的erl_redis的时候把
redis.erl模块设计成-module(redis, [Client, Pipeline]).请教了一下他这样设计的目的,也是为了方便调用,不必每一次都传递Client和Pipeline参数.由于Parameterized Module属于一个实验特性,虽然已经有mochiweb这样的项目已经使用,一方面这毕竟还不是一个标准的方法,另一方面Parameterized Module的确没有m:f(a)直观; 可以用,但是要控制使用的范围;
Parameterized module相关的讨论:
[1] Erlang questions mailing list ~ Parameterized module idioms
http://forum.trapexit.org/viewtopic.php?t=18119&sid=6e84e0954f92e92abc0dbc2a7629058d
[2] about the use of parametrized modules
http://erlang.2086793.n4.nabble.com/about-the-use-of-parametrized-modules-td3216925.html
[3] Is “new” in Erlang part of the official standard and should we use it?
http://stackoverflow.com/questions/2287403/is-new-in-erlang-part-of-the-official-standard-and-should-we-use-it
