Чёткое определение

Тоже так буду теперь всегда говорить

Спасибо

ну примерно если, то адт на которые натянули генерики(здарова), типа наш адт работает с N неизвестными параметрами и это все разнесено по членам суммы

sealed trait Foo[+A, +B]
case class Bar[+A, +B](a: A, b: B) extends Foo[A, B]
case class Baz[+A, +B](la: List[A], lb: List[B]) extends Foo[A, B]

это простой АДТ или уже ГАДТ?

для меня и исходя из моего определения — гадт

неправильный ответ

это простой АДТ, у всех конструкторов тот же набор тайп-параметров, что и у типа

читаемость класс

а, типа если я сделаю Quax[+A, +B, +C], то уже гадт?

sealed trait Foo[+A, +B]
case class Bar[+A](a: A) extends Foo[A, String]
case class Baz[+A, +B](la: List[A], lb: List[B]) extends Foo[A, B]

вот это, например ГАДТ

если ты сделаешь case object Kek extends Foo[Int, String]

не, тип у тя типы разные должны быть

sealed trait Foo[+A, +B]
case class Bar[+A, +B, C](c: C, f: C => (A, B)) extends Foo[A, B]
case class Baz[+A, +B](la: List[A], lb: List[B]) extends Foo[A, B]

и это тоже ГАДТ

соответственно эти два примера связаны с разными механизмами, которые представлены в конпеляторах

когда ты пишешь
(foo : Foo[A, B]) match {
 case Bar(a, b)

в случае АДТ ничего особенного не происходит с типами, у тебя просто появляются в контексте два новых имени

если ты пишешь case Bar(a) => в этом случае происходит то, что в конпеляторах называется унификация, т.е. компилятор узнает, что B = String , унифицирует два типа
и использует это в других своих выводах

если ты пишешь
case Bar(c, f) =>  в этом случае у тебя происходит другой эффект - ты знаешь, что во время конструкции был какой-то тип, и этот тип важен, чтобы расставить типы для с и f
например, ты должен знать что f можно применить к с а инту - без доп информации нельзя
т.е. конструктор можно представить как ∃C . c : C, f: C => (A, B)
такие типы называются экзистенциальными, и во время патерн-матчинга конпелятор делает другой трюк - это притворяется, что этот блок находится внутри какой-то генерик\параметрического контекста, где есть абстрактный тип С, т.е. как будто бы ты объявил
def handleBar[C](c: C, f: C => (A, B)) = ... с телом твоего матча
такой процесс выворачивания экзистенциальных типов в универсальные определения называется сколемизацией

вот вся эта хуита работает в дотти более или менее хорошо
в 2.13 приемлемо, а в 2.12 иногда не работает, а иногда приводит к крашам компилятор