Best way to convert a flat list to a set of two-tuples in Erlang?

Question

Is there a fast way to convert a flat list into a list of two-tuples such that a flat list like [1,2,3,4,5,6] becomes [{1,2},{3,4},{5,6}]?

This works, but it feels just plain WRONG:

tuples_from_flat_list(Target) ->
    TargetWithIndex = lists:zip(lists:seq(1, length(Target)), Target),
    {K, V} = lists:partition(fun({I, _}) -> I rem 2 == 1 end, TargetWithIndex),
    lists:zipwith(fun({_, X}, {_, Y}) -> {X, Y} end, K, V).

Answer 1

This version is more efficient than 'straight' approach with lists concatenation proposed earlier:

combine(L) when length(L) rem 2 == 0 -> combine([], L).
combine(Acc, []) -> lists:reverse(Acc);
combine(Acc, [H1,H2|T])  -> combine([{H1, H2}|Acc], T).

To benchmark:

combine.erl

-module(combine).
-export([reverse/1, straight/1, test/2]).

test(F, L) -> {Micros, _} = timer:tc(?MODULE, F, [L]), Micros.

reverse(L) when length(L) rem 2 == 0 -> reverse([], L).                                  
straight(L) when length(L) rem 2 == 0 -> straight([], L).

reverse(Acc, []) -> lists:reverse(Acc);
reverse(Acc, [H1, H2 | T]) -> reverse([{H1, H2} | Acc], T).

straight(Acc, []) -> Acc;
straight(Acc, [H1, H2 | T]) -> straight(Acc ++ [{H1, H2}], T).

output:

130> combine:test(reverse, lists:seq(1,1000)).
34
131> combine:test(straight, lists:seq(1,1000)).
1772

Answer 2

tuples_from_flat_list(List) -> tuples_from_flat_list(List, []).

tuples_from_flat_list([], Result) -> lists:reverse(Result).
tuples_from_flat_list([X, Y|T], Acc) -> tuples_from_flat_list(T, [{X, Y}|Acc]).

It is best and fastest way.

Answer 3

The shortest and most succinct approach:

pair_up([A, B | Tail]) ->
    [{A,B} | pair_up(Tail)];
pair_up([]) ->
    [].

Or the longer version carrying an accumulator, but still very idiomatic Erlang:

pair_up(List) ->
    pair_up(List, []).

pair_up([A, B | Tail], Acc) ->
    pair_up(Tail, [{A,B} | Acc]);
pair_up([], Acc) ->
    lists:reverse(Acc).

See this section in the erlang efficiency guide "Myth: Tail-recursive functions are MUCH faster than recursive functions".

As you will notice, both approaches will lead to a 'badarg' exit when called with an uneven length list. This is probably desirable from a fail-fast perspective.

Also read "Myth: '++' is always bad" to see why we build up the accumulator in reverse only to reverse it when done, instead of appending to the end of the list.