Erlang Parameterized Module

转载：http://www.cnblogs.com/me-sa/archive/2012/02/16/Erlang0037.html

把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('[email protected]').

-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模块的差异:

1. 导出的方法多了{new,2},{instance,2}
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

上面的THIS:

-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!!!