Name this python/ruby language construct (using array values to satisfy function parameters)

What is this language construct called?

In Python I can say:

def a(b,c): return b+c
a(*[4,5])

and get 9. Likewise in Ruby:

def a(b,c) b+c end
a(*[4,5])

What is this called, when one passes a single array to a function which otherwise requires multiple arguments?

What is the name of the `*` operator?

What other languages support this cool feature?

Ruby calls it **splat**, though David Black has also come up with the neat **unar{,ra}y operator** (i.e. **unary unarray operator**)

The typical terminology for this is called "applying a function to a list",
or "apply" for short.

See

[To see links please register here]

It has been in LISP since pretty much its inception back in 1960 odd.
Glad python rediscovered it :-}

Apply is typically on a *list* or a representation of a list such
as an array. However, one can apply functions to arguments that
come from other palces, such as structs. Our PARLANSE language
has fixed types (int, float, string, ...) and structures.
Oddly enough, a function argument list looks a lot like a structure
definintion, and in PARLANSE, it *is* a structure definition,
and you can "apply" a PARLANSE function to a compatible structure.
You can "make" structure instances, too, thus:

<pre><tt>

(define S
(structure [t integer]
[f float]
[b (array boolean 1 3)]
)structure
)define s

(= A (array boolean 1 3 ~f ~F ~f))

(= s (make S -3 19.2 (make (array boolean 1 3) ~f ~t ~f))


(define foo (function string S) ...)

(foo +17 3e-2 A) ; standard function call

(foo s) ; here's the "apply"

</tt></pre>
PARLANSE looks like lisp but isn't.

In ruby, it is often called "splat".

Also in ruby, you can use it to mean 'all of the other elements in the list'.

a, *rest = [1,2,3,4,5,6]
a # => 1
rest # => [2, 3, 4, 5, 6]

It can also appear on either side of the assignment operator:

a = d, *e

In this usage, it is a bit like scheme's cdr, although it needn't be all but the head of the list.

Haskell has it too (for pairs), with the `uncurry` function:

ghci> let f x y = 2*x + y
f :: (Num a) => a -> a -> a
ghci> f 1 2
4
ghci> f 10 3
23
ghci> uncurry f (1,2)
4
ghci> uncurry f (10,3)
23

You can also make it into an operator, so it's more splat-like:

ghci> f `uncurry` (1,2)
4
ghci> let (***) = uncurry
(***) :: (a -> b -> c) -> (a, b) -> c
ghci> f *** (10,3)
23

And though it'd be easy to define similar functions for the 3-tuple, 4-tuple, etc cases, there isn't any general function for `n`-tuples (like splat works in other languages) because of Haskell's strict typing.

The majority of the questions have already been answered, but as to the question "What is the name of the * operator?": the technical term is "asterisk" (comes from the Latin word *asteriscum*, meaning "little star", which, in turn, comes from the Greek *ἀστερίσκος*). Often, though, it will be referred to as "star" or, as stated above, "splat".

The Python docs call this [Unpacking Argument Lists][1]. It's a pretty handy feature. In Python, you can also use a double asterisk (**) to unpack a dictionary (hash) into keyword arguments. They also work in reverse. I can define a function like this:

def sum(*args):
result = 0
for a in args:
result += a
return result

sum(1,2)
sum(9,5,7,8)
sum(1.7,2.3,8.9,3.4)

To pack all arguments into an arbitrarily sized list.



[1]:

[To see links please register here]

I've been calling it "list expansion", but I don't think that's standard terminology (I don't think there's any...). Lisp in all versions (Scheme included), and Haskell and other functional languages, can do it easily enough, but I don't think it's easy to do in "mainstream" languages (maybe you can pull it off as a "reflection" stunt in some!-).