Rangkuman daftar scala, ::: vs ++

Apakah ada perbedaan di antara keduanya ::: dan ++untuk daftar gabungan di 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

Dari dokumentasi sepertinya ++lebih umum sedangkan :::yaituList spesifik. Apakah yang terakhir disediakan karena digunakan dalam bahasa fungsional lainnya?

Warisan. Daftar awalnya didefinisikan sebagai fungsional-mencari bahasa:

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

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

Tentu saja, Scala mengembangkan koleksi lain, secara ad-hoc. Ketika 2,8 keluar, koleksi yang dirancang ulang untuk digunakan kembali kode maksimum dan API konsisten, sehingga Anda dapat menggunakan ++untuk menggabungkan setiap dua koleksi - dan bahkan iterator. Daftar, bagaimanapun, harus menjaga operator aslinya, selain dari satu atau dua yang sudah usang.

Selalu gunakan :::. Ada dua alasan: efisiensi dan keamanan tipe.

Efisiensi

x ::: y ::: zlebih cepat daripada x ++ y ++ z, karena :::asosiatif yang benar. x ::: y ::: zdiuraikan sebagai x ::: (y ::: z), yang secara algoritmik lebih cepat dari (x ::: y) ::: z(yang terakhir membutuhkan O (| x |) langkah lebih lanjut).

Ketik keamanan

Dengan :::Anda hanya dapat menggabungkan dua Lists. Dengan ++Anda dapat menambahkan koleksi apa pun ke List, yang mengerikan:

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

++juga mudah digabungkan dengan +:

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

:::hanya bekerja dengan daftar, sementara ++dapat digunakan dengan traversable apa pun. Dalam implementasi saat ini (2.9.0), ++kembali aktif :::jika argumennya juga a List.

Poin yang berbeda adalah kalimat pertama diurai sebagai:

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

Sedangkan contoh kedua diuraikan sebagai:

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

Jadi, jika Anda menggunakan makro, Anda harus berhati-hati.

Selain itu, ++untuk dua daftar memanggil::: tetapi dengan lebih banyak overhead karena meminta nilai implisit untuk memiliki pembangun dari Daftar ke Daftar. Tapi microbenchmarks tidak membuktikan sesuatu yang berguna dalam arti itu, saya kira kompiler mengoptimalkan panggilan tersebut.

Tolok Ukur Mikro setelah pemanasan.

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

Seperti yang dikatakan Daniel C. Sobrai, Anda dapat menambahkan konten dari koleksi apa pun ke daftar menggunakan ++, sedangkan dengan :::Anda hanya dapat menggabungkan daftar.