Что означают <: <, <% <и =: = в 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предоставляется компилятором, если Aесть String. Вы можете думать о нем , как доказательство , что Aявляется Stringсамо по себе --the аргумент не имеет значения, только зная , что она существует. [править: технически это действительно важно, потому что представляет неявное преобразование из 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на Foo[String]. Это ограничение применяется во время компиляции, и это здорово!

<:<и <%<работают аналогично, но с небольшими вариациями:

• A =:= B означает, что A должен быть точно B
• A <:< Bозначает, что A должен быть подтипом B (аналогично ограничению простого типа <:)
• A <%< Bозначает, что A должен просматриваться как B, возможно, посредством неявного преобразования (аналогично ограничению простого типа <%)

Этот фрагмент @retronym является хорошим объяснением того, как такого рода вещи выполнялись раньше, и как обобщенные ограничения типов делают это проще.

ДОПОЛНЕНИЕ

Чтобы ответить на ваш дополнительный вопрос, по общему признанию, приведенный мною пример довольно надуманен и явно не полезен. Но представьте себе его использование для определения чего-то вроде List.sumIntsметода, который складывает список целых чисел. Вы не хотите, чтобы этот метод вызывался для любого старого List, просто a List[Int]. Однако Listконструктор типа не может быть таким ограниченным; вы все еще хотите иметь возможность иметь списки строк, foos, баров и еще много чего. Таким образом, установив ограничение обобщенного типа sumInts, вы можете убедиться, что только у этого метода есть дополнительное ограничение, которое может использоваться только в 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 в первых двух случаях, хотя и не особенно хорошо документированы.

Они предназначены для того, чтобы обеспечить способ проверить отношения между классами, точно так же, как <:и <%делать, в ситуациях, когда последний не может быть использован.

Что касается вопроса «когда я должен их использовать?», Ответ - не стоит, если только вы не знаете, что должны. :-) РЕДАКТИРОВАТЬ : Хорошо, хорошо, вот несколько примеров из библиотеки. У 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

Вы найдете несколько других примеров в коллекциях.