<17>Efficiency Guide之Function

1. 函数模式匹配
模式匹配，在函数头，case和receive从句都会被编译器优化，有一些优化排序后也没有好处，例如二进制的匹配。还有如下例子
DO NOT
atom_map1(one) -> 1;
atom_map1(two) -> 2;
atom_map1(three) -> 3;
atom_map1(Int) when is_integer(Int) -> Int;
atom_map1(four) -> 4;
atom_map1(five) -> 5;
atom_map1(six) -> 6.
DO

atom_map2(one) -> 1;
atom_map2(two) -> 2;
atom_map2(three) -> 3;
atom_map2(four) -> 4;
atom_map2(five) -> 5;
atom_map2(six) -> 6;
atom_map2(Int) when is_integer(Int) -> Int.
or

DO

atom_map3(Int) when is_integer(Int) -> Int;
atom_map3(one) -> 1;
atom_map3(two) -> 2;
atom_map3(three) -> 3;
atom_map3(four) -> 4;
atom_map3(five) -> 5;
atom_map3(six) -> 6.
因为第一种，如果one，two，three没有匹配上，那么编译器，总会匹配下一个，如果是four，five，six经过编译器优化后则不会匹配atom_map3(Int) when is_integer(Int) -> Int;

另一个例子是这样，
DO NOT

map_pairs1(_Map, [], Ys) ->
    Ys;
map_pairs1(_Map, Xs, [] ) ->
    Xs;
map_pairs1(Map, [X|Xs], [Y|Ys]) ->
    [Map(X, Y)|map_pairs1(Map, Xs, Ys)].

DO

map_pairs2(_Map, [], Ys) ->
    Ys;
map_pairs2(_Map, [_|_]=Xs, [] ) ->
    Xs;
map_pairs2(Map, [X|Xs], [Y|Ys]) ->
    [Map(X, Y)|map_pairs2(Map, Xs, Ys)].
the compiler is free to rearrange the clauses. It will generate code similar to this
要注意的是，这两种写法，就有及其细微的差别，Xs用[_|_] = Xs代替，仅此而已，这样，编译器可以进行优化为下面的写法
explicit_map_pairs(Map, Xs0, Ys0) ->
    case Xs0 of
[X|Xs] ->
    case Ys0 of
[Y|Ys] ->
    [Map(X, Y)|explicit_map_pairs(Map, Xs, Ys)];
[] ->
    Xs0
    end;
[] ->
    Ys0
    end.
这样的写法，如果参数非空或者很短，则比第一种写法更快

2.  关于函数的调用
(1) Calls to local or external functions (foo(), m:foo()) are the fastest kind of calls.
(2) Calling or applying a fun (Fun(), apply(Fun, [])) is about three times as expensive as calling a local function.
(这里的Mod:Name(),和apply(Mod,Name, []),应该是指自定义函数和用apply调用的函数)
(3) Applying an exported function (Mod:Name(), apply(Mod, Name, [])) is about twice as expensive as calling a fun, or about six times as expensive as calling a local function.
(这里是用apply的方法，调用外部函数，或用apply调用者自定义函数)
尽量多直接调函数，而不是用Fun, 或者apply，不过编译器会将apply(M, F, A)重新写为 M:F(A)

3  关于内存，erlang中所有的循环都来自递归，掌握递归至关重要，为了内存考虑，尽量用尾递归而不是一般的递归