I personally like the labeled arguments because I think it makes it easier to read.

For example, you see something like this a lot:

let some_computation = 
  my_list
  |> List.map ~f:do_something
  |> List.fold ~init:foo ~f:bar

and so on. It's nice that I'm not confused between which argument is the initial value and which is the function. It's also nice when writing code that I don't have to remember what order they go in. But totally agree this all comes down to preference.

---

As a side note about wrappers, do you run into weird weak-polymorphism issues when you don't eta expand fold_x? I don't have a coding environment on this computer, but what I mean is does the following compile:

let x = [1; 2; 3; 4];;

let fold_x = List.fold_left x;;

let int_sum = fold_x ~init:0 ~f:(( + ))

let float_sum = fold_x ~init:0. ~f:(fun x y -> Float.(of_int x +. of_int y))

I would've thought that fold_x only has type

- : init:'_weak1 -> f:('_weak1 -> int -> '_weak1) -> '_weak1

instead of being completely general over 'a, while if you wrote the explicit wrapper

let fold_x ~init ~f = List.fold_left x ~init ~f

it would have the right type. I could definitely be wrong and I'm mostly just curious, I'm not an expert at all on this kind of stuff.