В чем разница между типами Null и Null & T, где T <: AnyRef?

Вопросов довольно много, поэтому начну с азов.

Scala основана на исчислении DOT. В Scala каждый тип T является сегментом типа [Lower, Upper]. Типы Scala представляют собой решетку (относительно <:, &, |): https://en.wikipedia.org/wiki/Lattice_(order)

T <: AnyRef не подразумевает T >: Null, и наоборот.

T <: AnyRef означает сегмент типа [Nothing, AnyRef]. T >: Null означает [Null, Any].

(Nothing <: AnyVal <: Any, Nothing <: Null <: AnyRef <: Any, Nothing != Null != AnyRef != AnyVal != Any.)

AnyRef — это супертип всех ссылочных типов. Null — подтип всех ссылочных типов. Null населен только null.

Nothing — подтип всех типов (включая Null: Nothing <: Null, Nothing != Null). В нем нет (нормальных) ценностей. Но то, что Nothing не населен (нормальными) ценностями, не означает, что t: Nothing вообще ничем не населен. Существуют термины такого типа: T >: Nothing, есть абстрактные типы/параметры типа, пересекающиеся с этим типом: T <: AnyRef (и в программировании на уровне типа типы важнее, значения, существуют они или нет, менее важны), нет поэтому нормальные значения (расхождения, нижние значения), такие как

@tailrec
def infiniteRecursion(): Nothing = infiniteRecursion()

def throwException(): Nothing = throw new RuntimeException("error")

def foo[T <: AnyRef](t: => T): Unit = ()

foo[Nothing](infiniteRecursion()) // compiles, runs, successfully finishes
foo[Nothing](throwException())  // compiles, runs, successfully finishes

def foo[T <: AnyRef](t: T): Unit = ()

foo[Nothing](infiniteRecursion()) // compiles, runs forever
foo[Nothing](throwException()) // compiles, runs, throws exception

Если T >: Null подразумевает foo[Nothing](infiniteRecursion()), то foo[Nothing](throwException()), T <: AnyRef не будут компилироваться.

Если вам нужны оба T >: Null и def foo[T >: Null <: AnyRef] = ..., просто укажите обе границы типа:

T & Null

Разве часть Null не должна быть упрощена компилятором до T <: AnyRef, когда T >: Null

Нет, не должно. Должно быть, когда T >: Null <: AnyRef (включая Null).

В чем разница между типами T & Null и T = Nothing?

Если T & Null = Nothing & Null = Nothing != Null, то T >: Null. Если T & Null = Null, то T <: Null. Если T (т. е. [Nothing, Null] принадлежит отрезку T & Null = T), то T. Если T & Null — это просто какой-то тип, то <: T — это просто некоторые типы <: Null и T (фактически, максимальный такой тип), обычно отличающиеся от Null и Nat.

Если определение перекрестка...

• если ценности...
• если ценности...

Думаю, год назад мы уже обсуждали, что типы не являются наборами (значений):

Почему признак, аннотируемый самим собой, не может быть присвоен типу самого себя?

https://cs.stackexchange.com/questions/91330/what-exactly-is-the-semantic-difference-between-set-and-type

https://math.stackexchange.com/questions/489369/difference-between-a-type-and-a-set

https://planetmath.org/11typetheoryversussettheory

Если два типа имеют равные наборы значений этих типов, это не делает типы равными.

Например, типы ниже Succ[N], _0, _1, _2, Nat, ... являются абстрактными и не имеют значений. Но это совершенно разные типы. Если бы типы были множествами, то все эти типы Succ[N], _0, _1, _2, X, ... были бы одним и тем же множеством (а именно пустым множеством).

type Nat
type _0 <: Nat
type Succ[N <: Nat] <: Nat

trait Add[N <: Nat, M <: Nat] {
  type Out <: Nat
}
object Add {
  type Aux[N <: Nat, M <: Nat, Out0 <: Nat] = Add[N, M] { type Out = Out0 }

  implicit def zeroAdd[M <: Nat]: Aux[_0, M, M] = null
  implicit def succAdd[N <: Nat, M <: Nat](implicit
    add: Add[N, M]
  ): Aux[Succ[N], M, Succ[add.Out]] = null
}

type _1 = Succ[_0]
type _2 = Succ[_1]
type _3 = Succ[_2]
type _4 = Succ[_3]
type _5 = Succ[_4]

implicitly[Add.Aux[_2, _3, _5]] // compiles

trait ToInt[N <: Nat] {
  def apply(): Int
}
object ToInt {
  implicit val zeroToInt: ToInt[_0] = () => 0
  implicit def succToInt[N <: Nat](implicit toInt: ToInt[N]): ToInt[Succ[N]] =
    () => toInt() + 1
}

trait AddToInt[N <: Nat, M <: Nat] {
  def apply(): Int
}
object AddToInt {
  implicit def mkAddToInt[N <: Nat, M <: Nat, Sum <: Nat](implicit
    add: Add.Aux[N, M, Sum],
    toInt: ToInt[Sum]
  ): AddToInt[N, M] = () => toInt()
}

def addToInt[N <: Nat, M <: Nat](implicit addToInt: AddToInt[N, M]): Int =
  addToInt()

addToInt[_2, _3] // 5

Согласно теории типов, не существует типа A & X такого, что X совпадает с A для любого X.

На самом деле, в системе типов Scala Nothing есть T.