Что означают <: <, <% <и =: = в Scala 2.8 и где они документированы?

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

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

использует Scala альтернативный синтаксис infix для операторов типа.

Итак, 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

Это нормально, чтобы создать экземпляр, скажем, < <28 > , если вы не назовете smaller на нем.

В случае Option разработчикам нужен метод orNull, хотя это не имеет смысла для Option[Int]. Используя ограничение типа, все хорошо. Вы можете использовать orNull на Option[String], и вы можете создать Option[Int] и использовать его, если вы не вызываете orNull на нем. Если вы попробуете Some(42).orNull, вы получите очаровательное сообщение

 error: Cannot prove that Null <:< Int

Это зависит от того, где они используются. Чаще всего при использовании при объявлении типов неявных параметров они являются классами. Они также могут быть объектами в редких случаях. Наконец, они могут быть операторами на объектах Manifest. Они определены внутри scala.Predef в первых двух случаях, хотя и не особенно хорошо документированы.

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

Что касается вопроса "когда я должен их использовать?", ответ не должен, если вы не знаете, что вам нужно.:-) 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

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