Apa artinya <: <, <% <, dan =: = dalam Scala 2.8, dan di mana mereka didokumentasikan?

Saya dapat melihat di dokumen API untuk Predef bahwa mereka adalah subkelas dari tipe fungsi umum (Dari) => Ke, tetapi hanya itu yang dikatakan. Um, apa? Mungkin ada dokumentasi di suatu tempat, tetapi mesin pencari tidak menangani "nama" seperti "<: <" sangat baik, jadi saya belum dapat menemukannya.

Pertanyaan tindak lanjut: kapan saya harus menggunakan simbol / kelas yang funky ini, dan mengapa?

Ini disebut batasan tipe umum . Mereka memungkinkan Anda, dari dalam kelas tipe-parameter atau sifat, untuk lebih jauh membatasi salah satu parameter jenisnya. Ini sebuah contoh:

case class Foo[A](a:A) { // 'A' can be substituted with any type
    // getStringLength can only be used if this is a Foo[String]
    def getStringLength(implicit evidence: A =:= String) = a.length
}

Argumen implisit evidencedisediakan oleh kompiler, iff Aadalah String. Anda dapat menganggap itu sebagai bukti bahwa Aadalah Stringargumen --the itu sendiri tidak penting, hanya mengetahui bahwa itu ada. [edit: baiklah, secara teknis itu sebenarnya penting karena itu merupakan konversi implisit dari Ake String, yang memungkinkan Anda menelepon a.lengthdan tidak meminta kompiler berteriak kepada Anda]

Sekarang saya bisa menggunakannya seperti ini:

scala> Foo("blah").getStringLength
res6: Int = 4

Tetapi jika saya mencoba menggunakannya dengan Foosesuatu yang mengandung selain String:

scala> Foo(123).getStringLength
<console>:9: error: could not find implicit value for parameter evidence: =:=[Int,String]

Anda dapat membaca kesalahan itu sebagai "tidak dapat menemukan bukti bahwa Int == String" ... itu sudah seharusnya! getStringLengthmemaksakan pembatasan lebih lanjut pada jenis dari Aapa yang Foosecara umum mengharuskan; yaitu, Anda hanya dapat meminta getStringLengthpada a Foo[String]. Batasan ini diberlakukan pada waktu kompilasi, yang keren!

<:<dan <%<bekerja serupa, tetapi dengan sedikit variasi:

• A =:= B berarti A harus persis B
• A <:< Bberarti A harus merupakan subtipe B (analog dengan batasan tipe sederhana<: )
• A <%< Bberarti A harus dapat dilihat sebagai B, mungkin melalui konversi implisit (analog dengan batasan tipe sederhana <%)

Cuplikan oleh @retronym ini adalah penjelasan yang bagus tentang bagaimana hal seperti ini dapat diselesaikan dan bagaimana batasan tipe umum membuatnya lebih mudah sekarang.

TAMBAHAN

Untuk menjawab pertanyaan tindak lanjut Anda, diakui contoh yang saya berikan cukup dibuat-buat dan tidak jelas berguna. Tapi bayangkan menggunakannya untuk mendefinisikan sesuatu seperti List.sumIntsmetode, yang menambahkan daftar bilangan bulat. Anda tidak ingin mengizinkan metode ini dipanggil pada yang lama List, hanya a List[Int]. Namun Listkonstruktor tipe tidak dapat dibatasi; Anda masih ingin dapat memiliki daftar string, foo, bar, dan apa pun. Jadi dengan menempatkan batasan tipe umum sumInts, Anda dapat memastikan bahwa hanya metode yang memiliki kendala tambahan yang hanya dapat digunakan pada a List[Int]. Pada dasarnya Anda sedang menulis kode kasus khusus untuk beberapa jenis daftar.

Bukan jawaban yang lengkap (orang lain sudah menjawab ini), saya hanya ingin mencatat yang berikut, yang mungkin membantu untuk memahami sintaks lebih baik: Cara Anda biasanya menggunakan "operator" ini, seperti misalnya dalam contoh pelotom:

