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

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

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

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

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

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

интерпретация первого порядка вышеуказанных характеристик абстракций:

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

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

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

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

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

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

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

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

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

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

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

                   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, но вы можете использовать структурные типы без слишком больших синтаксических накладных расходов (the #λ-стиль обусловлен 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 constructor parameter", "type constructor member" или "Type constructor alias", чтобы подчеркнуть, что вы говорите не только о правильных типах.)

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