Я тут просто классический велосипед реализовываю  — попадание адреса в список масок (да-да, стандартная задача: локальное/мир/всё остальное).

[[],[[],[[[[[[[[],[[[],[[[],[[[[[[[[[[[],[[[[[[[[[[],[nil,nil]],[]],[]],[]],[]],[]],[]],[]],[]]],[]],[]],[]],[]],[]],[]],[]],[]],[]]],[]]],[]]],[]],[]],[]],[]],[]],[]]]]

И эти люди вынесли из стандартной установки Gimp со смехотворной мотивацией, что он много места занимает…

Причем оно, на самом деле, на строки не завязано.

ahocorasik:match([[{1,2,3}],[{3,2,1}], [{3,3,3},{1,2,3}]],[{1,2,3},4,5,6,7,8,{3,3,3},{1,2,3}]).
[{[{1,2,3}],[1,8]},{[{3,3,3},{1,2,3}],[7]}]

Только это не чистый Левенштейн, это Дамерау — Левенштейн.
Спёр себе, что-б было.

Проверил.

Из за того, что timer:tc точнее 1 микросекунды не считает, пришлось
для каждого варианта считать время выполнения 100 одинаковых операций.
Каждая такая итерация делалась 100000 раз и бралось среднее.

dict:find: при любом размере время выполнения 50-70 микросекунд
(напоминаю, это на 100 подряд вызовах, т.е. один вызов — где-то 0,5 -
0,7).

lists:keyfind:
номер элемента — время (здесь тоже помним про 100 вызовов).
1 — 4
10 — 8
20 — 12
30 — 15
100 — 46
150 — 67
200 — 87
300 — 130

Вобщем, где-то начиная с 300 элементов в списке имеет смысл переходить
на dict (если, конечно, нам не нужен постоянно последний элемент).

Допустим мы пишем функцию возвращающую номер месяца по его имени:

month('January') -> 1;
month('February') -> 2;
...
month('December') -> 12.

Что произойдёт, если вызвать эту функцию с «неправильным» параметром? Процесс упадёт, так как Ерланг не найдёт подходящей функции. А дальше у меня возникает «естественное» желание это отловить. Варианта три:
Совсем неправильный вариант — дописать

month(_other) -> {error, badmonth}.

Чуть менее неправильный вариант — переписать всё вот так:

month('January') -> {ok, 1};
month('February') -> {ok, 2};
...
month('December') -> {ok, 12};
month(_other) -> {error, badmonth}.

Особо изощренный неправильный вариант:

try
    M = month(MonthName)
catch
    _:_ -> ....
end

Есть еще варианты, но это, на самом деле, не важно. Потому что в этом месте ловить эту ошибку не нужно. Совсем не нужно. Оно должно упасть и пусть себе падает, всё равно никакого другого разумного выхода из этой ситуации нет, кроме как упасть и перезапуститься.
А почему приходится себя заставлять не делать эти проверки — это как раз «тяжелое наследие C/Pascal и иже с ним». Когда в течение многих лет приходилось помнить, что malloc может вернуть не только указатель, что fopen может вернуть не только хендл файла, когда неправильные параметры могут привести к не предсказуемым результатам.

Впрочем, я думаю, что у людей, которые начинали с чего-то более адекватного, хотя-бы с C++, я уж молчу про всякие Явы, нет такой проблемы. Они изначально знают, что функция или вернет что просят, или вывалится.

Do not future-proof your code. Don’t try to write code that will be able to deal with
every possible eventuality as the system evolves. It will make your code harder to un-
derstand and maintain, adding unnecessary complexity.

Но писать после этого на «обычных» языках становится немного сложно.

