Verkettung der Scala-Liste, ::: vs ++

Gibt es einen Unterschied zwischen :::und ++für die Verkettung von Listen in 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

Aus der Dokumentation geht hervor, dass ++es allgemeiner ist, während :::es Listspezifisch ist. Wird letzteres bereitgestellt, weil es in anderen funktionalen Sprachen verwendet wird?

Erbe. Die Liste wurde ursprünglich so definiert, dass sie nach funktionalen Sprachen aussieht:

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

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

Natürlich hat Scala andere Sammlungen ad-hoc weiterentwickelt. Als 2.8 herauskam, wurden die Sammlungen für maximale Code-Wiederverwendung und konsistente API neu gestaltet, sodass Sie zwei beliebige Sammlungen - und sogar Iteratoren - ++verketten können . List musste jedoch seine ursprünglichen Operatoren behalten, abgesehen von einem oder zwei, die veraltet waren.

Immer benutzen :::. Es gibt zwei Gründe: Effizienz und Typensicherheit.

Effizienz

x ::: y ::: zist schneller als x ++ y ++ z, weil :::richtig assoziativ ist. x ::: y ::: zwird analysiert als x ::: (y ::: z), was algorithmisch schneller ist als (x ::: y) ::: z(letzteres erfordert O (| x |) mehr Schritte).

Typensicherheit

Mit können :::Sie nur zwei Lists verketten . Mit können ++Sie jede Sammlung anhängen List, was schrecklich ist:

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

++ist auch leicht zu verwechseln mit +:

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

:::funktioniert nur mit Listen, ++kann aber mit jedem Traversable verwendet werden. In der aktuellen Implementierung (2.9.0) wird ++zurückgegriffen, :::wenn das Argument auch a ist List.

Ein anderer Punkt ist, dass der erste Satz wie folgt analysiert wird:

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

Während das zweite Beispiel wie folgt analysiert wird:

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

Wenn Sie also Makros verwenden, sollten Sie vorsichtig sein.

Außerdem wird ++für zwei Listen aufgerufen, :::jedoch mit mehr Overhead, da nach einem impliziten Wert gefragt wird, um einen Builder von Liste zu Liste zu haben. Aber Mikrobenchmarks haben sich in diesem Sinne nicht als nützlich erwiesen. Ich denke, der Compiler optimiert solche Aufrufe.

Mikro-Benchmarks nach dem Aufwärmen.

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

Wie Daniel C. Sobrai sagte, können Sie den Inhalt jeder Sammlung mit an eine Liste anhängen ++, während :::Sie damit nur Listen verketten können.