Какова концепция "слабого соответствия" в Scala?

Недавно я столкнулся с термином "Слабое соответствие" (в "Переполнение стека" retronym ответ на Как установить неявное преобразование, чтобы разрешить арифметику между числовыми типами?).

Что это?

Ответ 1

3.5.3 Слабое соответствие В некоторых ситуациях Scala используется более общий соответствие отношение. Тип S слабо соответствует типу T, записанному S <: _w T, если S <: T или оба S и T являются примитивные типы номеров и S предшествуют T в следующем порядке.

Byte <: _w Short
Байт <: _w Символ
Short <: _w Int
Int <: _w Long
Long <: _w Float
Float <: _w Двойной

Слабая наименьшая верхняя грань является наименьшая верхняя граница относительно слабого соответствие.

Где это используется? Во-первых, он определяет тип выражений if:

Тип условного выражения - слабая наименьшая верхняя граница (п. 3.5.3) типов e2 и e3

В Scala 2.7.x это будет по типу AnyVal, наименьшая верхняя граница Int и Double. В 2.8.x он имеет вид Double.

scala> if (true) 1 else 1d
res0: Double = 1.0

Аналогично:

scala> try { 1 } catch { case _ => 1.0 }
res2: Double = 1.0

scala> (new {}: Any) match { case 1 => 1; case _ => 1.0 }
res6: Double = 1.0

scala> def pf[R](pf: PartialFunction[Any, R]): PartialFunction[Any, R] = pf
pf: [R](pf: PartialFunction[Any,R])PartialFunction[Any,R]

scala> pf { case 1 => 1; case _ => 1d }
res4: PartialFunction[Any,Double] = <function1>

Другое место, которое оно используется, относится к типу вывода:

scala> def foo[A](a1: A, a2: A): A = a1
foo: [A](a1: A,a2: A)A

scala> foo(1, 1d)
res8: Double = 1.0

scala> def foos[A](as: A*): A = as.head
foos: [A](as: A*)A

scala> foos(1, 1d)
res9: Double = 1.0

А также для простого числового расширения:

Числовое расширение. Если e имеет примитив тип номера, который слабо соответствует (П. 3.5.3) к ожидаемому типу, расширенный до ожидаемого типа с использованием одного из 6.26 Неявные преобразования 97 числовых методов преобразования toShort, toChar, toInt, toLong, toFloat, toDouble определенной в п. 12.2.1. ожидаемый тип примитивный числовой тип Byte, Short или Char, а выражение e является целочисленный литеральный монтаж в диапазоне этого типа, он преобразуется в такой же литерал в этом типе.

scala> 1: Double
res10: Double = 1.0

UPDATE

Как отметил Даниэль, спецификация ошибочна в отношении того, какие типы имеют слабую совместимость. Позвольте спросить самого компилятора:

scala> :power
** Power User mode enabled - BEEP BOOP      **
** scala.tools.nsc._ has been imported      **
** New vals! Try repl, global, power        **
** New cmds! :help to discover them         **
** New defs! Type power.<tab> to reveal     **

scala> settings.maxPrintString = 10000


scala> import global.definitions._
import global.definitions._

scala> (for{c1 <- ScalaValueClasses;
      c2 <- ScalaValueClasses
      isNSC = isNumericSubClass(c1, c2)
      if isNSC
  } yield ("isNumericSubClass (%s, %s) = %b" format (c1, c2, isNSC))).mkString("\n")


