Pattern matching или перегрузка функций

  
Обязательно прочтите PS ;)

    Итак у Erlang-a замечательная функциональная парадигма. Собственно поэтому некоторые особо  одаренные программисты просто вешаются увидев, когда кто-то пишет на эрланге не в функциональном стиле. Собственно этот пост призван расставить все точки на "И". Пишем абстрактный код вида

-module(func).
-export([test_function_over/1,test_function/1]).

test_function_over(Elem)->
test_function_over_low(Elem rem 2)
.
test_function_over_low(1)->
1;
test_function_over_low(_)->
0.

test_function(Elem)->
case Elem rem 2 of
1 -> 1;
_ -> 0
end

Две функции возвращают четность числа. Далее используем наш любимый модуль

-module(meash_loop).
-export([loop/2]).



loop(Fun,List) when is_list(List) ->
First=now(),
lists:map(Fun,List),
Second=now(),
timer:now_diff(Second,First)
;

loop(Fun,Num)->
First=now(),
lists:map(Fun,lists:seq(1, Num) ),
Second=now(),
timer:now_diff(Second,First)
.

Открываем консоль, и измеряем скорость работы варианта с перегрузкой функции.

Fun={func,test_function_over}.
{func,test_function_over}
2> meash_loop:loop(Fun,1000000).
214185
3> meash_loop:loop(Fun,1000000).
201673
4> meash_loop:loop(Fun,1000000).
172881
5> meash_loop:loop(Fun,1000000).
151168
6> meash_loop:loop(Fun,1000000).
210622
7> meash_loop:loop(Fun,1000000).
175140
8> meash_loop:loop(Fun,1000000).
135384
9> meash_loop:loop(Fun,10000000).

А теперь вариант с обычным case

10> Fun1={func,test_function}.
{func,test_function}
11> meash_loop:loop(Fun1,10000000).
1815741
12> meash_loop:loop(Fun1,10000000).
1395509
13> meash_loop:loop(Fun1,10000000).
1408302
14> meash_loop:loop(Fun1,10000000).
1380560
15> meash_loop:loop(Fun1,1000000).
130111
16> meash_loop:loop(Fun1,1000000).
114137
17> meash_loop:loop(Fun1,1000000).
111419
18> meash_loop:loop(Fun1,100000000).
24698272

Но....это не все! В последней функции мы тестируем 100 миллионов записей..и если запустить его через перегруженную функцию...

meash_loop:loop(Fun,100000000).

Crash dump was written to: erl_crash.dump
eheap_alloc: Cannot allocate 1425410620 bytes of memory (of type "old_heap").

Нода вообще упала. И естественно повторим опыт снова.

Fun={func,test_function_over}.
{func,test_function_over}
2> Fun1={func,test_function}.
{func,test_function}
3> meash_loop:loop(Fun,100000000).

Crash dump was written to: erl_crash.dump
eheap_alloc: Cannot allocate 912262800 bytes of memory (of type "heap").
Aborted

То есть перегрузка перегрузке рознь и надо иметь ввиду, что мы можем вообще упасть к чертовой матери. Ну и если есть возможность использовать таки оператор case вместо перегрузки, то его имеет смысл использовать, так как он просто работает в два раза быстрее. Хотя любого программиста, знающего хотя бы на начальном уровне С, это не должно вызвать удивление. Для чистоты эксперимента расширим наши функции - будем проверять четыре случая.

-module(func).
-export([test_function_over/1,test_function/1]).

test_function_over(Elem)->
test_function_over_low(Elem rem 4)
.
test_function_over_low(1)->
1;
test_function_over_low(2)->
1;
test_function_over_low(3)->
1;
test_function_over_low(_)->
0.

test_function(Elem)->
case Elem rem 4 of
1 -> 1;
2 -> 1;
3 -> 1;
_ -> 0
end

.

Запускаем...

Erlang R14B (erts-5.8.1) [source] [smp:2:2] [rq:2] [async-threads:0] [hipe] [kernel-poll:false]

Eshell V5.8.1 (abort with ^G)
1> Fun={func,test_function_over}.
{func,test_function_over}
2> meash_loop:loop(Fun,1000000).
220398
3> meash_loop:loop(Fun,1000000).
233658
4> meash_loop:loop(Fun,1000000).
189970
5> meash_loop:loop(Fun,1000000).
154579
6> meash_loop:loop(Fun,10000000).
3249755
7> Fun1={func,test_function}.
{func,test_function}
8> meash_loop:loop(Fun1,10000000).
1890353
9> meash_loop:loop(Fun1,10000000).
1445280
10> meash_loop:loop(Fun1,10000000).
1457562
11> meash_loop:loop(Fun1,1000000).
112326
12> meash_loop:loop(Fun1,1000000).
141889
13> meash_loop:loop(Fun1,1000000).
119721
14> meash_loop:loop(Fun1,1000000).
115111
15>

Собственно отставание перегруженной функции примерно в два раза - к слову сказать это весьма не плохой результат, но все же быстрее простой оператор case.

P.S
  В комментариях тема раскрывается еще больше, не знаю подводит ли итог. Как оказалось много позже собственно благодаря вот этому,
Erlang раскатывает перегрузку функции в последовательность CASE.
Ну и обозначенные выше тесты  были слишком просты, каюсь был грешен, что бы склонить  чашу весов в чью-то сторону. Собственно, и склонять их в чью-то сторону не хотел. Тут вопрос остается лишь в том, кто лучше оптимизирует исходный код ты или компилятор, пока человек наверно выигрует раз case до сих пор не упразднили.

P.S.S
Это не призыв применять только оператор case и забыть вообще про функциональное программирование. Это призыв не фанатеть от убойной функциональности эрланга.