def getStringLength(implicit evidence: A =:= String)

memanfaatkan alternatif Scala sintaks infix untuk operator tipe .

Jadi, A =:= Stringsama dengan =:=[A, String](dan =:=hanya kelas atau sifat dengan nama yang tampak mewah). Perhatikan bahwa sintaks ini juga berfungsi dengan kelas "reguler", misalnya Anda dapat menulis:

val a: Tuple2[Int, String] = (1, "one")

seperti ini:

val a: Int Tuple2 String = (1, "one")

Ini mirip dengan dua sintaks untuk panggilan metode, "normal" dengan .dan ()dan sintaksis operator.

Baca jawaban lain untuk memahami apa itu konstruksi. Inilah saatnya Anda harus menggunakannya. Anda menggunakannya ketika Anda perlu membatasi metode untuk tipe tertentu saja.

Berikut ini sebuah contoh. Misalkan Anda ingin mendefinisikan Pasangan yang homogen, seperti ini:

class Pair[T](val first: T, val second: T)

Sekarang Anda ingin menambahkan metode smaller, seperti ini:

def smaller = if (first < second) first else second

Itu hanya berfungsi jika Tdipesan. Anda dapat membatasi seluruh kelas:

class Pair[T <: Ordered[T]](val first: T, val second: T)

Tapi itu memalukan - mungkin ada manfaat untuk kelas saat Ttidak dipesan. Dengan batasan tipe, Anda masih bisa mendefinisikan smallermetode:

def smaller(implicit ev: T <:< Ordered[T]) = if (first < second) first else second

Tidak masalah untuk instantiate, katakanlah, a Pair[File], selama Anda tidak menelepon smaller .

Dalam kasus ini Option, para pelaksana menginginkan suatu orNullmetode, meskipun itu tidak masuk akal Option[Int]. Dengan menggunakan batasan tipe, semuanya baik-baik saja. Anda dapat menggunakan orNullpada Option[String], dan Anda dapat membentuk Option[Int]dan menggunakannya, selama Anda tidak memanggilnya orNull. Jika Anda mencoba Some(42).orNull, Anda mendapatkan pesan yang menarik

 error: Cannot prove that Null <:< Int

Itu tergantung di mana mereka digunakan. Paling sering, ketika digunakan saat mendeklarasikan tipe parameter implisit, mereka adalah kelas. Mereka juga bisa menjadi objek dalam kasus yang jarang terjadi. Akhirnya, mereka bisa menjadi operator pada Manifestobjek. Mereka didefinisikan di dalamscala.Predef dalam dalam dua kasus pertama, meskipun tidak didokumentasikan dengan baik.

Mereka dimaksudkan untuk menyediakan cara untuk menguji hubungan antara kelas, seperti <:dan <%lakukan, dalam situasi ketika yang terakhir tidak dapat digunakan.

Adapun pertanyaan "kapan saya harus menggunakannya?", Jawabannya adalah Anda seharusnya tidak, kecuali Anda tahu Anda harus melakukannya. :-) EDIT : Ok, ok, berikut adalah beberapa contoh dari perpustakaan. Pada Either, Anda memiliki:

/**
  * Joins an <code>Either</code> through <code>Right</code>.
  */
 def joinRight[A1 >: A, B1 >: B, C](implicit ev: B1 <:< Either[A1, C]): Either[A1, C] = this match {
   case Left(a)  => Left(a)
   case Right(b) => b
 }

 /**
  * Joins an <code>Either</code> through <code>Left</code>.
  */
 def joinLeft[A1 >: A, B1 >: B, C](implicit ev: A1 <:< Either[C, B1]): Either[C, B1] = this match {
   case Left(a)  => a
   case Right(b) => Right(b)
 }

Pada Option, Anda memiliki:

def orNull[A1 >: A](implicit ev: Null <:< A1): A1 = this getOrElse null

Anda akan menemukan beberapa contoh lain di koleksi.