Erlang: thanh lịch tuple_to_list/1

Question

Tôi được giới thiệu về Erlang bởi Armstrongs "Lập trình Erlang". Một bài tập là viết một bản tái xác nhận của tuple_to_list/1 BIF. Giải pháp của tôi có vẻ khá không phù hợp với tôi, đặc biệt là vì chức năng trợ giúp tôi sử dụng. Có một cách Erlang-ish hơn để làm điều này?

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)]. 

Cảm ơn bạn rất nhiều vì ý tưởng của bạn. :)

Answer 1

Tôi nghĩ chức năng của bạn là ok và hơn thế nữa nếu mục tiêu của bạn là học ngôn ngữ. Như một vấn đề về phong cách, thường là trường hợp cơ bản khi xây dựng danh sách chỉ là danh sách rỗng []. Vì vậy, tôi muốn viết

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) -> []. 

bạn có thể viết khá nhiều việc cùng với danh sách hiểu

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

nó sẽ làm việc như mong đợi khi tuple không có các yếu tố, như danh sách: seq (1,0) đưa ra một danh sách trống.

Answer 2

Mã của bạn tốt và cũng là cách thành ngữ cách tạo loại nội dung này. Bạn cũng có thể xây dựng danh sách này ngược lại trong trường hợp này sẽ nhanh hơn một chút vì cuộc gọi đuôi nhưng không đáng kể.

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

Trong Erlang R16B bạn cũng có thể sử dụng chức năng erlang:delete_element/2 như thế này:

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

Answer 4

Erlang 17,0, bạn nên xây dựng danh sách theo thứ tự tự nhiên, các giải pháp trên là không chính xác từ quan điểm hiệu quả. Luôn thêm các yếu tố để người đứng đầu của danh sách hiện:

%% ==================================================================== 
%% 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

Tôi đang cố gắng tập từ Joe Armstrong cuốn sách, đây là những gì tôi đã đưa ra

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