Erlang

1998年起，Erlang发布开放源码版本，称为开源电信平台。开源电信平台采用修改过的Mozilla公共许可证协议发放，同时爱立信仍然提供商业版本的技术支持。目前，Erlang最大的商业用户是爱立信，其他知名用户有北电网络、以及T-Mobile等[5]。

• 在语言中，可以借由spawn/*函数，将特定的函数设置为独立的，之后可以做跨通信。
• 函数式设计 由于Erlang早期以Prolog开发制成，受语言特性影响，即成为函数式语言。
• 单次赋值 每个只能跟绑一次，所以，不像一般的可以多次指定为不同的值。单次赋值的好处是状态单纯，使容易阅读。
• 及早求值或严格求值 Erlang基本求值策略为电脑语言中及早求值之特性。而且，可以借由明确使用无参数的，将特定函数设置为惰性求值策略。
• 与类型系统 有编译时期的检查系统。
• 在运行时期发生的错误，会由错误位置送出消息，发生错误的立刻停止。借由，可以自动传递错误、捕捉错误，使其他能够帮助处理错误。
• 热更新 由于Erlang是函数语言，可以撰写特定的，制作即时更换新版函数的机制。
• 脚本语言 Erlang实作提供了脚本运行方式。

  原子 ( 变量 , 变量 , ... ) -> 表达式 , 表达式 , ...
在 -> 左边是函数名称及搭配的参数表，右边为函数本体。

  规则 ; 规则 ; ... ; 规则 .
以分号分隔一或多项规则，并最后以句号结束。
同一函数的每一规则必须以相同的原子开头，并接受相同数量的
参数表。

  原子 ( 数据 , 数据 , ... )
表示函数名称及搭配的参数表。调用符合函数名称及
相同参数数目的函数。

:{|

真值比较的结果，如果成功则传回true原子，失败则传回false原子。

请记得，Erlang是以true和false表示布尔数据类型。 | (略) |- | 操作符 | Erlang提供常用的操作符方便基本运算。操作符是用在中序的表达式里，包含 + - * / div(商) rem(余) 等。比特算算有 bnot, band, bor, bxor, bsl(算术左移), bsr(算术右移) 等。用于列表有 ++(列表衔接) --(列表剔除) 等。各种表达式皆可用 ( ) 调整运算优先级。 | (略) |- | 防卫式（页面存档备份，存于） | 防卫式是接在when关键字之后的一组表达式，借由防卫式的真伪值做程序控制处理。 防卫式的原则如下方所述：

1. 代表true或false的变量或原子，是防卫式。
2. 任何真值表达式，包括比较算式和逻辑算式，是防卫式。
3. 传回true或false的函数调用，是防卫式。
4. 以逗号分隔的多个防卫式，是防卫式。

|

• false
• A =< 10
• erlang:is_number(N), erlang:is_atom(A)

|- | 受防卫式限制的函数 | 函数对应规则格式为：

  原子 ( 变量 , 变量 , ... ) -> 表达式 , 表达式 , ...

若一条函数规则加上防卫式，此规则的处理范围会多一些限制。受防卫式限制的函数对应规则格式为：

  原子 ( 变量 , 变量 , ... ) when 防卫式 -> 表达式 , 表达式 , ...

|

• atom_pair(A, B) when is_atom(A), is_atom(B) -> {A, B}.

|- | 行后注解 | 任何 % 符号开头，往后到行尾的文本皆为注解文本。 | 'H.W.'. % Hello, World! |- | λ演算式 | λ演算式是匿名函数，在Erlang以 fun ... end 关键字叙述。格式为：

fun ( 变量 , 变量 , ... ) -> 表达式 , 表达式 , ... end

使用无参数的λ演算式，可以做出惰性求值的效果。 |

• (fun(X)->X>0 end)(1).

% (λ x . x > 0) 1

• lists:takewhile(

fun(X)->

X>0 and X=<10 end,

[1,5,11]).

|- | 因果式 | 使用 if ... end 关键字叙述条件判断原则。格式为：

if 防卫式 -> 表达式, 表达式, ... ;
   防卫式 -> 表达式, 表达式, ... ;
   ......
   防卫式 -> 表达式, 表达式, ...
end

|

• parse(A) ->

if

is_number(A),

round(A) == A,

A >= 0 ->

{natural, A};

is_number(A) ->

{real, A};

is_atom(A) ->

{word, A};

true ->

{unknown, A}

end.

|- | 案例式 | 使用 case ... of ... end 关键字，根据一个变量的案例，带往相对的处理进程。格式为：

case 表达式 of
   样式 -> 表达式, 表达式, ... ;
   样式 -> 表达式, 表达式, ... ;
   ......
   样式 -> 表达式, 表达式, ...
end

• 样式之后可接when防卫式。

|

• show(A) ->

case A of

{natural, N} ->

io:format("Natural number ~.10B is met.~n", [N]);

{real, R} ->

io:format("Real number ~f is met.~n", [R]);

{word, W} ->

io:format("\"~w\" is met.~n", [W]);

{unknown, U} ->

io:format("Unknown structure ~w.~n", [U])

end.

|- | 试误 | 使用 try ... catch ... end 关键字叙述试误的情况与结果。格式为：

try 表达式 of
   样式 -> 表达式, 表达式, ... ;
   样式 -> 表达式, 表达式, ... ;
   ......
   样式 -> 表达式, 表达式, ...
catch
   样式(例外) -> 表达式, 表达式, ... ;
   样式(例外) -> 表达式, 表达式, ... ;
   ......
   样式(例外) -> 表达式, 表达式, ...
after
   表达式, 表达式, ...
end

• 不需要使用after段落时，可省略after段落。
• 样式之后可接when防卫式。

| (略) |- | 接收消息 | 每个Erlang程序运行时，都可以从自己进程的邮箱中取得由其他进程送到的消息。可以使用 receive ... end 关键字接收消息，格式为：

receive
   样式 -> 表达式, 表达式, ... ;
   样式 -> 表达式, 表达式, ... ;
   ......
   样式 -> 表达式, 表达式, ...
end

• 样式之后可接when防卫式。

|

• loop(FromPid, Result) ->

receive

{FromPid, stop} ->

Result;

{FromPid, Any} ->

loop(FromPid, [Any|Result])

end.

|- | 发送消息 | Erlang容许向进程发送消息。使用 ! 关键字，格式为：

进程代号 ! 消息

• 消息可以是各种数据格式。消息数据格式可以是用各种表达式求出的值。

|

• Pid = erlang:spawn(

fun() ->

receive

X -> X

end

end)

• 以上产生一个进程。

• Pid ! {hello, world}

• 以上对Pid送出消息。

|- | 列表解析（页面存档备份，存于） | 列表解析，是提供快速创建列表的语法。语法等同于集合建构式（页面存档备份，存于）。格式为：

• [ 变量(表达式中的元素) || 变量(表达式中的元素) <- 表达式 , 防卫式 ]

若无防卫条件，列表解析中不写防卫式。

|

• [ X || X <- [1,2,3] ]

运算结果为[1,2,3]

|}

开源电信平台包括一个Erlang解释器、一个Erlang编译器、进程节点通信协定、CORBA、一个分布式数据库Mnesia（页面存档备份，存于）、以及许多程序库[6]。 内置函数涵盖了各种方面的功能，涵盖了系统命令、数据访问、格式转换、网络通信、图形接口、 ... 等。以下列表介绍几项常用的Erlang内置函数。(参阅文档（页面存档备份，存于）或索引 （页面存档备份，存于）)

> c:cd("D:\\code").
D:/code/
ok

> c:c(test). % test.erl 必须存在于目录位置
{ok, test}
> c:c(test1).
./test1.erl:none: ...
error

> io:format("~.8B, ~c, ~s, ~.2f~n", [32, $a, "hello", 3.1416]).
40, a, hello, 3.14
ok

> lists:sublist("Hello, World!", 2, 2).  
"el"

基本的平行程序示范如下：

• 以下启动一个进程。

% create process and call the function web:start_server(Port, MaxConnections)
ServerProcess = spawn(web, start_server, [Port, MaxConnections]),

• 以下是在任何程序中，对先前起动的进程送一则消息 {pause, 10} 。

% send the {pause, 10} message (a tuple with an atom "pause" and a number "10")
% to ServerProcess (asynchronously)
ServerProcess ! {pause, 10},

• 以下是一段接收消息的程序。每个进程都拥有一份邮箱，可伫留收到的消息； receive ... end 程序片断是从进程的邮箱中取出最早伫留的消息。

% receive messages sent to this process
receive       
        a_message -> do_something; 
        {data, DataContent} -> handle(DataContent);
        {hello, Text} -> io:format("Got hello message: ~s", [Text]);
        {goodbye, Text} -> io:format("Got goodbye message: ~s", [Text])
end.

收到 a_message 结果就是 do_something ；收到 {data, DataContent} 结果会调用 handle(DataContent) ；
收到 {hello, Text} 结果教是印出 "Got hello message: ..." ，收到 {goodbye, Text} 结果是印出
"Got goodbye message: ..." 。

以下程序，示范产生一组环状传递消息的进程。

ring_proc(Funs) ->
    Ns = lists:seq(1, length(Funs)),
    [P|Pids] = [ spawn(?MODULE, lists:nth(Nth,Funs),[]) || Nth <- Ns ],
    [ Pid ! ToPid || {Pid, ToPid} <- lists:zip([P|Pids], Pids++[P]) ]. 

func() ->
    receive
	ToPid ->
	    func_msg_(ToPid)
    end.

func_msg_(ToPid) ->
    receive
	stop ->
	    io:format("Stop process ~w~n", [self()]),
	    ToPid ! stop;
	Message ->
	    io:format("~w: transmit message to ~w~n", [self(), ToPid]),
	    ToPid ! Message,
	    func_msg_(ToPid)
    end.

接收stop消息，就对下一个进程送stop消息；接收到其他任何消息，就对下一个进程送同样的消息。

如果发送任何其他消息，就会让所有的进程不断对下一个进程传递消息。而以下是测试发送stop消息的运行结果。

> [P|_] = example:ring_proc([func,func,func]).
[<0.233.0>,<0.234.0>,<0.232.0>]
> P ! stop.
Stop process <0.233.0>
stop
Stop process <0.234.0>
> Stop process <0.232.0>
>

Erlang容错处理机制，由二个步骤实现：一是将二个进程连接起来，二者之间存在一道通信管道，可提供错误消息的传递 ── 在此使用link/1函数；二是将进程回报错误的机制打开 ── 在此使用process_flag/2函数。

• 使用link(Pid)让进程连接到另一个进程。

-module(example).
-compile(export_all).
hello() ->
    Pid = spawn(?MODULE, world, []),
    link(Pid),
    ... .

运行时，以 Pid = spawn(example, hello, []) 启动进程，此进程将启动另一个进程，并且与它连接。

但以上程序还不会有错误消息的传递机制，因为回报错误的开关还没有打开。

• 打开进程回报错误机制。

以上 hello/0 函数前段使用process_flag/2函数，将trap_exit标签打开，即可打开进程回报错误机制。

hello() ->
    process_flag(trap_exit, true),
    Pid = spawn(?MODULE, world, []),
    link(Pid),
    ... .

于是，当进程结束时，会送出{'EXIT', From, Reason}数据。进程正常结束时，Reason为normal。

另外，spawn函数另外有进程连接版本，spawn_link函数，同时启动并连接到新进程。

Erlang程序员可以使用惰性求值。不过，必须使用λ演算式，才能做到惰性求值。

以下是惰性求值的一例：假设有个剖析器程序如下，由于及早求值特征，本程序将不会求解。
expr() -> alt(then(factor(), then(literal($+), factor())),
              then(factor(), then(literal($-), factor()))).
factor() -> alt(then(term(), then(literal($*), term())),
                then(term(), then(literal($/), term()))).
term() -> alt(number(),
              xthen(literal($(), thenx(expr(), literal($))))).
此处使用λ演算式及适当使用函数名称表示，就能进行求值。示例如下。
expr() ->
    fun () ->
          alt(then(fun factor/0, then(literal($+), fun factor/0)),
              then(fun factor/0, then(literal($-), fun factor/0)))
    end.
factor() ->
    fun () ->
            alt(then(fun term/0, then(literal($*), fun term/0)),
                then(fun term/0, then(literal($/), fun term/0)))
    end.
term() ->
    fun () ->
          alt(number(),
              xthen(literal($(), thenx(expr(), literal($)))))
    end.