Apa arti param: _ * di Scala?

Karena baru mengenal Scala (2.9.1), saya memiliki List[Event]dan ingin menyalinnya ke a Queue[Event], tetapi Sintaks berikut menghasilkan aQueue[List[Event]] :

val eventQueue = Queue(events)

Untuk beberapa alasan, berikut ini berfungsi:

val eventQueue = Queue(events : _*)

Tapi saya ingin memahami apa fungsinya, dan mengapa itu berhasil? Saya sudah melihat tanda tangan dariQueue.apply fungsinya:

def apply[A](elems: A*)

Dan saya mengerti mengapa upaya pertama tidak berhasil, tetapi apa arti upaya kedua? Apa :, dan _*dalam kasus ini, dan mengapa fungsinya tidak applymengambil begitu saja Iterable[A]?

a: Aadalah tipe anggapan; lihat Apa tujuan dari jenis ascriptions di Scala?

: _* adalah turunan khusus dari tipe ascription yang memberi tahu kompilator untuk memperlakukan argumen tunggal dari tipe urutan sebagai urutan argumen variabel, yaitu varargs.

Ini sepenuhnya valid untuk membuat Queuepenggunaan Queue.applyyang memiliki elemen tunggal yang berurutan atau dapat diulang, jadi inilah yang terjadi ketika Anda memberikan satu Iterable[A].

Ini adalah notasi khusus yang memberi tahu kompilator untuk meneruskan setiap elemen sebagai argumennya sendiri, bukan semuanya sebagai argumen tunggal. Lihat disini .

Ini adalah jenis anotasi yang menunjukkan argumen urutan dan disebutkan sebagai "pengecualian" untuk aturan umum di bagian 4.6.2 dari spesifikasi bahasa, "Parameter Berulang".

Ini berguna ketika suatu fungsi mengambil sejumlah variabel argumen, misalnya fungsi seperti def sum(args: Int*), yang dapat dipanggil sebagai sum(1), sum(1,2)dll. Jika Anda memiliki daftar seperti xs = List(1,2,3), Anda tidak dapat melewatkannya xssendiri, karena ini adalah a Listdaripada Int, tetapi Anda dapat meneruskan elemennya menggunakan sum(xs: _*).

Untuk orang-orang Python:

Operator Scala _*kurang lebih setara dengan * -operator Python .

Contoh

Mengonversi contoh skala dari tautan yang disediakan oleh Luigi Plinge :

def echo(args: String*) = 
    for (arg <- args) println(arg)

val arr = Array("What's", "up", "doc?")
echo(arr: _*)

ke Python akan terlihat seperti:

def echo(*args):
    for arg in args:
        print "%s" % arg

arr = ["What's", "up", "doc?"]
echo(*arr)

dan keduanya memberikan hasil sebagai berikut:

Apa
up
doc?

Perbedaannya: membongkar parameter posisi

Sedangkan Python * -operator juga dapat menangani pembongkaran parameter / parameter posisi untuk fungsi fixed-arity:

def multiply (x, y):
    return x * y

operands = (2, 4)
multiply(*operands)

8

Melakukan hal yang sama dengan Scala:

def multiply(x:Int, y:Int) = {
    x * y;
}

val operands = (2, 4)
multiply (operands : _*)

akan gagal:

tidak cukup argumen untuk metode multiply: (x: Int, y: Int) Int.
Parameter nilai tidak ditentukan y.

Tetapi dimungkinkan untuk mencapai hal yang sama dengan scala:

def multiply(x:Int, y:Int) = {
    x*y;
}

val operands = (2, 4)
multiply _ tupled operands

Menurut Lorrin Nelson inilah cara kerjanya:

Bagian pertama, f _, adalah sintaks untuk fungsi yang diterapkan sebagian di mana tidak ada argumen yang ditentukan. Ini bekerja sebagai mekanisme untuk mendapatkan objek fungsi. tupled mengembalikan fungsi baru dari arity-1 yang mengambil satu tupel arity-n.

Bacaan selanjutnya:

• stackoverflow.com - membongkar scala tuple