apply an array of arguments to a multi parameter function

[suimong]

I'm looking for an equivalent of argument "unpacking" in Python, i.e.:

def foo(a,b,c):
    return a+b+c

xs = [1,2,3]
foo(*xs)

So far the solution I've come up with is like this:

let foo = fun a b c => a + b + c in
let xs = [1,2,3] in

let rpipe = std.function.flip (|>) in
std.array.fold_left rpipe foo xs

Is there a more idiomatic way of achieving the same?

[yannham]

I don't think there's a more idiomatic way to do this currently. In the Nix world, it's common to take a record as an argument and destructure it in the function, to emulate named parameters:

let foo = fun {a, b, c ? 0} => a + b + c in
foo {a = 1, b = 2}

This provides some structure, and the ability to build and pass one structured argument . But nothing like this for arrays and positional arguments. If you need this repeatedly, the best you can do is probably to put this code in a helper function:

let apply_packed = fun f args =>
  let rpipe = std.function.flip (|>) in
  std.array.fold_left rpipe f args
in
apply_packed foo xs

[suimong]

Thanks for the feedback. I'm writing a test helper function that applies a record of multiple test cases to a testee function, and the input arguments for the testee function are stoed in an array, thus the need for the "unpacking" behavior. The current solution works well in my case.