parse_task_info(Data) ->
{_, Dict} = parse_task_info(Data, #s{dict = dict:new()}),
Dict
.

parse_task_info([], S) -> {[], S#s.dict};

parse_task_info([$" |T], S)    when S#s.s =:= kquote    -> parse_task_info(T, S#s{token = [$"|S#s.token], s = kvalue});
parse_task_info([$" |T], S)    when S#s.s =:= nquote    -> parse_task_info(T, S#s{token = [$"|S#s.token], s = nvalue});
parse_task_info([H  |T], S)    when S#s.s =:= kquote orelse S#s.s =:= nquote    -> parse_task_info(T, S#s{token = [H|S#s.token]});
parse_task_info([$  |T], S)                                 -> parse_task_info(T, S);
parse_task_info([$= |T], S)    when S#s.s =:= start    -> parse_task_info(T, S#s{key = lists:reverse(S#s.token), token = «», s = kvalue});
parse_task_info([$( |T], S)    when S#s.s =:= start    -> parse_task_info(T, S#s{token = «», s = name});
parse_task_info([$( |T], S) when S#s.s =:= kvalue    ->
{Tn, Dict} = parse_task_info(T, S#s{root = sjoin(S#s.root, S#s.key), token = «», s = name}),
parse_task_info(Tn, S#s{dict = Dict, s = start, token=»"})
;
parse_task_info([$) |T], S) when S#s.s =:= name        -> parse_task_info(T, S#s{key = lists:reverse(S#s.token), token = «», s = nvalue});
parse_task_info([$" |T], S)    when S#s.s =:= kvalue     -> parse_task_info(T, S#s{token = [$"|S#s.token], s = kquote});
parse_task_info([$" |T], S)    when S#s.s =:= nvalue    -> parse_task_info(T, S#s{token = [$"|S#s.token], s = nquote});
parse_task_info([$, |T], S)    when S#s.s =:= start    ->
{T, S#s.dict}
;
parse_task_info([$, |T], S)    when S#s.s =:= kvalue    ->
Dict = dict:store(sjoin(S#s.root,S#s.key), lists:reverse(S#s.token), S#s.dict),
parse_task_info(T, S#s{dict = Dict, token = «», s = start})
;
parse_task_info([$,|T], S)        when S#s.s =:= nvalue    ->
Dict = dict:store(sjoin(S#s.root,S#s.key), lists:reverse(S#s.token), S#s.dict),
{T, Dict}
;
parse_task_info([$}|T], S)        when S#s.s =:= start    ->
{T, S#s.dict}
;
parse_task_info([${|T], S)        when S#s.s =:= nvalue    ->
{Tn, Dict} = parse_task_info(T, S#s{root = sjoin(S#s.root, S#s.key), token = «», s = start}),
parse_task_info(Tn, S#s{dict = Dict, s = start, token=»"})
;
parse_task_info([H|T], S)                                -> parse_task_info(T, S#s{token = [H|S#s.token]})
.

sjoin(«», «») -> «»;
sjoin(«», N2) -> N2;
sjoin(N1, «») -> N1;
sjoin(N1, N2) -> N1 ++ «.» ++ N2.

Что бы можно было для функции написать три «тела» — что делать в обычном случае, что делать в случае «отката» и что делать в случае «откат не удался». Приходится писать настолько феерически некрасиво и многословно, отрабатывая на каждом шагу каждый чих, что в результате основной алгоритм теряется в нагромождении if/case/try.

Впрочем, ерланговый подход «дай ему умереть» помогает с этим не то что бы справиться, но, по крайней мере, как-то упорядочить. Особенно если придерживаться еще одного правила — «молчи, если не спрашивают» (т.е. функция set(some, value) не должна ничего возвращать никогда).

Попутно задумался о применимости dz-товского фантома. Может я, конечно, чего-то не понимаю, но по моим ощущениям применимость идеи фантома ограничена случаем «нечто в себе с очень ограниченным взаимодействием со внешним миром». Ну т.е. настолько редкий и мизерный выигрыш от пресловутой persistence, что даже не смешно.

P.S. А вобще этопросто проверка кросспоста в FB.

Хочу просто предупредить тех, кто
пользуется DETS и/или  Mnesia на 32-х битных системах и у кого размеры
DAT приближаются к 2Г — оно умеет портить DAT файлы. Вот пример, там
всё видно.:

ufm@imac:~/src$ erl
Erlang R13B01 (erts-5.7.2) [source] [smp:2:2] [rq:2] [async-threads:0]
[kernel-poll:false]

Eshell V5.7.2  (abort with ^G)
1> BigL = lists:seq(1,2000000).
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,
23,24,25,26,27,28,29|...]
2> dets:open_file(tab,[{type,set}]).
{ok,tab}
3> dets:info(tab).
[{type,set},
{keypos,1},
{size,0},
{file_size,5432},
{filename,"tab"}]
4> lists:foreach(fun(X) -> dets:insert(tab,{X,BigL}) end, lists:seq
(1,50)).
ok
5> dets:info
(tab).
[{type,set},
{keypos,1},
{size,50},
{file_size,848861394},
{filename,"tab"}]
6> dets:close(tab).
ok
7> dets:open_file(tab,
[{type,set}]).
{ok,tab}
8> dets:info
(tab).
[{type,set},
{keypos,1},
{size,50},
{file_size,848861666},
{filename,"tab"}]
9> lists:foreach(fun(X) -> dets:insert(tab,{X,BigL}) end, lists:seq
(50,200)).
ok
10> dets:info
(tab).
[{type,set},
{keypos,1},
{size,126},
{file_size,2066820196},
{filename,"tab"}]
11> dets:close
(tab).
{error,{{bad_object,read_buckets},»tab»}}
12> dets:close
(tab).
{error,not_owner}
13> dets:info
(tab).
undefined
14> dets:open_file(tab,
[{type,set}]).
dets: file «tab» not properly closed, repairing …
{error,{no_more_space_on_file,»tab.TMP»}}
15>

Eshell V5.6.5 (abort with ^G)
1> A=[255||X<-lists:seq(1,20000000)],ok.
ok
2> B=list_to_binary(A).
<<»\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377″…>>
3>
3> byte_size(B).
20000000
4> byte_size(B).
20000000
5> byte_size(B).
20000000

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

Ага. Список. От 1 до 256. И как я 256 собрался в binary переводить?

Вот это — тоже весело:

1> L=lists:seq(1,256).
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,
23,24,25,26,27,28,29|...]
2> B=list_to_binary(L).
** exception error: bad argument
in function list_to_binary/1
called as list_to_binary([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,
23,24,25,26,27,28|...])

ну и напоследок:

34> f().
ok
35> L=lists:seq(1,256).
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,
23,24,25,26,27,28,29|...]

Crash dump was written to: erl_crash.dump
eheap_alloc: Cannot allocate 1425410620 bytes of memory (of type «heap»).
Aborted

tmt = 5;
tmt = fun1(tmt);
tmt = fun2(tmt);
tmt = fun3(tmt);

Как это приходится писать на эрланге

Tmt = 5,
Tmt1 = fun1(Tmt),
Tmt2 = fun2(Tmt1),
Tmt3 = fun3(Tmt2).

В результате достаточно в третьей строчке ошибиться и написать Tmt (при копипейстинге из другого места, реорганизации кода или просто опечататься) и ловить эту ошибку придется достаточно долго. Особенно когда переменная Tmt1 используется между функциями fun1 и fun2 — компилятор даже предупреждения не даст, что переменная нигде не используется.
Хотя, конечно, возможно это просто у меня с непривычки.

P.S. А постоянное слежение за тем, когда писать ‘,’ когда ‘;’ а когда вобще ничего — это отдельная песня. :)

Eshell V5.6.5 (abort with ^G)
1> c(«/home/ufm/src/tmt», [{outdir, "/home/ufm/src/"}]).

{ok,tmt}

2> tmt:pow(2,16).
65536

3> tmt:pow(2,2).
4

4> tmt:pow(1024,1024).
352497141210838265713481483980028154643914213439664710603913826057310702768547493650483
302964736638624569681553952983739732590494759431136198883386731161336668147068707652719
076562056460186083699855587212676703217390319386338332818891926201584265318069231442392
697268763999519611919803480232917034723057637824103945897589345856311110781204353030326
888187514464352913713571717556327753629326947950763134366874696380043276893902467353218
558306108568659249137608267637760032658517165573342106422773434757577997804990215598224
124342750870843172934551295704067075900020717046731355275335432173559875681076975779467
857964124560483600729656168710248662446500810590681830381345185142229871868373945980198
595129936003792361901975768389050807333599890946870089994162477220200619925599314018723
573797084885850036669659306097304307741074074940180653658450770943205347006923544001698
241315783891536569167546822524255627428950268220861122361857689319404333240786923864636
423780292915823845509040122842652771246674528169856593374975809915925102014797665008774
278345666191563143881075857435462890675510524340756781953453733639195713232101136226155
117651343296272079557936053768928759383576728708813056793055212933599754278019219975348
914740908681134673577843597833830910857171008072284250312267769851973643594046830415066
139436466661994548993636858018487767296858378032282161138338547424434092214804502325631
304177096253207949716727377373859839755200477399781651249069168579319609024073978415366
576503787580124091572059395130853242824392901089090690365154306903599631529865877499305
168806703261450369876070529616967815564185509662018228218579780200625368240156976209572
227380655388321870974098595026691965890259611994487589973737929731917233355497723948788
740508545327859224758228364037939866231931740209314323814184370227604126822763829893548
396254532412898071082609051342346791309548675704473545497601746910070785284527450279949
438532294805445123688313787611196816167193276373081423151051205287046835151820383202250
786653139117317493642556212844343049454372146094060086405209720295099554355680948888157
014704194108891565239711821728144232741409554280705943283816670482867719728577034355258
035447078345677740272066141434199824101092619306983110108578748668407438514728576453309
291695484037510844947258937293554504737710599868010583420219027353676279009748723681378
389963973798981614548259709107328582027812829739376428479733818386729806933990394293426
130015951489680820100160610223162428423676727412654054345531072966235596044133263521405
296181711754506578842550993346187227316979201855824371823913976733011681606825166392147
065669814659617313748089491317423647529930783263677141170014042109302515381324422193350
726720968651846913030271569624397770537072865839497640551512918164025464624527191347971
790992102335775962779256460318241722748740845621134400433973951910654736207171042506860
408965809287008425939191732838445314709522056008744823024885238670745329077812649908653
518446848070122080391082875645348545004863915388760636114766656202302948114683518353740
72060530215907909311281816131942219776

«мамой клянусь равно», «что-то типа», «даже рядом не лежало с» и «в общем то по барабану».