¿Cómo creo una matriz heterogénea en Scala?

Question

en JavaScript, podemos hacer:

["a string", 10, {x : 1}, function() {}].push("another value"); 

Cuál es el equivalente Scala?

Answer 1

Las matrices en Scala son muy homogéneas. Esto se debe a que Scala es un lenguaje estáticamente tipado. Si realmente necesita características pseudo heterogéneas, debe usar una estructura de datos inmutables que se parametrice de forma coherente (son las estructuras de datos más inmutables). List es el ejemplo canónico allí, pero Vector también es una opción. A continuación, puede hacer algo como esto:

Vector("a string", 10, Map("x" -> 1),()=>()) + "another value" 

El resultado será de tipo Vector[Any]. No es muy útil en términos de tipeo estático, pero todo estará allí según lo prometido.

Por cierto, la "sintaxis literal" para matrices en Scala es el siguiente:

Array(1, 2, 3, 4)  // => Array[Int] containing [1, 2, 3, 4] 

Ver también: More info on persistent vectors

Answer 2

Scala podría tener la capacidad para obtener una lista "heterogéneo" pronto : HList in Scala

Answer 3

Scala elegirá el tipo de elemento de matriz más específico que pueda contener todos los valores, en este caso se necesita el tipo más general Any que es un supertipo de cualquier otro tipo:

Array("a string", 10, new { val x = 1 },() =>()) :+ "another value" 

La matriz resultante será de tipo Array[Any].

Answer 4

Personalmente, probablemente usaría tuplas, como menciona en un comentario.

scala> ("a string", 10, (1),() => {}) 
res1: (java.lang.String, Int, Int,() => Unit) = (a string,10,1,<function0>) 

Pero no se puede agregar fácilmente a tales estructuras.

La HList mencionada por ePharaoh está "hecha para esto", pero probablemente me mantendría alejado de ella. Es pesado en la programación de tipos y, por lo tanto, puede llevar consigo cargas sorprendentes (es decir, crear muchas clases cuando se compila). Sólo sé cuidadoso. Un nodo Hlist de los anteriores (necesita biblioteca MetaScala) sería (no probada, puesto que yo no uso MetaScala):

scala> "a string" :: 10 :: (1) ::() => {} :: HNil 

puede anexar etc. (bueno, al menos anteponer) a una lista de este tipo, y sabrá los tipos. El preanálisis crea un nuevo tipo que tiene el tipo antiguo como cola.

Luego hay un enfoque aún no mencionado. Las clases (especialmente clases de casos) son muy ligeros en la Scala y usted puede hacer como una sola línea:

scala> case class MyThing(str: String, int: Int, x: Int, f:() => Unit) 
defined class MyThing 

scala> MyThing("a string", 10, 1,()=>{}) 
res2: MyThing = MyThing(a string,10,1,<function0>) 

Por supuesto, esto no va a manejar ya sea añadiendo.