Concatenación de lista Scala, ::: vs ++

¿Hay alguna diferencia entre :::y ++para concatenar listas en Scala?

scala> List(1,2,3) ++ List(4,5)
res0: List[Int] = List(1, 2, 3, 4, 5)

scala> List(1,2,3) ::: List(4,5)
res1: List[Int] = List(1, 2, 3, 4, 5)

scala> res0 == res1
res2: Boolean = true

De la documentación parece que ++es más general, mientras que :::es Listespecífico. ¿Se proporciona este último porque se usa en otros lenguajes funcionales?

Legado. La lista se definió originalmente para tener un aspecto funcional de idiomas:

1 :: 2 :: Nil // a list
list1 ::: list2  // concatenation of two lists

list match {
  case head :: tail => "non-empty"
  case Nil          => "empty"
}

Por supuesto, Scala desarrolló otras colecciones, de manera ad-hoc. Cuando salieron 2,8, las colecciones han sido rediseñados para una máxima reutilización de código y API consistente, por lo que se puede utilizar ++para concatenar los dos colecciones - e incluso los iteradores. List, sin embargo, debe mantener sus operadores originales, aparte de uno o dos que quedaron en desuso.

Siempre uso :::. Hay dos razones: eficiencia y seguridad de tipo.

Eficiencia

x ::: y ::: zes más rápido que x ++ y ++ z, porque :::es correcto asociativo. x ::: y ::: zse analiza como x ::: (y ::: z), que es algorítmicamente más rápido que (x ::: y) ::: z(este último requiere O (| x |) más pasos).

Tipo de seguridad

Con :::usted solo puede concatenar dos Lists. Con ++usted puede agregar cualquier colección List, lo cual es terrible:

scala> List(1, 2, 3) ++ "ab"
res0: List[AnyVal] = List(1, 2, 3, a, b)

++También es fácil de mezclar con +:

scala> List(1, 2, 3) + "ab"
res1: String = List(1, 2, 3)ab

:::funciona solo con listas, mientras que ++se puede usar con cualquier tragable. En la implementación actual (2.9.0), ++cae de nuevo sobre :::si el argumento es también una List.

Un punto diferente es que la primera oración se analiza como:

scala> List(1,2,3).++(List(4,5))
res0: List[Int] = List(1, 2, 3, 4, 5)

Mientras que el segundo ejemplo se analiza como:

scala> List(4,5).:::(List(1,2,3))
res1: List[Int] = List(1, 2, 3, 4, 5)

Entonces, si está utilizando macros, debe tener cuidado.

Además, ++para dos listas se llama :::pero con más sobrecarga porque se pide un valor implícito para tener un generador de Lista a Lista. Pero los microbenchmarks no probaron nada útil en ese sentido, supongo que el compilador optimiza tales llamadas.

Micro-puntos de referencia después del calentamiento.

scala>def time(a: => Unit): Long = { val t = System.currentTimeMillis; a; System.currentTimeMillis - t}
scala>def average(a: () => Long) = (for(i<-1 to 100) yield a()).sum/100

scala>average (() => time { (List[Int]() /: (1 to 1000)) { case (l, e) => l ++ List(e) } })
res1: Long = 46
scala>average (() => time { (List[Int]() /: (1 to 1000)) { case (l, e) => l ::: List(e ) } })
res2: Long = 46

Como dijo Daniel C. Sobrai, puede agregar el contenido de cualquier colección a una lista usando ++, mientras que con :::solo puede concatenar listas.