Multiple assignment in Scala without using Array?

Simple answer

val Array(a, b, xs @ _*) = "1 2 3 4 5".split(" ")

The syntax you are seeing here is a simple pattern-match. It works because "1 2 3 4 5".split(" ") evaluates to an Array:

scala> "1 2 3 4 5".split(" ")
res0: Array[java.lang.String] = Array(1, 2, 3, 4, 5)

Since the right-hand-side is an Array, the pattern on the left-hand-size must, also, be an Array

The left-hand-side can be a tuple only if the right-hand-size evaluates to a tuple as well:

val (a, b, xs) = (1, 2, Seq(3,4,5))

More complex answer

Technically what's happening here is that the pattern match syntax is invoking the unapply method on the Array object, which looks like this:

def unapplySeq[T](x: Array[T]): Option[IndexedSeq[T]] =
  if (x == null) None else Some(x.toIndexedSeq)

Note that the method accepts an Array. This is what Scala must see on the right-hand-size of the assignment. And it returns a Seq, which allows for the @_* syntax you used.

Your version with the tuple doesn't work because Tuple3's unapplySeq is defined with a Product3 as its parameter, not an Array:

def unapply[T1, T2, T3](x: Product3[T1, T2, T3]): Option[Product3[T1, T2, T3]] =
  Some(x)

You can actually "extractors" like this that do whatever you want by simply creating an object and writing an unapply or unapplySeq method.

The answer is:

val a :: b :: c = "1 2 3 4 5".split(" ").toList

Should clarify that in some cases one may want to bind just the first n elements in a list, ignoring the non-matched elements. To do that, just add a trailing underscore:

val a :: b :: c :: _ = "1 2 3 4 5".split(" ").toList

That way:

c = "3" vs. c = List("3","4","5")

I'm not an expert in Scala by any means, but I think this might have to do with the fact that Tuples in Scala are just syntatic sugar for classes ranging from Tuple2 to Tuple22.

Meaning, Tuples in Scala aren't flexible structures like in Python or other languages of the sort, so it can't really create a Tuple with an unknown a priori size.

We can use pattern matching to extract the values from string and assign it to multiple variables. This requires two lines though.

Pattern says that there are 3 numbers([0-9]) with space in between. After the 3rd number, there can be text or not, which we don't care about (.*).

val pat = "([0-9]) ([0-9]) ([0-9]).*".r
val (a,b,c) = "1 2 3 4 5" match { case pat(a,b,c) => (a,b,c) }

Output

a: String = 1
b: String = 2
c: String = 3