¿Cuál es el rendimiento de Scala?

Creo que la respuesta aceptada es excelente, pero parece que muchas personas no han logrado comprender algunos puntos fundamentales.

Primero, forlas comprensiones de Scala son equivalentes a dola notación de Haskell, y no es más que un azúcar sintáctico para la composición de múltiples operaciones monádicas. Como lo más probable es que esta afirmación no ayude a nadie que necesite ayuda, intentémoslo de nuevo… :-)

Las comprensiones de Scala forson azúcar sintáctica para la composición de múltiples operaciones con map flatMapy filter. O foreach. Scala en realidad traduce una forexpresión - en llamadas a esos métodos, por lo que cualquier clase que los proporcione, o un subconjunto de ellos, puede usarse para comprensión.

Primero, hablemos de las traducciones. Hay reglas muy simples:

1. Este

   for(x <- c1; y <- c2; z <-c3) {...}
   

   se traduce en

   c1.foreach(x => c2.foreach(y => c3.foreach(z => {...})))
   

2. Este

   for(x <- c1; y <- c2; z <- c3) yield {...}
   

   se traduce en

   c1.flatMap(x => c2.flatMap(y => c3.map(z => {...})))
   

3. Este

   for(x <- c; if cond) yield {...}
   

   se traduce en Scala 2.7 a

   c.filter(x => cond).map(x => {...})
   

   o, en Scala 2.8, en

   c.withFilter(x => cond).map(x => {...})
   

   con un recurso alternativo al primero si el método withFilterno está disponible pero sí filterlo está. Consulte la sección siguiente para obtener más información al respecto.

4. Este

   for(x <- c; y = ...) yield {...}
   

   se traduce en

   c.map(x => (x, ...)).map((x,y) => {...})
   

Cuando nos fijamos en forcomprensiones muy simples, las alternativas map/ foreachparecen, de hecho, mejores. Sin embargo, una vez que comienzas a componerlos, puedes perderte fácilmente entre paréntesis y niveles de anidamiento. Cuando eso sucede, forlas comprensiones suelen ser mucho más claras.

Mostraré un ejemplo simple y omitiré intencionalmente cualquier explicación. Puede decidir qué sintaxis fue más fácil de entender.

l.flatMap(sl => sl.filter(el => el > 0).map(el => el.toString.length))

o

for {
  sl <- l
  el <- sl
  if el > 0
} yield el.toString.length

withFilter

Scala 2.8 introdujo un método llamado withFilter, cuya principal diferencia es que, en lugar de devolver una colección nueva filtrada, filtra según demanda. El filtermétodo tiene su comportamiento definido en función del rigor de la colección. Para entender esto mejor, echemos un vistazo a Scala 2.7 con List(estricto) y Stream(no estricto):

scala> var found = false
found: Boolean = false

scala> List.range(1,10).filter(_ % 2 == 1 && !found).foreach(x => if (x == 5) found = true else println(x))
1
3
7
9

scala> found = false
found: Boolean = false

scala> Stream.range(1,10).filter(_ % 2 == 1 && !found).foreach(x => if (x == 5) found = true else println(x))
1
3

La diferencia ocurre porque filterse aplica inmediatamente con List, devolviendo una lista de probabilidades, ya que foundes false. Sólo entonces foreachse ejecuta, pero, en ese momento, el cambio foundno tiene sentido, como filterya se ha ejecutado.

En el caso de Stream, la condición no se aplica inmediatamente. En cambio, a medida que cada elemento es solicitado por foreach, filterprueba la condición, lo que permite foreachinfluir en él a través de found. Para que quede claro, aquí está el código de comprensión equivalente:

for (x <- List.range(1, 10); if x % 2 == 1 && !found) 
  if (x == 5) found = true else println(x)

for (x <- Stream.range(1, 10); if x % 2 == 1 && !found) 
  if (x == 5) found = true else println(x)

Esto causó muchos problemas, porque la gente esperaba que ifse considerara bajo demanda, en lugar de aplicarse a toda la colección de antemano.

Se introdujo Scala 2.8 withFilter, que siempre no es estricto, sin importar el rigor de la colección. El siguiente ejemplo muestra Listambos métodos en Scala 2.8:

scala> var found = false
found: Boolean = false

scala> List.range(1,10).filter(_ % 2 == 1 && !found).foreach(x => if (x == 5) found = true else println(x))
1
3
7
9

scala> found = false
found: Boolean = false

scala> List.range(1,10).withFilter(_ % 2 == 1 && !found).foreach(x => if (x == 5) found = true else println(x))
1
3

Esto produce el resultado que la mayoría de la gente espera, sin cambiar su filtercomportamiento. Como nota al margen, Rangese cambió de no estricto a estricto entre Scala 2.7 y Scala 2.8.

Jun 29 '2009 17:06 Daniel C. Sobral