res5: String =
isNumericSubClass (class Byte, class Byte) = true
isNumericSubClass (class Byte, class Short) = true
isNumericSubClass (class Byte, class Int) = true
isNumericSubClass (class Byte, class Long) = true
isNumericSubClass (class Byte, class Float) = true
isNumericSubClass (class Byte, class Double) = true
isNumericSubClass (class Short, class Short) = true
isNumericSubClass (class Short, class Int) = true
isNumericSubClass (class Short, class Long) = true
isNumericSubClass (class Short, class Float) = true
isNumericSubClass (class Short, class Double) = true
isNumericSubClass (class Int, class Int) = true
isNumericSubClass (class Int, class Long) = true
isNumericSubClass (class Int, class Float) = true
isNumericSubClass (class Int, class Double) = true
isNumericSubClass (class Long, class Long) = true
isNumericSubClass (class Long, class Float) = true
isNumericSubClass (class Long, class Double) = true
isNumericSubClass (class Char, class Int) = true
isNumericSubClass (class Char, class Long) = true
isNumericSubClass (class Char, class Char) = true
isNumericSubClass (class Char, class Float) = true
isNumericSubClass (class Char, class Double) = true
isNumericSubClass (class Float, class Float) = true
isNumericSubClass (class Float, class Double) = true
isNumericSubClass (class Double, class Double) = true

Ответ 2

Чтобы завершить ответ Сандора, эта новая функция в 2.8 все еще испечена (и исправлена).

В этот поток, Эссер раскрывает неприятный побочный эффект:

scala> val a= 10 
a: Int = 10 

scala> val b= 3 
b: Int = 3 

scala> if (b!=0) a/b else Double.NaN 
res0: Double = 3.0 

scala> def div1(a: Int, b: Int) = if (b!=0) a/b else Double.NaN 
div1: (a: Int,b: Int)Double 

scala> def div2(a: Int, b: Int): Double = if (b!=0) a/b else Double.NaN 
div2: (a: Int,b: Int)Double 

scala> div1(10,3) 
res1: Double = 3.0 

scala> div2(10,3) 
res2: Double = 3.3333333333333335

Кажется интересным, потому что неявно найденный тип результата Double, и результат равен 3.0.
Если Double явно указано, результат равен 3,33...

В этот поток, добавляет Мартин Одерский (21 июня):

вы обнаружили серьезный непредвиденный побочный эффект слабых правил соответствия при перегрузке разрешения.
Проблема заключалась в том, что аргументы перегруженных методов требуются для слабого согласования, тогда как тип результата должен был строго соответствовать.

Это благоприятствовало методу добавления Float => Float в Int по методу Int => Int, если для типа результата был Float.
Я старался быть консервативным в своем переходе к слабому соответствию, потому что мне требовалось слабое соответствие только там, где оно выглядело абсолютно необходимым.
Но теперь кажется, что консервативность вызвала проблему, на которую мы смотрим!

И еще одна версия Scala RC;)

Подтверждено в эта тема Мартина Одерского (22 июня):

Итак, будет RC7 с тремя изменениями от RC6:

val x: Double = 10/3 даст 3.0, а не 3.3333333 - это регрессия, о которой я упоминал

[...]

[...]
Что это. Наши приоритеты теперь сводятся к 2.8 как можно быстрее и в то же время избегают очень плохих регрессий, таких как (1) выше.

Сроки:

Мы будем ждать еще одну неделю, чтобы получить обратную связь по RC6.

Мы вытащим RC7 в начале следующей недели.
Если никаких дальнейших проблем не возникнет, RC7 затем превратится в 2,8 финала через 10-14 дней после его выпуска.

(так около 12 июля, я полагаю, но эта догадка одна моя;))

Ответ 3

Согласно Scala lang spec 2.8:
http://www.scala-lang.org/archives/downloads/distrib/files/nightly/pdfs/ScalaReference.pdf

3.5.3 Слабое соответствие
В некоторых ситуациях Scala использует большее отношение соответствия genral. Тип S слабо соответствует типу T, записанному S <: w T, если S <: T или оба S и T являются примитивными числами типы и S предшествует T в следующем порядке.
Байт <: w Короткое изображение Байт < w: символ символов Short <: w Int
Int <: w Длинные
Long <: w Float
Float <: w Double
Слабая наименьшая верхняя грань является наименьшей верхней оценкой относительно слабого соответствия.