Що значить <: <, <% <, і =: = означають у Scala 2.8 та де вони задокументовані?

Я можу побачити в документах API для Predef, що вони є підкласами типу загальної функції (From) => To, але все це говорить. Гм, що? Можливо, десь є документація, але пошукові системи не дуже добре обробляють такі імена, як "<: <", тому я не зміг її знайти.

Подальше запитання: коли я повинен використовувати ці прикольні символи / класи, і чому?

Вони називаються обмеженнями узагальненого типу . Вони дозволяють вам із класу, параметризованого типом або ознакою, додатково обмежувати один із його параметрів типу. Ось приклад:

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
}

Неявний аргумент evidenceподається компілятором, iff Ais String. Ви можете вважати це доказом, що Aце String- сам аргумент не важливий, лише знаючи, що він існує. [редагувати: ну, технічно це насправді важливо, оскільки це являє собою неявну конверсію з Aв String, саме це дозволяє вам дзвонити, a.lengthа не компілятор кричати на вас]

Тепер я можу використовувати його так:

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

Але якщо я спробував використовувати його із Fooвмістом, що не містить String:

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

Ви можете прочитати цю помилку як "не вдалося знайти доказ того, що Int == String" ... це так, як має бути! getStringLengthнакладає додаткові обмеження щодо типу, Aніж того, що Fooвзагалі вимагає; а саме ви можете посилатися лише getStringLengthна a Foo[String]. Це обмеження виконується під час компіляції, що класно!

<:<і <%<працювати аналогічно, але з незначними варіаціями:

• A =:= B означає, що A повинен бути саме B
• A <:< Bозначає, що A повинен бути підтипом B (аналогічно обмеженню простого типу <:)
• A <%< Bозначає, що A має бути видимим як B, можливо, шляхом неявного перетворення (аналогічного простому обмеженню типу <%)

Цей фрагмент від @retronym є хорошим поясненням того, як подібні речі використовувались і як узагальнені обмеження типу спрощують його зараз.

ДОБАВЛЕННЯ

Щоб відповісти на ваше подальше запитання, правда, приклад, який я наводив, досить надуманий і не очевидно корисний. Але уявіть, як використовувати його для визначення чогось типу List.sumIntsметоду, який додає список цілих чисел. Ви не хочете, щоб цей метод використовувався на будь-якому старому List, лише на List[Int]. Однак Listконструктор типів не може бути таким обмеженим; ви все ще хочете мати змогу мати списки струн, футів, смуг та ін. Таким чином, розміщуючи узагальнене обмеження типу sumInts, ви можете переконатися, що саме цей метод має додаткове обмеження, яке може бути використане лише на a List[Int]. По суті, ви пишете спеціальний код для певних типів списків.

Не повна відповідь (інші вже відповіли на це), я просто хотів зазначити наступне, що, можливо, допомагає краще зрозуміти синтаксис: спосіб, яким ви зазвичай користуєтесь цими "операторами", як, наприклад, у прикладі pelotom:

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

використовує альтернативний синтаксис інфіксації Scala для операторів типів .

Отже, A =:= Stringце те саме, що =:=[A, String](і =:=є просто класом чи ознакою з вигадливим назвою). Зауважте, що цей синтаксис також працює з "регулярними" класами, наприклад, ви можете писати:

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

подобається це:

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

Це схоже на два синтаксиси для викликів методів, "нормальний" з .і ()синтаксис оператора.

Прочитайте інші відповіді, щоб зрозуміти, що це за конструкції. Ось коли ви повинні їх використовувати. Ви їх використовуєте, коли вам потрібно обмежити метод лише для конкретних типів.

Ось приклад. Припустимо, ви хочете визначити однорідну пару, наприклад:

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

Тепер ви хочете додати такий метод smaller:

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

Це працює лише за Tзамовленням. Ви можете обмежити весь клас:

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

Але це здається прикро - для класу можуть бути використані випадки, коли Tїх не замовлено. Маючи обмеження типу, ви все ще можете визначити smallerметод:

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

Добре інстанціювати, скажімо, a Pair[File], доки ви не зателефонуєте smaller на нього.

У випадку з Option, реалізатори хотіли orNullметод, хоча це не має сенсу Option[Int]. За допомогою обмеження типу все добре. Ви можете використовувати orNullна Option[String], і ви можете сформувати Option[Int]і використовувати його, поки ви не зателефонуєте orNullна нього. Якщо ви спробуєте Some(42).orNull, ви отримаєте чарівне повідомлення

 error: Cannot prove that Null <:< Int

Це залежить від того, де вони використовуються. Найчастіше при використанні під час декларування типів неявних параметрів це класи. Вони можуть бути об'єктами і в рідкісних випадках. Нарешті, вони можуть бути операторами на Manifestоб’єктах. Вони визначені всередині scala.Predefперших двох випадків, хоча вони не особливо добре зафіксовані.

Вони покликані забезпечити спосіб перевірити взаємозв'язок між класами, як <:і <%робити, в ситуаціях, коли останні не можуть бути використані.

Що стосується питання "коли я повинен їх використовувати?", То відповіді ви не повинні, якщо ви не знаєте, що слід. :-) EDIT : Добре, добре, ось кілька прикладів з бібліотеки. У Eitherвас є:

/**
  * 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)
 }

У Optionвас є:

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

Ви знайдете деякі інші приклади в колекціях.