¿Cómo puede Scala recibir múltiples parámetros en una definición de método?

Question

Java tiene:

public void someMethod(int ... intArray) { // question: what is the equivalent to "..." 
    // do something with intArray 
} 

cómo puedo conseguir la misma funcionalidad en Scala? Es decir, ¿pasar un número indefinido de parámetros a un método?

Answer 1

def someMethod(values : Int*) 

Da una matriz. Coloque el parámetro argumento variable como el último parámetro formal.

Answer 2

Tanto Java como Scala tienen varargs, y ambos solo son compatibles con los últimos parámetros.

def varargTest(ints:Int*) { ints.foreach(println) } 

De this article, la diferencia está en el tipo de las utilizadas para los argumentos varargs:

• matriz para Java
• Seq (Secuencia) para Scala: puede ser iterado y muchos métodos tales como colecciones foreach, map, filter, find, ... están disponibles

El '*' representa 0 o más argumentos.

Nota: si los valores de los parámetros ya están "empaquetados" como una secuencia, tal como una lista, falla:

# varargTest(List(1,2,3,4,5)) 
# //--> error: type mismatch; 
# //--> found : List[Int] 
# //--> required: Int 
# //-->  varargTest(List(1,2,3,4,5)) 
# //--> 

Pero esto va a pasar:

varargTest(List(1,2,3):_*) 
    //--> 1 
    //--> 2 
    //--> 3 

'_' es un atajo de marcador de posición para la inferencia de tipo. '_*' se aplica aquí a un 'tipo repetido.
la Sección 4.6.2 de Scala Specification menciona:

El parámetro último valor de una sección parámetro puede ser el sufijo “*”, por ejemplo (..., x:T *).
El tipo de dicho parámetro repetido dentro del método es entonces el tipo de secuencia scala.Seq[T].
Los métodos con parámetros repetidos T* toman una cantidad variable de argumentos del tipo T.

(T1, . . . , Tn,S*)U => (T1, . . . , Tn,S, . . . , S)U, 

La única excepción a esta regla es que el último argumento está marcado para ser un argumento a través de una secuencia de anotación _* tipo.

(e1, . . . , en,e0: _*) => (T1, . . . , Tn, scala.Seq[S]). 

Nota bis: cuidado de la borradura tipo subyacente de Java:

//--> error: double definition: 
//--> method varargTest:(ints: Seq[Int])Unit and 
//--> method varargTest:(ints: Int*)Unit at line 10 
//--> have same type after erasure: (ints: Sequence)Unit 
//--> def varargTest(ints:Seq[Int]) { varargTest(ints: _*) }