In Python, we have the star (or “*” or “unpack”) operator, that allows us to unpack a list for convenient use in passing positional arguments. For example:

range(3, 6)
args = [3, 6]
# invokes range(3, 6)

In this particular example, it doesn’t save much typing, since range only takes two arguments. But you can imagine that if there were more arguments to range, or if args was read from an input source, returned from another function, etc. then this could come in handy.

In Scala, I haven’t been able to find an equivalent. Consider the following commands run in a Scala interactive session:

case class ThreeValues(one: String, two: String, three: String)

//works fine
val x = ThreeValues("1","2","3")

val argList = List("one","two","three")

//also works
val y = ThreeValues(argList(0), argList(1), argList(2))

//doesn't work, obviously
val z = ThreeValues(*argList)

Is there a more concise way to do this besides the method used in val y?

There is no direct equivalent in scala.
The closest thing you will find is the usage of _*, which works on vararg methods only.
By example, here is an example of a vararg method:

def hello( names: String*) {
  println( "Hello " + names.mkString(" and " ) )

which can be used with any number of arguments:

scala> hello()
scala> hello("elwood")
Hello elwood
scala> hello("elwood", "jake")
Hello elwood and jake

Now, if you have a list of strings and want to pass them to this method, the way to unpack it is through _*:

scala> val names = List("john", "paul", "george", "ringo")
names: List[String] = List(john, paul, george, ringo)
scala> hello( names: _* )
Hello john and paul and george and ringo    

You can get some way towards the Python using shapeless,

Welcome to Scala version 2.11.0-20130208-073607-ce32c1af46 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_05).
Type in expressions to have them evaluated.
Type :help for more information.

scala> import shapeless._
import shapeless._

scala> import Traversables._
import Traversables._

scala> case class ThreeValues(one: String, two: String, three: String)
defined class ThreeValues

scala> val argList = List("one","two","three")
argList: List[String] = List(one, two, three)

scala> argList.toHList[String :: String :: String :: HNil].map(_.tupled).map(ThreeValues.tupled)
res0: Option[ThreeValues] = Some(ThreeValues(one,two,three))

As you can see, a little more ceremony is required in Scala with shapeless. This is because shapeless imposes compile time constraints which are guaranteed to be satisfied at runtime (unlike the python, which will fail at runtime if args is the wrong size or contains elements of the wrong type) … instead you’re forced to specify the type you expect the List to have (in this case exactly three Strings) and be prepared to handle the case where that expectation isn’t satisfied (because the result is explicitly an Option of ThreeValues).

There is something similar for functiones: tupled It converts a function that takes n parameters into a function that takes one argument of type n-tuple.

See this question for more information: scala tuple unpacking

Such a method for arrays wouldn’t make much sense, because it would only work with functions with multiple arguments of same type.

Another way of unpacking a list:

val a :: b :: c :: _ = argList
val z = ThreeValues(a, b, c)