жесть какая...
f - параметр метода, то есть он в контравариантной позиции
A => B - Параметр функции (A) тоже в контравариантной позиции
Таким образом f: A => B - тут A в дважды контравариантной позиции, то есть в ковариантной позиции

A - параметр функции в параметре метода. Тот случай, когда минус на минус дает плюс

Извиняюсь, а почему жесть? х)

думать приходится. не люблю я это дело

Тогда почему это не работает?
case class Sample[+A]() {
 
 def method[B](f: A => B) = ???
 
}

val f: Nothing => Int = ???

Sample[Int]().method[Int](f)
https://scastie.scala-lang.org/SwQrzrtiSeitPay9C2uAyw

Ой, а ??? – это способ не писать тело функции, дабы проверить type checking?

Ну типа того, хотя я не эксперт

Тут с точностью до наоборот.
В коде выше Int => Int используется там, где ожидается Nothing => Int - так можно из-за контравариантности. В вашем коде Nothing => Int используется там, где ожидается Int => Int - так нельзя

А, блин

??? - метод, возвращающий Nothing.

f: Int => Int
- это функция, которая принимает целое число, и возвращает целое
представим, что у нас есть
PosInt <: Int, некое положительное подмножество целых, наша функция определена для любых целых чисел, значит для всех положительных как минимум, что скала позволяет записать как
f: PosInt => Int
таким образом для любого подмножества целых чисед f определена на нём, что соответствует некому суждению в нашей системе типов
Nothing соответствует пустому подмножеству значений для множества значений любого типа
и любая функция
g: A => B определена на нём, что выражается как суждение
g: Nothing => B

таким образом, какую бы функцию f : A => B вы не передали, она так же является функцией Nothing => B, т.е. функцией с которой снимается необходимость обрабатывать что-либо, и нет никакого противоречия, в том чтобы передать её в метод, принимающий такой аргумент

Пошло что-то по Карри-Говарду

не

это попытка связать типы и множества, и подтипы и подмножества, довольно своевольная и неформальная чисто для интуиции

это очень ограниченная ассоциация, она не всегда работает, просто, чтобы решить проблему "как так"

мне проще так: Int => Int частный случай функции (подтип) Nothing => Int
т.к. Nothing это подтип Int то Int более общий тип
функция из более общего типа (Int) в менее общий (Int в этом случае, у нас они совпадают) будет подтипом функции

не верно

почему не верно? верно
любая функция из более общего типа в менее общий тип это подтип

туплю

все верно