Что такое более высокий тип в Scala?

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

Конструктор типа - это тип, который можно применить для аргументов типа для "построения" типа.

Конструктор значений - это значение, которое вы можете применить к аргументам значения для "построения" значения.

Конструкторы значений обычно называются "функциями" или "методами". Эти "конструкторы" также называются "полиморфными" (потому что их можно использовать для создания "материала" различной "формы" ) или "абстракций" (поскольку они абстрагируются от того, что меняется между различными полиморфными экземплярами).

В контексте абстракции/полиморфизма первый порядок относится к "единственному использованию" абстракции: вы абстрагируетесь по типу один раз, но сам этот тип не может абстрагироваться ни от чего. Генераторы Java 5 являются первоклассными.

Первой интерпретацией вышеприведенных характеристик абстракций являются:

Конструктор типа - это тип, который можно применить к соответствующим аргументам типа для "построения" соответствующего типа.

Конструктор значений - это значение, которое вы можете применить к соответствующим аргументам значения, чтобы "построить" правильное значение.

Чтобы подчеркнуть, что нет абстракции (я думаю, вы могли бы назвать этот "нулевой порядок", но я этого не видел), например значение 1 или тип String, мы обычно говорим что-то является "правильным" значением или типом.

Собственное значение "немедленно можно использовать" в том смысле, что оно не ждет аргументов (оно не абстрагируется над ними). Думайте о них как о ценностях, которые вы можете легко распечатать/проверить (сериализация функции - обман!).

Правильный тип - это тип, который классифицирует значения (включая конструкторы значений), конструкторы типов не классифицируют какие-либо значения (сначала они должны применяться к аргументам правильного типа для получения соответствующего типа). Чтобы создать экземпляр типа, необходимо (но недостаточно), чтобы он был правильным типом. (Это может быть абстрактный класс или класс, к которому у вас нет доступа.)

"Высший порядок" - просто общий термин, который означает многократное использование полиморфизма/абстракции. Это означает то же самое для полиморфных типов и значений. Конкретно, абстракция более высокого порядка абстрагируется над чем-то, что абстрагируется над чем-то. Для типов термин "высший сорт" является специальной версией более общего "высшего порядка".

Таким образом, более высокая версия нашей характеристики становится:

Конструктор типа - это тип, который можно применить для аргументов типа (правильные типы или конструкторы типов) для "построения" подходящего типа (конструктора).

Конструктор значений - это значение, которое вы можете применить к аргументам значения (правильные значения или конструкторы значений) для "построения" правильного значения (конструктор).

Таким образом, "высший порядок" просто означает, что когда вы говорите "абстрагирование над X", вы действительно это понимаете! X, который абстрагируется, не теряет собственных "прав абстракции": он может абстрагировать все, что он хочет. (Кстати, я использую глагол "abstract" здесь, чтобы означать: оставить что-то, что не является существенным для определения значения или типа, так что он может быть изменен/предоставлен пользователем абстракции в качестве аргумента.)

Вот несколько примеров (по мотивам вопросов Лутца по электронной почте) правильных значений и типов первого порядка и более высокого порядка:

                   proper    first-order           higher-order

values             10        (x: Int) => x         (f: (Int => Int)) => f(10)
types (classes)    String    List                  Functor
types              String    ({type λ[x] = x})#λ   ({type λ[F[x]] = F[String]})#λ

Если используемые классы были определены как:

class String
class List[T]
class Functor[F[_]]

Чтобы избежать косвенности посредством определения классов, вам нужно как-то выразить функции анонимного типа, которые не выражаются непосредственно в Scala, но вы можете использовать структурные типы без излишних синтаксических накладных расходов (требуется стиль #λ на https://stackoverflow.com/users/160378/retronym afaik):

В некоторой гипотетической будущей версии Scala, которая поддерживает функции анонимного типа, вы можете сократить эту последнюю строку из примеров до:

types (informally) String    [x] => x              [F[x]] => F[String]) // I repeat, this is not valid Scala, and might never be

(В личной заметке я сожалею о том, что когда-либо говорил о "более высоких типах", они просто типа, когда все! Когда вам абсолютно необходимо устранить неоднозначность, я предлагаю сказать такие вещи, как "тип конструктора типа", "type член конструктора" или "псевдоним конструктора типа", чтобы подчеркнуть, что вы не говорите только о правильных типах.)

ps: Чтобы усложнить ситуацию, "полиморфный" неоднозначен по-другому, поскольку полиморфный тип иногда означает универсально квантифицированный тип, такой как Forall T, T => T, который является правильным типом, поскольку он классифицирует полиморфные значения (в Scala, это значение может быть записано как структурный тип {def apply[T](x: T): T = x})