Eu descobri os loops no estilo Erlang: recursão de cauda com funções que recebem todas as "variáveis que não variam":

%% does something, 80 bytes at a time
loop(Line, File) -> loop(Line, File, 0).
loop(Line, File, Count) -> 
    do_something(Line, Count),
    case file:read(File, 80) of
        {ok, Line2} -> loop(Line2, File, Count + 1);
        eof -> file:close(File);
        {error, Reason} -> {error, Reason}
    end.

Mas, qual é a melhor maneira de incrementar um contador em Erlang? Na maioria das linguagens de programação, a maneira como você conta as coisas é incrementando uma variável (por exemplo,count += 1;) As variáveis de Erlang não variam, por isso temos que ser criativos. Felizmente, temos opções ...

Podemos passar uma variável Counter com nossas funções e incrementá-la a cada chamada de função. Podemos usar o dicionário do processo para armazenar uma contagem eget eput para incrementá-lo. Podemos usar o ETS, o armazenamento local de dados para processos. Podemos usar um processo de contador (!!!):

loop(Count) ->                            
    receive                                   
        { incr } -> 
            loop(Count + 1);              
        { report, To } ->                     
            To ! { count, Count },            
            loop(Count)                           
    end.                                      

incr(Counter) ->
    Counter ! { incr }.

get_count(Counter) ->    
    Counter ! { report, self() },
    receive
        { count, Count } -> Count
    end.

Tenho certeza de que existem outras maneiras também, dependendo do escopo. O que é considerado "prática recomendada" para incrementar uma variável em Erlang?