Erlang: elegancka tuple_to_list/1

Question

Przedstawiam się Erlangowi przez Armstrongs "Programming Erlang". Jednym z ćwiczeń jest napisanie reeimplementacji tuple_to_list/1 BIF. Moje rozwiązanie wydaje mi się raczej nieeleganckie, szczególnie z powodu funkcji pomocnika, której używam. Czy istnieje inny sposób na robienie tego Erlang?

tup2lis({}) -> []; 
tup2lis(T) -> tup2list_help(T,1,tuple_size(T)). 

tup2list_help(T,Size,Size) -> [element(Size,T)]; 
tup2list_help(T,Pos,Size) -> [element(Pos,T)|tup2list_help(T,Pos+1,Size)]. 

Dziękuję bardzo za Twoje pomysły. :)

Answer 1

Myślę, że twoja funkcja jest w porządku, a więcej, jeśli twoim celem jest nauka języka. Co do stylu, zazwyczaj podstawową budową list jest tylko pusta lista []. Więc będę pisać

tup2list(Tuple) -> tup2list(Tuple, 1, tuple_size(Tuple)). 

tup2list(Tuple, Pos, Size) when Pos =< Size -> 
    [element(Pos,Tuple) | tup2list(Tuple, Pos+1, Size)]; 
tup2list(_Tuple,_Pos,_Size) -> []. 

można napisać prawie to samo z listowego

[element(I,Tuple) || I <- lists:seq(1,tuple_size(Tuple))]. 

będzie działać zgodnie z oczekiwaniami, gdy krotka nie ma elementów, jak listy SEQ (1,0) daje pustą listę.

Answer 2

Twój kod jest dobry, a także idiomatyczny sposób tworzenia tego rodzaju rzeczy. Możesz także zbudować tę listę wstecz, która w tym przypadku będzie trochę szybsza z powodu wywołania ogona, ale nieistotna.

tup2list(T) -> tup2list(T, size(T), []). 

tup2list(T, 0, Acc) -> Acc; 
tup2list(T, N, Acc) -> tup2list(T, N-1, [element(N,T)|Acc]). 

Answer 3

W Erlang R16B można również użyć erlang:delete_element/2 funkcję tak:

tuple2list({}) -> []; 
tuple2list(T) when is_tuple(T) -> 
    [element(1, T) | tuple2list(erlang:delete_element(1, T))]. 

Answer 4

Erlang 17,0, należy zbudować listę w porządku naturalnego, rozwiązania powyżej jest błędne z punktu skuteczności. Zawsze dodawać elementy do głowy istniejącej listy:

%% ==================================================================== 
%% API functions 
%% ==================================================================== 
my_tuple_to_list({}) -> 
    []; 
my_tuple_to_list(Tuple) -> 
    tuple_to_list_iter(1, size(Tuple), Tuple, []) 
. 
%% ==================================================================== 
%% Internal functions 
%% ==================================================================== 
tuple_to_list_iter(N, N, Tuple, List) -> 
    lists:reverse([element(N, Tuple)|List]); 

tuple_to_list_iter(N, Tuplesize, Tuple, List) -> 
    L = [element(N, Tuple)|List], 
    tuple_to_list_iter(N + 1, Tuplesize, Tuple, L)  
. 

Answer 5

mytuple_to_list(T) when tuple_size(T) =:= 0 -> []; mytuple_to_list(T) -> [element(1, T)|mytuple_to_list(erlang:delete_element(1, T))].

Answer 6

jestem próby ćwiczeń z Joe Armstrong książce Oto co wymyśliłem

my_tuple_to_list(Tuple) -> [element(T, Tuple) || T <- lists:seq(1, tuple_size(Tuple))].