Łączenie listy Scala, ::: vs ++

Czy jest jakaś różnica pomiędzy :::i ++za łączeniem list w Scali?

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

Z dokumentacji wynika, że ++jest bardziej ogólna, podczas gdy :::jest Listspecyficzna. Czy to drugie jest zapewnione, ponieważ jest używane w innych językach funkcjonalnych?

Dziedzictwo. Lista została pierwotnie zdefiniowana jako wyglądająca na języki funkcjonalne:

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

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

Oczywiście Scala ewoluowała inne kolekcje w sposób ad hoc. Kiedy pojawiła się wersja 2.8, kolekcje zostały przeprojektowane w celu maksymalnego ponownego wykorzystania kodu i spójnego interfejsu API, dzięki czemu można używać ++do łączenia dowolnych dwóch kolekcji - a nawet iteratorów. Lista jednak zachowała swoich pierwotnych operatorów, oprócz jednego lub dwóch, które stały się przestarzałe.

Zawsze używaj :::. Są dwa powody: wydajność i bezpieczeństwo typu.

Wydajność

x ::: y ::: zjest szybszy niż x ++ y ++ z, ponieważ :::ma właściwe skojarzenie. x ::: y ::: zjest analizowany jako x ::: (y ::: z), który jest algorytmicznie szybszy niż (x ::: y) ::: z(ten drugi wymaga O (| x |) więcej kroków).

Wpisz bezpieczeństwo

Z :::możesz połączyć tylko dwa Lists. Dzięki ++niemu możesz dołączyć dowolną kolekcję List, co jest okropne:

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

++jest również łatwy do zmieszania z +:

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

:::działa tylko z listami, a ++można go używać z każdym przejściem. W obecnej implementacji (2.9.0), ++spada z powrotem na :::jeśli argument jest również List.

Inną kwestią jest to, że pierwsze zdanie jest analizowane jako:

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

Natomiast drugi przykład jest analizowany jako:

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

Więc jeśli używasz makr, powinieneś się zachować ostrożność.

Poza tym, ++dla dwóch list wywołuje się, :::ale z większym obciążeniem, ponieważ prosi o wartość domyślną, aby mieć konstruktora z listy do listy. Ale mikrobenchmarki nie okazały niczego przydatnego w tym sensie, myślę, że kompilator optymalizuje takie wywołania.

Mikro-Benchmarki po rozgrzaniu.

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

Jak powiedział Daniel C. Sobrai, możesz dołączyć zawartość dowolnej kolekcji do listy za pomocą ++, podczas gdy za pomocą :::możesz łączyć tylko listy.