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

Question

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?

Answer 1

The Python docs call this Unpacking Argument Lists. 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.

Answer 2

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.

Answer 3

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

See http://en.wikipedia.org/wiki/Apply

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:

 (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"

PARLANSE looks like lisp but isn't.

Answer 4

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

Answer 5

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

Answer 6

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.

Answer 7

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".