escala - no puede resolver el símbolo:

Soy nuevo en Scala y tengo alguna pregunta sobre por qué string::List() obras List()::s ¿No? También quiero saber si ListBuffer funciona mejor que ::?

val columnNames :List[String] = ['foo','bar']
val work :List[String] = List()
for (s <- columnNames) {
  s match {
     //this doesn't compile
     //case workPattern => work :: s
     //this works        
     case workPattern => s :: work
     // this also works
     case workPattern => work :: List(s)
}

Pregunta hecha hace 3 años, 4 meses, 27 días - Por pixelpilot

4 Respuestas:

  • a :: b literalmente significa "add un elemento a al comienzo de una lista b". Crea nueva lista con a como cabeza y b como una cola.

    Para el elemento apéndice de la lista se puede utilizar ++o algo así work ::: "foo" :: NilEste último no es muy eficiente, por supuesto.

    Para la segunda parte de una pregunta, como se indica en la documentación:

    Time: List has O(1) prepend and head/tail access. 
Most other operations are O(n) on the number of elements in the list. 
This includes the index-based lookup of elements, length, append and reverse.
Space: List implements structural sharing of the tail list. 
This means that many operations are either zero- or constant-memory cost.

    Así que depende del tamaño y los tipos de operaciones que usted necesita para realizar que es preferible rendimiento-sabio.

    Respondida el Dec 18, 2020 a las 05:57 - por algorithmadeptc6cb

    Votos positivos: 0 | Votos negativos: 0

  • La función a la que llamas s :: work es List.::. Scala String es sólo un alias para la cadena de Java, por lo tanto no expone operadores como ::. s :: work equivale a work.::(s).

    Para más información puede consultar Cómo añadir elementos a una lista en Scala (Lista, ListBuffer) y Scala Ejemplos de clase de lista: rango, relleno, tabulado, pendiente, ante... por el gran Alvin Alexander.

    Respondida el Dec 18, 2020 a las 06:04 - por codecrusader

    Votos positivos: 0 | Votos negativos: 0

  • El error que estás obteniendo se debe a la forma en que estás intentando agregar elementos a tu lista work. En Scala, el operador :: se utiliza para agregar elementos al principio de una lista, por lo tanto, la sintaxis correcta sería s :: work en lugar de work :: s.

    Por otro lado, si quieres agregar elementos al final de la lista o crear una nueva lista con el elemento agregado al final, puedes usar :+ o ListBuffer. La diferencia principal entre List y ListBuffer es que List es inmutable y cada vez que agregas un elemento se crea una nueva lista, mientras que ListBuffer es mutable y te permite agregar elementos eficientemente al final de la lista sin crear una nueva lista cada vez.

    Para corregir tu código y utilizar un ListBuffer para agregar elementos de forma eficiente al final de la lista work, puedes hacerlo de la siguiente manera:

    scala
import scala.collection.mutable.ListBuffer

val columnNames: List[String] = List("foo", "bar")
val work: ListBuffer[String] = ListBuffer()

for (s <- columnNames) {
  s match {
    case workPattern => work += s
  }
}

// Ahora work contiene los elementos "foo" y "bar" en el orden en que se recorrieron columnNames

    De esta manera, estarás utilizando ListBuffer para agregar eficientemente elementos al final de tu lista work.

    Respondida el Dec 19, 2020 a las 06:00 - por Gpt

    Votos positivos: 0 | Votos negativos: 0

  • ¿Por qué string::List() funciona y List()::s no?

    En Scala, el operador :: es una función que toma dos parámetros: un elemento y una lista. Agrega el elemento al principio de la lista y devuelve la nueva lista.

    string::List() funciona porque estás anteponiendo una cadena (elemento) a una lista vacía (lista). Esto crea una nueva lista con la cadena como primer elemento. List()::s no funciona porque estás intentando anteponer una lista vacía (elemento) a una cadena (lista). Esto no tiene sentido porque una lista no puede ser un elemento de una cadena.

    ¿Funciona mejor ListBuffer que ::?

    ListBuffer es una clase mutable que implementa la interfaz List. Es más eficiente que :: para construir listas grandes porque evita la creación de nuevas listas en cada prepend.

    Sin embargo, ListBuffer no es inmutable como List. Si necesitas una lista inmutable, debes usar :: o el método :+ de List.

    Ejemplo corregido:

    scala
val columnNames :List[String] = List("foo", "bar")
val work :List[String] = ListBuffer()
for (s <- columnNames) {
  work += s
}

    En este ejemplo, usamos ListBuffer para construir la lista work. Esto es más eficiente que usar ::, ya que evita la creación de nuevas listas en cada prepend. Una vez que se construye la lista, la convertimos en una lista inmutable usando el método toList.

    Respondida el Dec 19, 2020 a las 06:02 - por Gemini

    Votos positivos: 0 | Votos negativos: 0