Is there a more OCaml-esque way to convert a tuple list to list than what I did?

user_12770603 0
Viewed 87

My goal here was to convert a (int * int) list to an int list. This is what I did:

let tuples_list_to_list l =
  let rec aux_tuples_to_list acc l =
    match l with
    | [] -> acc
    | x :: tl -> aux_tuples_to_list (fst x :: snd x :: acc) tl in
  aux_tuples_to_list [] l

I was wondering if there was a more "elegant" even though this is subjective or at least better, way to write my function. I was thinking about using List.map or List.fold_left but I was having issues figuring out I could use those two functions to do the same thing I did. Basically, I think it would be possible to have a one-liner instead of the whole function I wrote.

What do you think? Thanks

tuples ocaml list functional-programming
2 Answers

This task is suited for List.concat_map (also known as "flat map" in some other languages):

(* List.concat_map : ('a -> 'b list) -> 'a list -> 'b list *)

let tuples_list_to_list l = 
  List.concat_map (fun (x, y) -> [x; y]) l

You can use List.fold_left, but you'll have to reverse the result at the end as the list is constructed in reverse order:

let tuples_list_to_list l = 
  List.rev (List.fold_left (fun acc (x, y) -> y :: x :: acc) [] l)
user_3206150

You can also deconstruct the tuple values in the pattern matching instead of using fst and snd (This version, unlike yours, gives a result list with the numbers in the same order as the orignal):

let tuples_list_to_list l =
  let rec aux_tuples_to_list acc l =
    match l with
    | [] -> List.rev acc
    | (x, y) :: tl -> aux_tuples_to_list (y :: x :: acc) tl in
  aux_tuples_to_list [] l

Yet Another Option is using List.fold_right, which avoids the need to reverse the accumulator list at the end at the cost of not being tail recursive:

let tuples_list_to_list l =
  List.fold_right (fun (x, y) acc -> x :: y :: acc) l [];;
user_99521960
Related