Concaténation de la liste Scala, ::: vs ++

Y a-t-il une différence entre :::et ++pour concaténer des listes dans 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

D'après la documentation, il semble être ++plus général alors qu'il :::est Listspécifique. Ce dernier est-il fourni car il est utilisé dans d'autres langages fonctionnels?

Héritage. La liste a été initialement définie pour ressembler à des langages fonctionnels:

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

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

Bien sûr, Scala a fait évoluer d'autres collections, de manière ponctuelle. Lorsque 2.8 est sorti, les collections ont été redessinés pour une réutilisation du code et l' API cohérente, de sorte que vous pouvez utiliser ++pour concaténer les deux collections - et même itérateurs. List, cependant, a réussi à conserver ses opérateurs d'origine, à l'exception d'un ou deux qui se sont dépréciés.

Utilisez toujours :::. Il y a deux raisons: l'efficacité et la sécurité du type.

Efficacité

x ::: y ::: zest plus rapide que x ++ y ++ z, parce que :::c'est juste associatif. x ::: y ::: zest analysé comme x ::: (y ::: z), ce qui est algorithmiquement plus rapide que (x ::: y) ::: z(ce dernier nécessite O (| x |) étapes supplémentaires).

Type de sécurité

Avec ::: vous ne pouvez concaténer que deux Lists. Avec ++vous pouvez ajouter n'importe quelle collection List, ce qui est terrible:

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

++est également facile à mélanger avec +:

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

:::ne fonctionne qu'avec des listes, alors qu'il ++peut être utilisé avec n'importe quel traversable. Dans l'implémentation actuelle (2.9.0), ++retombe :::si l'argument est également a List.

Un autre point est que la première phrase est analysée comme suit:

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

Alors que le deuxième exemple est analysé comme suit:

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

Donc, si vous utilisez des macros, vous devez faire attention.

En outre, ++pour deux listes appelle::: mais avec plus de surcharge car cela demande une valeur implicite pour avoir un générateur de List en List. Mais les microbenchmarks n'ont rien prouvé d'utile dans ce sens, je suppose que le compilateur optimise de tels appels.

Micro-repères après échauffement.

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

Comme l'a dit Daniel C. Sobrai, vous pouvez ajouter le contenu de n'importe quelle collection à une liste en utilisant ++, alors qu'avec :::vous, vous ne pouvez concaténer que des listes.