Concatenação da lista Scala, ::: vs ++

Existe alguma diferença entre :::e ++para concatenar listas no 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

A partir da documentação , parece ++ser mais geral, enquanto :::é Listespecífico. O último é fornecido porque é usado em outras linguagens funcionais?

Legado. A lista foi originalmente definida para aparência de idiomas funcionais:

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

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

Obviamente, Scala desenvolveu outras coleções, de maneira ad-hoc. Quando o 2.8 foi lançado, as coleções foram redesenhadas para reutilização máxima de código e API consistente, para que você possa usar ++para concatenar quaisquer duas coleções - e até iteradores. A List, no entanto, conseguiu manter seus operadores originais, além de um ou dois que foram preteridos.

Sempre use :::. Há duas razões: eficiência e segurança do tipo.

Eficiência

x ::: y ::: zé mais rápido que x ++ y ++ z, porque :::é associativo correto. x ::: y ::: zé analisado como x ::: (y ::: z), o que é algoritmicamente mais rápido que (x ::: y) ::: z(o último requer O (| x |) mais etapas).

Digite segurança

Com :::você só pode concatenar dois Lists. Com ++você, você pode anexar qualquer coleção a List, o que é terrível:

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

++Também é fácil misturar-se com +:

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

:::funciona apenas com listas, enquanto ++pode ser usado com qualquer travável. Na implementação atual (2.9.0), ++recai novamente :::se o argumento também for a List.

Um ponto diferente é que a primeira frase é analisada como:

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

Enquanto o segundo exemplo é analisado como:

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

Portanto, se você estiver usando macros, tome cuidado.

Além disso, ++para duas listas está chamando, :::mas com mais sobrecarga porque está solicitando um valor implícito para ter um construtor de Lista para Lista. Mas as marcas de microbench não provaram nada de útil nesse sentido, acho que o compilador otimiza essas chamadas.

Micro-benchmarks após o aquecimento.

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 Daniel C. Sobrai disse, você pode anexar o conteúdo de qualquer coleção a uma lista usando ++, enquanto que :::você só pode concatenar listas.