Система типов Хиндли - Милнера

редактировать

A Система типов Хиндли - Милнера (HM) - это классическая система типов для лямбда-исчисление с параметрическим полиморфизмом. Он также известен как Дамас-Милнер или Дамас-Хиндли-Милнер . Впервые он был описан Дж. Роджер Хиндли, а затем вновь обнаружен Робином Милнером. Луис Дамас представил подробный формальный анализ и доказательство метода в своей докторской диссертации.

Среди основных примечательных свойств HM - его полнота и способность определять наиболее общий тип данной программы. без предоставленных программистом аннотаций типа типа или других подсказок. Алгоритм W - это эффективный метод вывода типа на практике, который успешно применен на больших базах кода, хотя имеет высокую теоретическую сложность. HM используется для функциональных языков. Впервые он был реализован как часть системы типов языка программирования ML. С тех пор HM был расширен способами, в первую очередь с помощью ограничений типа class, подобных тем что в Haskell.

Содержание

1 Введение
- 1.1 Мономорфизм против полиморфизма
- 1.2 Let-полиморфизм
2 Обзор
3 Система типов Хиндли - Милнера
- 3.1 Синтаксис
  - 3.1.1 Монотипы
  - 3.1.2 Политипы
  - 3.1.3 Контекст и типизация
  - 3.1.4 Переменные свободного типа
- 3.2 Порядок типов
  - 3.2.1 Основной тип
  - 3.2.2 Подстановка в типах
- 3.3 Дедуктивная система
  - 3.3.1 Правила ввода
- 3.4 Let- полиморфизм
- 3.5 Правило обобщения
4 Алгоритм вывода
- 4.1 Система правил, управляемый синтаксисом
- 4.3 Степени, воплощающие правила
- 4.4 Алгоритм J
5 Доказательство алгоритма
- 5.1 Алгоритм W
- 5.2 Обязательства по подтверждению
6 Расширения
- 6.1 Рекурсивные определения
  - 6.1.1 Правило ввода
  - 6.1.2 Последствия
- 6.2 Перегрузка
- 6.3 Мета-типы
- 6.4 Подтипы
7 Примечания
8 С с
9ние ссылки

Введение

В метод вывода типа Хиндли-Милнер позволяет выводить типы выражений и функций в качестве программ, написанных в полностью нетипизированном стиле. Будучи чувствительным к scope, он не ограничивается выводом типов только из частей исходного кода, а скорее из полных программ или модулей. Будучи способным работать с параметрическим типом, он также используется в качестве ядра для системы типа языков функционального программирования. Впервые он был применен к этому расширению в ML.

. Источником вывода типа для просто типизированного лямбда-исчисления, который был разработан Haskell Curry и Роберт Фейс в 1958 г. В 1969 г. Дж. Роджер Хиндли расширил эту работу и доказал, что их алгоритм всегда выводит самый общий тип. В 1978 году Робин Милнер, независимо от работы Хиндли, предоставил эквивалентный алгоритм, Алгоритм W. В 1982 году окончательно доказал полноту алгоритма Милнера и расширил его для поддержки систем с полиморфными ссылками.

Мономорфизм противорфизма

В просто типизированном лямбда-исчислении типы $T {\ displaystyle T}$ $T$ начало себя константами атомарного типа или функциональные типы формы $Т → Т {\ Displaystyle T \ rightarrow T}$ $T\rightarrow T$ . Такие типы мономорфны. Типичными примерами являются используемые в арифметических значениях:

3: Добавление числа 3 4: Добавление числа: ->Число ->Число

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

≡ λ {\ displaystyle \ Equiv \ lambda}

{\ displaystyle \ Equiv \ lambda}

x. x

, который просто возвращает любое значение, к используемому. Менее тривиальные примеры параметров, такие как списки.

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

минусы: для всех a. a ->Список a ->Список ноль: forall a. Список а. id: для всех. a ->a

Полиморфные типы могут стать мономорфными последовательными заменами их числа. Примеры мономорфных экземпляров:

id ': String ->String nil': Номер списка

В более общем смысле, тип полиморфны, когда они содержат переменные типа, тогда как типы без них являются мономорфными.

В различных типах систем, используемых, например, в Pascal (1970) или C (1972), которые только мономорфные типы, HM разработаны с акцентом на параметрический полиморфизм. Преемники упомянутых языков, такие как C ++ (1985), сфокусировались на различных типах полиморфизма, а именно на подтипе в связи с объектно-ориентированным программированием и перегрузке. Хотя подтипирование несовместимо с HM, вариант систематической перегрузки доступен в основанной на HM системе типов Haskell.

Let-полиморфизм

При расширении вывода типа для простого типизированного лямбда-исчисления в сторону полиморфизма необходимо определить, когда получение экземпляров значений допустимо. В идеале это было бы разрешено при любом использовании используемого компонента, например:

(λ id.... (id 3)... (id "text")...) (λ x. X)

К сожалению, вывод типа в полиморфном лямбда-исчислении не разрешим. Вместо этого HM предоставляет let-полиморфизм вида

let id = λ x. x in ... (id 3)... (id "текст")...

ограничение механизма привязки в расширении синтаксиса выражения. Только значения, связанные в конструкции let, могут быть инстанцированы, т.е. являются полиморфными, а параметры в лямбда-абстракциях рассматриваются как мономорфные.

Обзор

Дальнейшая часть этого статьи следующим образом:

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

Везде используется одно и то же описание системы дедукции. даже для двух алгоритмов, чтобы сделать различные формы, представленные в представленных HM, напрямую сопоставимыми.

Система типов Хиндли-Милнера

Систему типов можно формально описать с помощью правил синтаксиса, которые фиксируют язык для выражений, типов и т. Д. Представление здесь такой синтаксис не является слишком формальным, поскольку он написан не для изучения поверхностной грамматики, а скорее для изучения глубинной грамматики, и оставляет некоторые синтаксические детали открытыми. Такая форма представления обычная. Основываясь на этом, типы типов используются для определения того, как используемые различные типы. Как и прежде, форма немного либеральна.

Синтаксис

Выражения

e = x переменная | е 1 е 2 приложение | λ х. е абстракция | letx = e 1 ine 2 {\ displaystyle {\ begin {array} {lrll} \\ e = x {\ textrm {variable}} \\ \ vert e_ {1} \ e_ {2} { \ textrm {приложение}} \\ \ vert \ lambda \ x \. \ e {\ textrm {abstraction}} \\ \ vert {\ mathtt {let}} \ x = e_ {1} \ {\ mathtt {in}} \ e_ {2} \\\\\ конец {array}}

{\begin{array}{lrll}\\e=x{\textrm {variable}}\\\vert e_{1}\ e_{2}{\textrm {application}}\\\vert \lambda \ x\.\ e{\textrm {abstraction}}\\\vert {\mathtt {let}}\ x=e_{1}\ {\mathtt {in}}\ e_{2}\\\\\end{array}}

Типы

моно τ = α переменная | C τ… τ приложение | τ → τ абстракция поли σ = τ | ∀ α. σ квантификатор {\ displaystyle {\ begin {array} {llrll} \\ {\ textrm {mono}} \ tau = \ alpha \ {\ textrm {variable}} \\ \ vert C \ \ tau \ точки \ tau \ {\ textrm {application}} \\ \ vert \ tau \ rightarrow \ tau \ {\ textrm {abstraction}} \\ {\ textrm {poly}} \ sigma = \ тау \\ \ верт \ forall \ \ alpha \. \ \ sigma \ {\ textrm {quantifier}} \\\\\ end {array}}}

{\ displaystyle {\ begin {array} {llrll} \\ {\ textrm { mono}} \ tau = \ alpha \ {\ textrm {variable}} \\ \ vert C \ \ tau \ dots \ tau \ {\ textrm {application}} \\ \ vert \ tau \ rightarrow \ tau \ {\ textrm {abstraction}} \\ {\ textrm {poly}} \ sigma = \ tau \\ \ vert \ forall \ \ alpha \. \ \ sigma \ {\ textrm {квантификатор}} \\\\\ end {array}}

Контекст и ввод

Контекст Γ = ϵ (пусто) | Γ, x: σ Набрав = Γ ⊢ e: σ {\ displaystyle {\ begin {array} {llrl} \\ {\ text {Context}} \ Gamma = \ epsilon \ {\ mathtt {(пусто)} } \\ \ vert \ Gamma, \ x: \ sigma \\ {\ text {Typing}} = \ Gamma \ vdash e: \ sigma \\\\\ end {array}}}

{\ displaystyle {\ begin {array} {llrl} \\ {\ text {Context}} \ Gamma = \ epsilon \ {\ mathtt {(empty)}} \\ \ vert \ Gamma, \ x: \ sigma \\ {\ text {Typing}} = \ Gamma \ vdash e: \ sigma \\\\\ end {array}}}

Бесплатно Переменные типа

free (α) = {α} free (C τ 1… τ n) = ⋃ i = 1 n free (τ i) free (Γ) = ⋃ x: σ ∈ Γ free (σ) free ( ∀ α. Σ) = бесплатно (σ) - {α} бесплатно (Γ ⊢ e: σ) = бесплатно (σ) - бесплатно (Γ) {\ displaystyle {\ begin {array} {ll} \\ {\ text { бесплатно}} (\ \ alpha \) = \ \ left \ {\ alpha \ right \} \\ {\ text {free}} (\ C \ \ tau _ {1} \ dots \ tau _ {n} \) = \ \ bigcup \ limits _ {i = 1} ^ {n} {{\ text {free}} (\ \ tau _ {i} \)} \\ {\ text {free}} (\ \ Gamma \) = \ \ bigcup \ limits _ {x: \ sigma \ in \ Gamma} {\ text {free}} (\ \ sigma \) \\\\ {\ text {free}} (\ \ forall \ \ альфа \. \ \ sigma \) = \ {\ text {free}} (\ \ sigma \) \ - \ left \ {\ alpha \ right \} \\ {\ text {free}} (\ \ Gamma \ вдаш е: \ си gma \) = \ {\ text {free}} (\ \ sigma \) \ - \ {\ text {free}} (\ \ Gamma \) \\\\\ end {array}}}

{\begin{array}{ll}\\{\text{free}}(\ \alpha \)=\ \left\{\alpha \right \}\\{\text{free}}(\ C\ \tau _{1}\dots \tau _{n}\)=\ \bigcup \limits _{i=1}^{n}{{ \text{free}}(\ \tau _{i}\)}\\{\text{free}}(\ \Gamma \)=\ \bigcup \limits _{x:\sigma \in \Gamma } {\text{free}}(\ \sigma \)\\\\{\text{ free}}(\ \forall \ \alpha \.\ \sigma \)=\ {\text{free}}(\ \sigma \)\ -\ \left\{\alpha \right\}\\{\text{free}}(\ \Gamma \vdas h e:\sigma \)=\ {\text{free}}(\ \sigma \)\ -\ {\text{free}}(\ \Gamma \)\\\\\end{array}}

Выражения, которые нужно набрать, соответствуют se из лямбда-исчисления расширен let-выражением, как показано в соседней таблице. Круглые скобки Заголовок "Номнозначности выражения". Приложение связывает слева и связывает, чем абстракция или конструкция сильнее.

Типы синтаксически разделены на две группы: монотипы и политипы.

Монотипы

Монотипы всегда обозначают определенный тип. Монотипы $τ {\ displaystyle \ tau}$ $\tau$ синтаксически представлены как термины.

Примеры монотипов, включая константы типов, такие как $int {\ displaystyle {\ mathtt {int}} }$ ${\ mathtt {int}}$ или $строка {\ displaystyle {\ mathtt {string}}}$ ${\ mathtt {string}}$ и параметрические типы, такие как $M ap (S etstring) int {\ displaystyle {\ mathtt {Карта \ (Set \ string) \ int}}}$ ${\mathtt {Map\ ( Set\ string)\ int}}$ . Последние типы являются примерами типов типов, например, из набора ${M ap 2, S et 1, string 0, int 0, → 2} {\ displaystyle \ {{\ mathtt {Map ^ {2}, \ Set ^ {1}, \ string ^ {0}, \ int ^ {0}}}, \ \ rightarrow ^ {2} \}}$ ${\ displaystyle \ {{\ mathtt {Map ^ {2}, \ Set ^ {1}, \ строка ^ {0}, \ int ^ {0}}}, \ \ rightarrow ^ {2} \}}$ , где верхний индекс указывает количество параметров типа. Полный набор функций типа $C {\ displaystyle C}$ $C$ в HM произвольный, за исключением того, что он должен содержать не менее $→ 2 {\ displaystyle \ rightarrow ^ {2}}$ $\ rightarrow ^ {2}$ , тип функций. Для удобства его часто пишут инфиксной нотацией. Например, функция, отображающая целые числа в строке, имеет тип $i n t → s t r i n g {\ displaystyle {\ mathtt {int}} \ rightarrow {\ mathtt {string}}}$ ${\mathtt {int}}\rightarrow {\mathtt {string}}$ . Опять же, скобки можно использовать для устранения неоднозначности выражения типа. Приложение связывает сильнее, чем инфиксная стрелка, которая связывает вправо.

Переменные типа допускаются как монотипы. Монотипы не следует путать с мономорфными типами, которые исключают переменные и допускают только основные термины.

Два монотипа равны, если у них одинаковые термины.

Политипы

Политипы (или схемы типов) - это перечень связанных одним или используемым квантификми для всех, например $∀ α. α → α {\ Displaystyle \ forall \ альфа. \ alpha \ rightarrow \ alpha}$ $\forall \alpha.\alpha \rightarrow \alpha$ .

Функция с политипом $∀ α. α → α {\ Displaystyle \ forall \ альфа. \ alpha \ rightarrow \ alpha}$ $\forall \alpha.\alpha \rightarrow \alpha$ может отображать любое значение того же типа самому себе, и функция идентичности является величиной для этого типа.

В качестве другого примера, $∀ α. (S и α) → int {\ Displaystyle \ forall \ альфа. ({\ Mathtt {Set}} \ alpha) \ rightarrow {\ mathtt {int}}}$ $\ forall \ alpha. ({\ mathtt {Set}} \ \ alpha) \ rightarrow {\ mathtt {int}}$ - тип отображения функций всех конечных чисел в целые числа. Функция, которая возвращает мощность набора, будет значением этого типа.

Квантификаторы могут появляться только на верхнем уровне. Например, тип $∀ α. α → ∀ α. α {\ Displaystyle \ forall \ альфа. \ alpha \ rightarrow \ forall \ alpha. \ alpha}$ $\для ll \ alpha. \ alpha \ rightarrow \ forall \ alpha. \ alpha$ исключается синтаксисом типов. В политипы входят монотипы, поэтому тип имеет также общий вид $∀ α 1… ∀ α n. τ, N ≥ 0 {\ Displaystyle \ forall \ alpha _ {1} \ dots \ forall \ alpha _ {n}. \ tau, n \ geq 0}$ ${\ displaystyle \ forall \ alpha _ {1} \ dots \ forall \ alp ха _ {п}. \ тау, п \ geq 0}$ , где $τ {\ displaystyle \ tau}$ $\tau$ - монотипия.

Равенство политипов зависит от переупорядочения количественных оценок и переименования количественных чисел ( $α {\ displaystyle \ alpha}$ $\alpha$ -конверсия). Кроме того, количественные переменные не встречаются в монотипе, могут быть опущены.

Контекст и типизация

Чтобы осмысленно объединить все еще непересекающиеся части (синтаксические выражения и типы), необходима третья часть: контекст. Синтаксически контекст - это список пар $x: σ {\ displaystyle x: \ sigma}$ $x: \ sigma$ , называемые присвоениями, предположениями или привязками, каждая пара, указывающая, что значение $xi {\ displaystyle x_ {i}}$ $x_ {i}$ тип $σ i {\ displaystyle \ sigma _ {i}}$ $\sigma _{i}$ . Все три части вместе дают оценку типа $Γ ⊢ e: σ {\ displaystyle \ Gamma \ \ vdash \ e: \ sigma}$ $\Gamma \ \vdash \ e:\sigma$ , что при предположениях $Γ {\ displaystyle \ Gamma}$ $\ Gamma$ , выражение $e {\ displaystyle e}$ $e$ имеет тип $σ {\ displaystyle \ sigma}$ $\ sigma$ .

переменные произвольного типа

В виде $α 1… ∀ α n. τ {\ displaystyle \ forall \ alpha _ {1} \ dots \ forall \ alpha _ {n}. \ tau}$ $\ forall \ alpha _ {1} \ dots \ forall \ alpha _ {n}. \ Tau$ , символ $∀ {\ displaystyle \ forall}$ $\ forall$ - квантор, связывающий переменные типа $α i {\ displaystyle \ alpha _ {i}}$ $\ alpha _ {i}$ в монотипе $τ {\ displaystyle \ tau}$ $\tau$ . Переменные $α i {\ displaystyle \ alpha _ {i}}$ $\ alpha _ {i}$ называются квантифицированными, и любое определение квантифицированного типа в $τ {\ displaystyle \ tau}$ $\tau$ называется системой, а все переменные несвязанного типа в $τ {\ displaystyle \ tau}$ $\tau$ называются свободными. В дополнение к количественному определению $∀ {\ displaystyle \ forall}$ $\ forall$ в политипах, переменные типа могут также быть связаны, встречаясь в контексте, но с обратным эффектом в правой части $⊢ {\ displaystyle \ вдаш}$ $\vdash$ . В этом случае такие переменные ведут себя как константы типов. Наконец, переменная типа может быть юридически несвязанной при типе, и в этом случае все неявно качественно.

Наличие как связанных, так и несвязанных чисел типа немного необычно для языков программирования. Часто все переменные типа обрабатываются неявно и количественно. Например, в Prolog нет предложений со свободными переменными. Скорее всего, в Haskell, где все типы неявно выражаются количественно, т.е. тип Haskell a ->aозначает $∀ α. α → α {\ Displaystyle \ forall \ альфа. \ alpha \ rightarrow \ alpha}$ $\forall \alpha.\alpha \rightarrow \alpha$ здесь. Связанный, а также очень необычный эффект связывания правой стороны $σ {\ displaystyle \ sigma}$ $\ sigma$ назначений.

Как правило, происходит сочетание связанного и несвязанного типа из-за использования выражения в выражении. Постоянная функция K= $λ x. λ y. х {\ Displaystyle \ лямбда х. \ lambda y.x}$ ${\ displaystyle \ lambda x. \ lambda yx}$ дает пример. Он имеет монотипию $α → β → α {\ displaystyle \ alpha \ rightarrow \ beta \ rightarrow \ alpha}$ ${\ displaystyle \ alpha \ rightarrow \ beta \ rightarrow \ alpha}$ . Можно вызвать полиморфизм с помощью $l e t k = λ x. (letf = λ Y. xinf) чернила {\ displaystyle \ mathbf {let} \ k = \ lambda x. (\ mathbf {let} \ f = \ lambda yx \ \ mathbf {in} \ f) \ \ mathbf {in} \ k}$ ${\ displaystyle \ mathbf {let } \ k = \ lambda x. (\ mathbf {let} \ f = \ lambda yx \ \ mathbf {in} \ f) \ \ mathbf {in} \ k}$ . Здесь $f {\ displaystyle f}$ $f$ имеет тип $∀ γ. γ → α {\ Displaystyle \ forall \ гамма. \ gamma \ rightarrow \ alpha}$ ${\ displaystyle \ forall \ gamma. \ gamma \ rightarrow \ alpha}$ . Свободная переменная монотипии $α {\ displaystyle \ alpha}$ $\alpha$ происходит от типа $x {\ displaystyle x}$ $x$ , структура в окружающей области. $к {\ displaystyle k}$ $k$ имеет тип $∀ α ∀ β. α → β → α {\ Displaystyle \ для \ альфа \ для \ бета. \ alpha \ rightarrow \ beta \ rightarrow \ alpha}$ $\forall \alpha \forall \beta.\alpha \rightarrow \beta \rightarrow \alpha$ . Можно представить себе переменную свободного типа $α {\ displaystyle \ alpha}$ $\alpha$ в типе $f {\ displaystyle f}$ $f$ , связанное с $∀ α {\ displaystyle \ forall \ alpha}$ ${\ displaystyle \ forall \ alpha}$ в типе $k {\ displaystyle k}$ $k$ . Но такой объем не может быть выражен в HM. Скорее привязка контекст контекстом.

Порядок типов

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

В качестве примера тождества $λ x. x {\ displaystyle \ lambda x.x}$ ${\ displaystyle \ lambda xx}$ может иметь $∀ α. α → α {\ Displaystyle \ forall \ альфа. \ alpha \ rightarrow \ alpha}$ ${\ displaystyle \ forall \ alpha. \ alpha \ rightarrow \ alpha}$ как его тип, а также $строка → строка {\ displaystyle {\ texttt {string}} \ rightarrow {\ texttt {строка}}}$ ${\texttt {string}}\rightarrow {\texttt {string}}$ или $int → int {\ displaystyle {\ texttt {int}} \ rightarrow {\ texttt {int}}}$ ${\ displaystyle {\ texttt {int}} \ rightarrow {\ texttt {int}}}$ и многие другие, но не $int → строка {\ displaystyle { \ texttt {int}} \ rightarrow {\ texttt {строка}}}$ ${\texttt {int}}\rightarrow {\texttt {string}}$ . Наиболее общий тип этой функции - $α. α → α {\ Displaystyle \ forall \ альфа. \ alpha \ rightarrow \ alpha}$ ${\ displaystyle \ forall \ alpha. \ alpha \ rightarrow \ alpha}$ , в то время как другие конкретны и могут быть производными от общего, последовательно заменяя другой тип для типа типа, т. е. количественная переменная $α {\ displaystyle \ alpha}$ $\alpha$ . Контрпример терпит неудачу, потому что замена непоследовательна.

Последовательная замена может сделать формальную, применив замену $S = {ai ↦ τ i,…} {\ displaystyle S = \ left \ {\ a_ {i} \ mapsto \ tau _ {i}, \ \ dots \ \ right \}}$ ${\ Displaystyle S = \ left \ {\ a_ {i} \ mapsto \ tau _ {i}, \ \ dots \ \ right \}}$ к члену типа $τ {\ displaystyle \ tau}$ $\tau$ , записанному $S τ {\ Displaystyle S \ тау}$ $S\tau$ . Как показывает пример, подстановка не только использует с порядком, которая позволяет использовать более низкую квалификацию, но также с общей количественной оценкой, которая позволяет применять замену.

Правило специализации

τ ′ = {α i ↦ τ i} τ β i ∉ free (∀ α 1... ∀ α n. Τ) ∀ α 1... ∀ α n. τ ⊑ ∀ β 1... ∀ β м. τ ′ {\ displaystyle \ displaystyle {\ frac {\ tau '= \ left \ {\ alpha _ {i} \ mapsto \ tau _ {i} \ right \} \ tau \ quad \ beta _ {i} \ not \ в {\ textrm {free}} (\ forall \ alpha _ {1}... \ forall \ alpha _ {n}. \ tau)} {\ forall \ alpha _ {1}... \ forall \ alpha _ {n}. \ tau \ sqsubseteq \ forall \ beta _ {1}... \ forall \ beta _ {m}. \ tau '}}}

\displaystyle {\frac {\tau '=\left\{\alpha _{i}\mapsto \tau _{i}\right\}\tau \quad \beta _{i}\not \in {\textrm {free}}(\forall \alpha _{1}...\forall \alpha _{n}.\tau)}{\forall \alpha _{1}...\forall \alpha _{n}.\tau \sqsubseteq \forall \beta _{1}...\forall \beta _{m}.\tau '}}

Формально в HM тип $σ ′ {\ displaystyle \ sigma'}$ $\sigma '$ является более общим, чем $σ {\ displaystyle \ sigma}$ $\ sigma$ , формально $σ ′ ⊑ σ {\ displaystyle \ sigma '\ sqsubseteq \ sigma}$ $\sigma '\sqsubseteq \sigma$ , если некоторая количественная переменная в $σ ′ {\ displaystyle \ sigma'}$ $\sigma '$ последовательно заменяется так, что получается $σ {\ displaystyle \ sigma}$ $\ sigma$ , как показано на боковой панели. Этот порядок является частью определения типа системы типов.

В нашем примере применения $S = {α ↦ строка} {\ displaystyle S = \ left \ {\ alpha \ mapsto {\ texttt {string}} \ right \}}$ $S=\left\{\alpha \mapsto {\texttt {string}}\right\}$ приведет к $∀ α. α → α ⊑ строка → строка {\ displaystyle \ forall \ alpha. \ alpha \ rightarrow \ alpha \ sqsubseteq {\ texttt {string}} \ rightarrow {\ texttt {string}}}$ ${\ displaystyle \ forall \ alpha. \ Alpha \ rightarrow \ альфа \ sqsubseteq {\ texttt {строка}} \ rightarrow {\ texttt {строка}}}$ .

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

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

Отношение $⊑ {\ displaystyle \ sqsubseteq}$ $\ sqsubseteq$ является частичным порядком и $∀ α. α {\ Displaystyle \ forall \ альфа. \ alpha}$ ${\ displaystyle \ forall \ alpha. \ alpha}$ - его наименьший элемент.

Основной тип

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

Подстановка в типах

Порядок типов, может быть расширен до типов, потому что подразумеваемая совокупная оценка обеспечивается последовательной замену:

Γ ⊢ e: σ ⟹ S Γ ⊢ e: S σ {\ displaystyle \ Gamma \ vdash e: \ sigma \ quad \ Longrightarrow \ quad S \ Gamma \ vdash e: S \ sigma}

{\ displaystyle \ Gamma \ vdash e: \ sigma \ quad \ Longrightarrow \ quad S \ Gamma \ vdash e: S \ sigma}

Вопреки правилу спецификации, это не часть определения, но как неявная общая количественная оценка, скорее, следствие правил типов, определенных. Переменные свободного типа в типизации заполнителями для возможного уточнения. Эффект привязки среды к переменным свободного типа в правой части $⊢ {\ displaystyle \ vdash}$ $\vdash$ , запрещающая их замену в правиле специализации, снова заключается в том, что замена должна быть согласованной и нужно будет весь набор текстов.

В этой статье мы обсудим четыре различных набора правил:

$⊢ D {\ displaystyle \ vdash _ {D}}$ $\vdash _{D}$ декларативная система
$⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ синтаксическая система
$⊢ J {\ displaystyle \ vdash _ {J}}$ ${\ displaystyle \ vdash _ {J}}$ алгоритм J
$⊢ W {\ displaystyle \ vdash _ {W}}$ ${\ displaystyle \ vdash _ {W}}$ алгоритм W

Дедуктивная система

Синтаксис правил

Предикат = σ ⊑ σ ′ | α ∉ f r e e (Γ) | x: α ∈ Γ Суждение = набор набора = Суждение | Предикат Заключение = Правило суждения = формула… Заключение [Имя] {\ displaystyle {\ begin {array} {lrl} {\ text {Predicate}} = \ sigma \ sqsubseteq \ sigma '\\ \ vert \ \ alpha \ not \ in free (\ Gamma) \\ \ vert \ x: \ alpha \ in \ Gamma \\\\ {\ text {Judgment}} = {\ text {Typing}} \\ {\ text {блюдо}} = {text {Суждение}} \ \ vert \ {\ text {Предикат}} \\ {\ text {Заключение}} = {\ text {Суждение}} \\\\ {\ текст {Правило}} = \ displaystyle {\ frac {{\ textrm {Premise}} \ \ dots} {\ textrm {Заключение}}} \ quad [{\ mathtt {Name}}] \ end {array}} }

{\begin{array}{lrl}{\text{Predicate}}=\sigma \sqsubseteq \sigma '\\\vert \ \alpha \not \in free(\Gamma)\\\vert \ x:\alpha \in \Gamma \\\\{\text{Judgment}}={\text{Typing}}\\{\text{Premise}}={\text{Judgment}}\ \vert \ {\text{Predicate}}\\{\text{Conclusion}}={\text{Judgment}}\\\\{\text{Rule}}=\displaystyle {\frac {{\textrm {Premise}}\ \dots }{\textrm {Conclusion}}}\quad [{\mathtt {Name}}]\end{array}}

Синтаксис HM перенесен в синтаксис правил вывода, которые образуют тело формальной системы, с использованием типов суждений. Каждое из правил определить, какой вывод из каких посылок можно сделать. В дополнение к судебным решениям, некоторые дополнительные условия, представленные выше, представленные в качестве предписания в предпосылок.

Доказательство с использованием правил - это последовательность суждений, в которой все условия перед выводом. Приведенные ниже показывают возможный формат доказательств. Слева направо, каждая строка показывает заключение, $[N ame] {\ displaystyle [{\ mathtt {Name}}]}$ $[{\mathtt {Name}}]$ применяемых правил и условий, либо со ссылкой на более раннюю строку (номер), если посылка является суждением или явным предикатом.

Правила набора текста

Система декларативных правил

x: σ ∈ Γ Γ ⊢ D x: σ [V ar] Γ ⊢ D e 0: τ → τ ′ Γ ⊢ D e 1: τ Γ ⊢ D e 0 e 1: τ ′ [A pp] Γ, x: τ ⊢ D e: τ ′ Γ ⊢ D λ x. e: τ → τ ′ [A bs] Γ ⊢ D e 0: σ Γ, x: σ ⊢ D e 1: τ Γ ⊢ D letx = e 0 ine 1: τ [L et] Γ ⊢ D e: σ ′ σ ′ ⊑ σ Γ ⊢ D e: σ [I nst] Γ ⊢ D e: σ α ∉ free (Γ) Γ ⊢ D e: ∀ α. σ [G en] {\ displaystyle {\ begin {array} {cl} \ displaystyle {\ frac {x: \ sigma \ in \ Gamma} {\ Gamma \ vdash _ {D} x: \ sigma}} [{ \ mathtt {Var}}] \\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {D} e_ {0}: \ tau \ rightarrow \ tau '\ quad \ quad \ Gamma \ vdash _ {D} e_ {1}: \ tau} {\ Gamma \ vdash _ {D} e_ {0} \ e_ {1}: \ tau '}} [{\ mathtt {App}}] \\\\\ displaystyle {\ frac {\ Gamma, \; x: \ tau \ vdash _ {D} e: \ tau '} {\ Gamma \ vdash _ {D} \ lambda \ x \. \ E: \ tau \ rightarrow \ tau '}} [{\ mathtt {Abs}}] \\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {D} e_ {0}: \ sigma \ quad \ quad \ Gamma, \, x: \ sigma \ vdash _ {D} e_ {1}: \ tau} {\ Gamma \ vdash _ {D} {\ mathtt {let}} \ x = e_ {0} \ {\ mathtt {in}} \ e_ {1}: \ tau}} и [{\ mathtt {Let}}] \\\\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {D} e: \ sigma ' \ quad \ sigma '\ sqsubseteq \ sigma} {\ Gamma \ vdash _ {D} e: \ sigma}} [{\ mathtt {Inst}}] \\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {D} е: \ sigma \ quad \ alpha \ notin {\ text {free}} (\ Gamma)} {\ Gamma \ vdash _ {D} e: \ forall \ \ alpha \. \ \ sigma}} [{\ mathtt {Gen}}] \\\\\ end {array}}}

{\begin{array}{cl}\displaystyle {\frac {x:\sigma \in \Gamma }{\Gamma \vdash _{D}x:\sigma }}[{\mathtt {Var}}]\\\\\displaystyle {\frac {\Gamma \vdash _{D}e_{0}:\tau \rightarrow \tau '\quad \quad \Gamma \vdash _{D}e_{1}:\tau }{\Gamma \vdash _{D}e_{0}\ e_{1}:\tau '}}[{\mathtt {App}}]\\\\\displaystyle {\frac {\Gamma,\;x:\tau \vdash _{D}e:\tau '}{\Gamma \vdash _{D}\lambda \ x\.\ e:\tau \rightarrow \tau '}}[{\mathtt {Abs}}]\\\\\displaystyle {\frac {\Gamma \vdash _{D}e_{0}:\sigma \quad \quad \Gamma,\,x:\sigma \vdash _{D}e_{1}:\tau }{\Gamma \vdash _{D}{\mathtt {let}}\ x=e_{0}\ {\mathtt {in}}\ e_{1}:\tau }}[{\mathtt {Let}}]\\\\\\\displaystyle {\frac {\Gamma \vdash _{D}e:\sigma '\quad \sigma '\sqsubseteq \sigma }{\Gamma \vdash _{D}e:\sigma }}[{\mathtt {Inst}}]\\\\\displaystyle {\frac {\Gamma \vdash _{D}e:\sigma \quad \alpha \notin {\text{free}}(\Gamma)}{\Gamma \vdash _{D}e:\forall \ \alpha \.\ \sigma }}[{\mathtt {Gen}}]\\\\\end{array}}

Боковое окно показывает правила дедукции системы типов HM. Можно грубо разделить правила на две группы:

Первые четыре правила $[V ar] {\ displaystyle [{\ mathtt {Var}}]}$ $[{\ mathtt {Var }}]$ (переменная или функция доступ), $[A pp] {\ displaystyle [{\ mathtt {App}}]}$ $[{\ mathtt {App}} ]$ (приложение, т.е. вызов функции с одним параметром), $[A bs] {\ displaystyle [{\ mathtt {Abs}}]}$ $[{\ mathtt {Abs}}]$ (абстракция, то есть функции объявления) и $[L et] {\ displaystyle [{\ mathtt {Let}}]}$ $[{\mathtt {Let}}]$ (объявление) сосредоточены вокруг синтаксиса, представляя одно правило для каждой формы выражения. Их значение с первого взгляда, поскольку они разбирают каждое выражение, доказывают свои подвыражения и наконец, объединяют типы, найденные в соединках, с типом в заключении.

Вторая группа образована двумя предписаниями $[I nst] {\ displaystyle [{\ mathtt {Inst}}]}$ $[{\ mathtt {Inst}}]$ и $[G en] {\ displaystyle [ {\ mathtt {Gen}}]}$ $[{\ mathtt {Gen}}]$ . Они обрабатывают специализацию и обобщение типов. Хотя правило $[I nst] {\ displaystyle [{\ mathtt {Inst}}]}$ $[{\ mathtt {Inst}}]$ должно быть удалено из раздела по специализации выше, $[G ru] {\ displaystyle [{\ mathtt {Gen}}]}$ $[{\ mathtt {Gen}}]$ дополняет первое, работает в противоположном направлении. Это позволяет обобщать, то есть количественно определять переменные монотипа, не связанные в контексте.

Следующие два примера демонстрируют систему правил в действии. Здесь используются данные для типов правил.

Пример : Доказательство для $Γ ⊢ D id (n): int {\ displaystyle \ Gamma \ vdash _ {D} id (n): int}$ $\ Gamma \ vdash _ {D} id (n): int$ где $Γ = id: ∀ α. α → α, N: int {\ displaystyle \ Gamma = id: \ forall \ alpha. \ alpha \ rightarrow \ alpha, \ n: int}$ $\Gamma =id:\forall \alpha.\alpha \rightarrow \alpha,\ n:int$ , можно записать

1: Γ ⊢ D id: ∀ α. α → α [V ar] (id: ∀ α. α → α ∈ Γ) 2: Γ ⊢ D id: int → int [I nst] (1), (∀ α. α → α ⊑ int → int) 3 : Γ ⊢ D n: int [V ar] (n: int ∈ Γ) 4: Γ ⊢ D id (n): int [A pp] (2), (3) {\ displaystyle {\ begin {array} { llll} 1: \ Gamma \ vdash _ {D} id: \ forall \ alpha. \ alpha \ rightarrow \ alpha [{\ mathtt {Var}}] (id: \ forall \ alpha. \ alpha \ rightarrow \ alpha \ in \ Gamma) \\ 2: \ Gamma \ vdash _ {D} id : int \ rightarrow int [{\ mathtt {Inst}}] (1), \ (\ forall \ alpha. \ alpha \ rightarrow \ alpha \ sqsubseteq int \ rightarrow int) \\ 3: \ Gamma \ vdash _ {D} n: int [{\ mathtt {Var}}] (n: int \ in \ Gamma) \\ 4: \ Гамма \ vdash _ {D} id (n): int [{\ mathtt {App}}] (2), \ (3) \\\ end {array}}}

{\begin{array}{llll}1:\Gamma \vdash _{D}id:\forall \alpha.\alpha \rightarrow \alpha [{\mathtt {Var}}](id:\forall \alpha.\alpha \rightarrow \alpha \in \Gamma)\\2:\Gamma \vdash _{D}id:int\rightarrow int[{\mathtt {Inst}}](1),\ (\forall \alpha.\alpha \rightarrow \alpha \sqsubseteq int\rightarrow int)\\3:\Gamma \vdash _{D}n:int[{\mathtt {Var}}](n:int\in \Gamma)\\4:\Gamma \vdash _{D}id(n):int[{\mathtt {App}}](2),\ (3)\\\end{array}}

Пример : для демонстрации обобщения, $⊢ D пусть id = λ x. x в i d: α. α → α {\ Displaystyle \ vdash _ {D} \ {\ textbf {let}} \, id = \ lambda xx \ {\ textbf {in}} \ id \,: \, \ forall \ alpha. \ alpha \ rightarrow \ alpha}$ $\vdash _{D}\ {\textbf {let}}\,id=\lambda x.x\ {\textbf {in}}\ id\,:\,\forall \alpha.\alpha \rightarrow \alpha$ показано ниже:

1: x: α ⊢ D x: α [V ar] (x: α ∈ {x: α}) 2: ⊢ D λ x. x: α → α [A b s] (1) 3: ⊢ D λ x. х: ∀ α. α → α [G e n] (2), (α ∉ f r e e (ϵ)) 4: i d: ∀ α. α → α ⊢ D i d: ∀ α. α → α [V a r] (i d: ∀ α. α → α ∈ {i d: ∀ α. α → α}) 5: ⊢ D пусть i d = λ x. x в i d: α. α → α [L et] (3), (4) {\ displaystyle {\ begin {array} {llll} 1: x: \ alpha \ vdash _ {D} x: \ alpha [{\ mathtt {Var }}] (x: \ alpha \ in \ left \ {x: \ alpha \ right \}) ​​\\ 2: \ vdash _ {D} \ lambda xx: \ alpha \ rightarrow \ alpha [{ \ mathtt {Abs}}] (1) \\ 3: \ vdash _ {D} \ lambda xx: \ forall \ alpha. \ Alpha \ rightarrow \ alpha [{\ mathtt {Gen}}] (2), \ (\ alpha \ not \ in free (\ epsilon)) \\ 4: id: \ forall \ alpha. \ alpha \ rightarrow \ alpha \ vdash _ {D} id: \ forall \ alpha. \ alpha \ rightarrow \ alpha [{\ mathtt {Var}}] (id: \ forall \ alpha. \ alpha \ rightarrow \ alpha \ in \ left \ {id: \ forall \ alpha. \ alpha \ rightarrow \ alpha. \ right \}) ​​\\ 5: \ vdash _ {D} {\ textbf {let}} \, id = \ lambda xx \ {\ textbf {in}} \ id \,: \, \ forall \ альфа. \ Alpha \ rightarrow \ alpha [{\ mathtt {Let}}] (3), \ (4) \\\ end {array}}}

{\ begin {array} {llll} 1: x: \ alpha \ vdash _ { D} x: \ alpha [{\ mathtt {Var}}] (x: \ alpha \ in \ left \ {x: \ alpha \ right \}) ​​\\ 2: \ vdash _ {D} \ lambda xx: \ alpha \ rightarrow \ alpha [{\ mathtt {Abs}}] (1) \\ 3: \ vdash _ {D} \ lambda xx: \ forall \ alpha. \ alpha \ rightarrow \ alpha [ {\ mathtt {Gen}}] (2), \ (\ alpha \ not \ in free (\ epsilon)) \\ 4: id: \ forall \ alpha. \ alpha \ rightarrow \ alpha \ vdash _ {D} id: \ forall \ alpha. \ alpha \ rightarrow \ alpha [{\ mathtt {Var}}] (id: \ forall \ alpha. \ alpha \ rightarrow \ alpha \ in \ left \ {id: \ forall \ al pha. \ alpha \ rightarrow \ alpha \ right \}) ​​\\ 5: \ vdash _ {D} {\ textbf {let}} \, id = \ lambda xx \ {\ textbf {in}} \ id \, : \, \ forall \ alpha. \ alpha \ rightarrow \ alpha [{\ mathtt {Let}}] (3), \ (4) \\\ end {array}}

Let-полиморфизм

Не виден сразу, набор правил кодирует правило согласно каким-либо обстоятельствам, слегка изменяя использование моно- и политипов в правилах $[A bs] {\ displaystyle [{\ mathtt {Abs}}]}$ $[{\ mathtt {Abs}}]$ и $[L et] {\ displaystyle [{\ mathtt {Let}}]}$ $[{\mathtt {Let}}]$ . Помните, что $σ {\ displaystyle \ sigma}$ $\ sigma$ и $τ {\ displaystyle \ tau}$ $\tau$ обозначают поли- и монотипы соответственно.

В правиле $[A b s] {\ displaystyle [{\ mathtt {Abs}}]}$ $[{\ mathtt {Abs}}]$ , переменные значения параметров функции $λ x. е {\ displaystyle \ lambda xe}$ $\ lambda xe$ добавляется в контекст с мономорфным типом через объем $Γ, x: τ ⊢ D e: τ ′ {\ displaystyle \ Gamma, \ x: \ тау \ vdash _ {D} e: \ tau '}$ $\Gamma,\ x:\tau \vdash _{D}e:\tau '$ , а в правиле $[L et] {\ displaystyle [{\ mathtt {Let}}]}$ $[{\mathtt {Let}}]$ , переменная входит в среду ворф полимерной формы $Γ, x: σ ⊢ D e 1: τ {\ displaystyle \ Gamma, \ x: \ sigma \ vdash _ {D} e_ {1}: \ tau}$ $\Gam ma,\ x:\sigma \vdash _{D}e_{1}:\tau$ . Хотя в обоих случаях наличие $x {\ displaystyle x}$ $x$ в любом случае исключает использование правил обобщения для альтернативного назначения, это правило позволяет использовать тип параметра $x {\ displaystyle x}$ $x$ в $λ {\ displaystyle \ lambda}$ $\ lambda$ -выражение, чтобы оставаться мономорфным, в то время как в let-выражении переменная может быть представлена полиморфной, возможными специализации.

Вследствие этого правила $λ f. (е верно, е 0) {\ displaystyle \ lambda f. (f \, {\ textrm {true}}, f \, {\ textrm {0}})}$ $\lambda f.(f\,{\textrm {true}},f\,{\textrm {0}})$ нельзя достичь, так как параметр $f {\ displaystyle f}$ $f$ находится в мономорфной позиции, а $пусть f = λ x. Икс в (е истинно, е 0) {\ displaystyle {\ textbf {let}} \ f = \ lambda xx \, {\ textbf {in}} \, (f \, {\ textrm {true}}, f \, {\ textrm {0}})}$ ${\ textbf {let} } \ f = \ lambda xx \, {\ textbf {in}} \, (f \, {\ textrm {true}}, f \, {\ textrm {0}})$ имеет тип $(bool, int) {\ displaystyle (bool, int)}$ $(bool,int)$ , потому что $f {\ displaystyle f}$ $f$ был введен в let-выражение и поэтому считается полиморфным.

Правило обобщения

Правило обобщения также заслуживает внимательного изучения. Здесь полная количественная оценка, заложенная в посылке $Γ ⊢ e: σ {\ displaystyle \ Gamma \ vdash e: \ sigma}$ ${\ displaystyle \ Gamma \ vdash e: \ sigma}$ , просто перемещается в правую часть $⊢ D {\ displaystyle \ vdash _ {D}}$ $\vdash _{D}$ в заключении. Это возможно, поскольку $α {\ displaystyle \ alpha}$ $\alpha$ не встречается в контексте свободно. Опять же, хотя это делает правило обобщения правдоподобным, на самом деле это не следствие. Напротив, правило обобщения является частью определения системы типов HM и следствием неявной общей количественной оценки.

Алгоритм вывода

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

Степени свободы выбора правил

Изоляция точек в доказательстве, когда решение вообще невозможно, первая группа правил, сосредоточенная вокруг синтаксиса, не оставляет выбора, поскольку для каждого синтаксического правила соответствует уникальному правилу типизации, которое определяет часть доказательства, а между выводом и предпосылками этих фиксированных частей цепочки $[I nst] {\ displaystyle [{\ mathtt {Inst}}]}$ $[{\ mathtt {Inst}}]$ и $[G en] {\ displaystyle [{\ mathtt {Gen}}]}$ $[{\ mathtt {Gen}}]$ могли возникнуть. Такая цепочка также могла существовать между завершением доказательства и правилом для наивысшего выражения. Все доказательства должны иметь такую набросанную форму.

Поскольку единственный выбор в доказательстве в отношении выбора правила - это $[I nst] {\ displaystyle [{\ mathtt {Inst}}]}$ $[{\ mathtt {Inst}}]$ и $[G en] {\ displaystyle [{\ mathtt {Gen}}]}$ $[{\ mathtt {Gen}}]$ цепочки, форма доказательства наводит на вопрос, можно ли сделать его более точным, где эти цепочки могут понадобиться. На самом деле это возможно и приводит к варианту системы правил без таких правил.

Система правил, ориентированная на синтаксис

Система синтаксических правил

x: σ ∈ Γ σ ⊑ τ Γ ⊢ S x: τ [V ar] Γ ⊢ S e 0: τ → τ ′ Γ ⊢ S e 1: τ Γ ⊢ S e 0 e 1: τ ′ [A pp] Γ, x: τ ⊢ S e: τ ′ Γ ⊢ S λ x. e: τ → τ ′ [A bs] Γ ⊢ S e 0: τ Γ, x: Γ ¯ (τ) ⊢ S e 1: τ ′ Γ ⊢ S letx = e 0 ine 1: τ ′ [L et] { \ Displaystyle {\ begin {array} {cl} \ displaystyle {\ frac {x: \ sigma \ in \ Gamma \ quad \ sigma \ sqsubseteq \ tau} {\ Gamma \ vdash _ {S} x: \ tau}} [{\ mathtt {Var}}] \\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {S} e_ {0}: \ tau \ rightarrow \ tau '\ quad \ quad \ Gamma \ vdash _ {S } e_ {1}: \ tau} {\ Gamma \ vdash _ {S} e_ {0} \ e_ {1}: \ tau '}} [{\ mathtt {App}}] \\\\\ displaystyle { \ frac {\ Gamma, \; x: \ tau \ vdash _ {S} e: \ tau '} {\ Gamma \ vdash _ {S} \ lambda \ x \. \ e: \ tau \ rightarrow \ tau'} } [{\ mathtt {Abs}}] \\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {S} e_ {0}: \ tau \ quad \ quad \ Gamma, \, x: {\ bar {\ Gamma}} (\ tau) \ vdash _ {S} e_ {1}: \ tau '} {\ Gamma \ vdash _ {S} {\ mathtt {let}} \ x = e_ {0} \ {\ mathtt {in}} \ e_ {1}: \ tau '}} [{\ mathtt {Let}}] \ end {array}}}

{\begin{array}{cl}\displaystyle {\frac {x:\sigma \in \Gamma \quad \sigma \sqsubseteq \tau }{\Gamma \vdash _{S}x:\tau }}[{\mathtt {Var}}]\\\\\displaystyle {\frac {\Gamma \vdash _{S}e_{0}:\tau \rightarrow \tau '\quad \quad \Gamma \vdash _{S}e_{1}:\tau }{\Gamma \vdash _{S}e_{0}\ e_{1}:\tau '}}[{\mathtt {App}}]\\\\\displaystyle {\frac {\Gamma,\;x:\tau \vdash _{S}e:\tau '}{\Gamma \vdash _{S}\lambda \ x\.\ e:\tau \rightarrow \tau '}}[{\mathtt {Abs}}]\\\\\displaystyle {\frac {\Gamma \vdash _{S}e_{0}:\tau \quad \quad \Gamma,\,x:{\bar {\Gamma }}(\tau)\vdash _{S}e_{1}:\tau '}{\Gamma \vdash _{S}{\mathtt {let}}\ x=e_{0}\ {\mathtt {in}}\ e_{1}:\tau '}}[{\mathtt {Let}}]\end{array}}

Обобщение

Γ ¯ (τ) = ∀ α ^. τ α ^ = бесплатно (τ) - бесплатно (Γ) {\ displaystyle {\ bar {\ Gamma}} (\ tau) = \ forall \ {\ hat {\ alpha}} \. \ \ tau \ quad \ quad {\ hat {\ alpha}} = {\ textrm {free}} (\ tau) - {\ textrm {free}} (\ Gamma)}

{\ bar {\ Gamma}} (\ tau) = \ forall \ {\ hat {\ alpha}} \. \ \ tau \ quad \ quad {\ hat {\ alpha}} = {\ textrm {free}} (\ tau) - {\ textrm {free}} (\ Gamma)

Современное лечение HM использует чисто систему правил, созданный Клиентом как промежуточный этап. В этой системе специализация используется сразу после исходных правил $[V ar] {\ displaystyle [{\ mathtt {Var}}]}$ $[{\ mathtt {Var }}]$ и объединяется с ним, а обобщение становится правилом $[L et] {\ displaystyle [{\ mathtt {Let}}]}$ $[{\mathtt {Let}}]$ . Здесь также определяется обобщение, чтобы всегда производить наиболее общий тип путем введения функции $Γ ¯ (τ) {\ displaystyle {\ bar {\ Gamma}} (\ tau)}$ ${\ bar {\ Gamma}} (\ тау)$ , которая количественно определяет все переменные монотипа не связаны в $Γ {\ displaystyle \ Gamma}$ $\ Gamma$ .

Формально для подтверждения того, что эта новая система правил $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ эквивалентно исходному $⊢ D {\ displaystyle \ vdash _ {D}}$ $\vdash _{D}$ , нужно показать, что $Γ ⊢ D e: σ ⇔ Γ ⊢ S e: σ {\ displaystyle \ Gamma \ vdash _ {D} \ e: \ sigma \ Leftrightarrow \ Gamma \ vdash _ {S} \ e: \ sigma}$ $\Gamma \vdash _{D}\ e:\sigma \Leftrightarrow \Gamma \vdash _{S}\ e:\sigma$ , который распадается на два доказательства:

$Γ ⊢ D е: σ ⇐ Γ ⊢ S e: σ {\ displaystyle \ Gamma \ vdash _ {D} \ e: \ sigma \ Leftarrow \ Gamma \ vdash _ {S} \ e: \ sigma}$ $\ Gamma \ vdash _ {D} \ e: \ sigma \ Leftarrow \ Gamma \ vdash _ {S} \ e: \ sigma$ (Согласованность )
$Γ ⊢ D e: σ ⇒ Γ ⊢ S e: σ {\ displaystyle \ Gamma \ vdash _ {D} \ e: \ sigma \ Rightarrow \ Gamma \ vdash _ {S} \ e: \ sigma}$ $\ Gamma \ vdash _ { D} \ e: \ sigma \ Rightarrow \ Gamma \ vdash _ {S} \ e: \ sigma$ (Полнота )

Хотя согласованность можно увидеть, разложив прав ила $[L et] {\ displaystyle [{\ mathtt {Let}}]}$ $[{\mathtt {Let}}]$ и $[V ar] {\ displaystyle [{\ mathtt {Var}}]}$ $[{\ mathtt {Var }}]$ из $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ в доказательств в $⊢ D {\ displaystyle \ vdash _ {D}}$ $\vdash _{D}$ вероятно, видно, что $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ является неполным, так как нельзя показать $λ x. х: ∀ α. α → α {\ Displaystyle \ лямбда \ хх: \ forall \ альфа. \ alpha \ rightarrow \ alpha}$ $\ lambda \ xx: \ forall \ alpha. \ alpha \ rightarrow \ alpha$ в $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ , например, но только $λ x. Икс: α → α {\ Displaystyle \ лямбда \ x.x: \ alpha \ rightarrow \ alpha}$ $\lambda \ x.x:\alpha \rightarrow \alpha$ . Тем не менее, можно доказать лишь немного более слабую версию полноты, а именно

$Γ ⊢ D e: σ ⇒ Γ ⊢ S e: τ ∧ Γ ¯ (τ) ⊑ σ {\ displaystyle \ Gamma \ vdash _ {D} \ e: \ sigma \ Rightarrow \ Gamma \ vdash _ {S} \ e: \ tau \ wedge {\ bar {\ Gamma}} (\ tau) \ sqsubseteq \ sigma}$ $\ Gamma \ vdash _ {D} \ e: \ sigma \ Rightarrow \ Gamma \ vdash _ {S} \ e: \ tau \ клин {\ bar {\ Gamma}} (\ tau) \ sqsubseteq \ sigma$

подразумевая, что можно вывести основной тип для выражения в $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ , что позволяет нам обобщить доказательство в конце.

Сравнение $⊢ D {\ displaystyle \ vdash _ {D}}$ $\vdash _{D}$ и $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ , теперь в суждениях всех правил фигурируют только монотипии. Кроме того, форма любого возможного примера с помощью системы дедукции новая форма выражения (оба они представлены как деревья ). Таким образом, выражение должно указать форму доказательства. В $⊢ D {\ displaystyle \ vdash _ {D}}$ $\vdash _{D}$ форма, вероятно, будет определяться с соблюдением всех правил, кроме $[I nst] {\ displaystyle [{\ mathtt {Inst }}]}$ $[{\ mathtt {Inst}}]$ и $[G en] {\ displaystyle [{\ mathtt {Gen}}]}$ $[{\ mathtt {Gen}}]$ , которые позволяют строить произвольно длинные ответвления (цепочки) между другими узлами.

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

Теперь, когда форма доказательства известна, мы уже близки к формулированию алгоритма вывода типов. Испытание на качество.

Здесь играет роль порядок за ущерб (специализации). Хотя на первый взгляд невозможно определить метод определения, есть надежда, что их можно уточнить с помощью порядка при обходе дерева доказательства, как предполагаемый алгоритм должен стать методом вывода, что в любом помещении будет определен как лучший. И действительно, можно, если посмотреть на правила $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ , подсказывает:

$[A bs] {\ displaystyle [Abs]}$ $[Abs]$ : критический выбор - $τ {\ displaystyle \ tau}$ $\tau$ . На данный момент ничего не известно о $τ {\ displaystyle \ tau}$ $\tau$ , поэтому можно предположить только самый общий тип, который является $∀ α. α {\ Displaystyle \ forall \ alpha. \ alpha}$ ${\ displaystyle \ forall \ alpha. \ alpha}$ . План состоит в том, чтобы специфицировать тип, если в этом возникнет необходимость. К сожалению, политип в этом месте не разрешен, поэтому на данный момент нужно использовать $α {\ displaystyle \ alpha}$ $\alpha$ . Чтобы избежать нежелательных захватов, безопасным выбором переменная типа, еще не прошедшая проверка. Кроме того, следует иметь в виду, что эта монотипия еще не исправлена, но может быть дополнительно уточнена.
$[V ar] {\ displaystyle [Var]}$ $[Var]$ : выбор заключается в том, как уточнить $σ {\ displaystyle \ sigma}$ $\ sigma$ . Любой выбор типа $τ {\ displaystyle \ tau}$ $\tau$ здесь зависит от использования, которая не известна локально, самая безопасная ставка - самая общая. Используя тот же метод, что и выше, можно создать экземпляры всех количественных чисел в $σ {\ displaystyle \ sigma}$ $\ sigma$ с новыми переменными монотипии, снова оставляя их открытыми для дальнейшего уточнения.
$[L et] {\ displaystyle [Let]}$ $[Let]$ : правило не оставляет никакого выбора. Готово.
$[A pp] {\ displaystyle [App]}$ ${\ displaystyle [App]}$ : только правило приложения может вызвать уточнение чис, «открытое» на данный момент.

Первый формирующий результат вывод должен иметь форму $τ → τ ′ {\ displaystyle \ tau \ rightarrow \ tau '}$ $\tau \rightarrow \tau '$ .

Если это так, то хорошо. Позже можно будет выбрать его $τ ′ {\ displaystyle \ tau '}$ $\tau '$ для результата.
Если нет, то это может быть открытая переменная. Затем это может быть уточнено до требуемой формы с помощью двух новых чисел, как и раньше.
В противном случае проверка типа завершится неудачно, поскольку первая посылка выявила тип, который не может быть преобразован в тип функции.

Вторая система требует, чтобы предполагаемый тип был равенством $τ {\ displaystyle \ tau}$ $\tau$ первого предпосылки. Теперь есть два, возможно, разных типов, возможно, с переменными открытого типа, которые можно сравнивать и приравнивать, если это возможно. Если это так, уточнение найдено, а если нет, типа обнаруживается снова. Известен эффективный метод «уравнять два члена» путем подстановки, Робинсона Объединение в сочетании с так называемым алгоритмом Union-Find.

Вкратце резюмируя алгоритм поиска объединения, он позволяет сгруппировать их вместе в классы эквивалентности посредством $объединения {\ displaystyle {\ mathtt {union}}}$ ${\mathtt {union}}$ и выбрать представителя для каждого такого класса с помощью процедуры $find {\ displaystyle {\ mathtt {find}}}$ ${\ mathtt {find}}$ . Подчеркивая слово процедура в смысле побочного эффекта, мы явно выходим из области логики, чтобы подготовить эффективный алгоритм. Представитель объединения $(a, b) {\ displaystyle {\ mathtt {union}} (a, b)}$ ${\ mathtt {union}} (a, b)$ таким образом, что если оба $a {\ displaystyle a}$ $a$ и $b {\ displaystyle b}$ $б$ являются переменными типами, тогда представитель произвольно является одним из них, но при объединении и члене становится представителем. Предполагая создание-поиск под рукой, можно сформулировать два монотипов следующим образом:

unify (ta, tb): ta = find (ta) tb = find (tb) if оба ta, tb являются формами D p1..pn с идентичными D, n, затем unify (ta [i], tb [i]) для каждого i-го редакции else ifхотя бы один из ta, tb - это переменная типа, затем union (ta, tb) else тип ошибок совпадают »

Теперь есть набросок имеющегося алгоритма вывода, более формальное представление дается в следующем разделе. Это описано в Milner P. 370 ff. как алгоритм J.

Алгоритм J

x: σ ∈ Γ τ = inst (σ) Γ ⊢ J x: τ [V ar] Γ ⊢ J e 0: τ 0 Γ ⊢ J e 1: τ 1 τ ′ = newvarunify (τ 0, τ 1 → τ ′) Γ ⊢ J e 0 e 1: τ ′ [A pp] τ = newvar Γ, x: τ ⊢ J e: τ ′ Γ ⊢ J λ x. e: τ → τ ′ [A bs] Γ ⊢ J e 0: τ Γ, x: Γ ¯ (τ) ⊢ J e 1: τ ′ Γ ⊢ J letx = e 0 ine 1: τ ′ [L et] { \ Displaystyle {\ begin {array} {cl} \ displaystyle {\ frac {x: \ sigma \ in \ Gamma \ quad \ tau = {\ mathit {inst}} (\ sigma)} {\ Gamma \ vdash _ {J } x: \ tau}} [{\ mathtt {Var}}] \\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {J} e_ {0}: \ tau _ {0} \ quad \ Gamma \ vdash _ {J} e_ {1}: \ tau _ {1} \ quad \ tau '= {\ mathit {newvar}} \ quad {\ mathit {unify}} (\ tau _ {0}, \ \ tau _ {1} \ rightarrow \ tau ')} {\ Gamma \ vdash _ {J} e_ {0} \ e_ {1}: \ tau'}} [{\ mathtt {App}}] \\\\\ displaystyle {\ frac {\ tau = {\ mathit {newvar}} \ quad \ Gamma, \; x: \ tau \ vdash _ {J} e: \ tau '} {\ Gamma \ vdash _ {J} \ lambda \ х \. \ е: \ тау \ rightarrow \ тау '}} и [{\ mathtt {Abs}}] \\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {J} e_ {0}: \ tau \ quad \ quad \ Gamma, \, x: {\ bar {\ Gamma}} (\ tau) \ vdash _ {J} e_ {1}: \ tau '} {\ Gamma \ vdash _ {J} {\ mathtt {let} } \ x = e_ {0} \ {\ mathtt {in}} \ e_ {1}: \ tau '}} [{\ mathtt {Let}}] \ end {array}}}

{\begin{array}{cl}\displaystyle {\frac {x:\sigma \in \Gamma \quad \tau ={\mathit {inst}}(\sigma)}{\Gamma \vdash _{J}x:\tau }}[{\mathtt {Var}}]\\\\\displaystyle {\frac {\Gamma \vdash _{J}e_{0}:\tau _{0}\quad \Gamma \vdash _{J}e_{1}:\tau _{1}\quad \tau '={\mathit {newvar}}\quad {\mathit {unify}}(\tau _{0},\ \tau _{1}\rightarrow \tau ')}{\Gamma \vdash _{J}e_{0}\ e_{1}:\tau '}}[{\mathtt {App}}]\\\\\displaystyle {\frac {\tau ={\mathit {newvar}}\quad \Gamma,\;x:\tau \vdash _{J}e:\tau '}{\Gamma \vdash _{J}\lambda \ x\.\ e:\tau \rightarrow \tau '}}[{\mathtt {Abs}}]\\\\\displaystyle {\frac {\Gamma \vdash _{J}e_{0}:\tau \quad \quad \Gamma,\,x:{\bar {\Gamma }}(\tau)\vdash _{J}e_{1}:\tau '}{\Gamma \vdash _{J}{\mathtt {let}}\ x=e_{0}\ {\mathtt {in}}\ e_{1}:\tau '}}[{\mathtt {Let}}]\end{array}}

Представление алгоритма J Неправильное использование обозначения логического, поскольку он включает побочные эффекты, но позволяет прямое сравнение с $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ , одновременно выражая эффективную работу. Теперь правила определяют ограниченность $Γ, e {\ displaystyle \ Gamma, e}$ $\ Gamma, e$ , что дает $τ {\ displaystyle \ tau}$ $\tau$ в заключении, где оформление помещения происходит слева направо.

Процедура $inst (σ) {\ displaystyle inst (\ sigma)}$ $inst ( \ sigma)$ специализируется на политипе $σ {\ displaystyle \ sigma}$ $\ sigma$ на копирование термина и последовательная замена связанного типа новыми переменными монотипии. ' $n e w v a r {\ displaystyle newvar}$ $newvar$ ' создает новую переменную монотипии. Вероятно, $Γ ¯ (τ) {\ displaystyle {\ bar {\ Gamma}} (\ tau)}$ ${\ bar {\ Gamma}} (\ тау)$ должен скопировать тип, вводящий новые переменные для количественной оценки, чтобы избежать нежелательных захватов. В целом алгоритм теперь всегда делает наиболее общий выбор, оставляя специализацию для унификации, которая сама по себе дает наиболее общий результат. Как отмечалось выше, окончательный результат $τ {\ displaystyle \ tau}$ $\tau$ должен быть обобщен до $Γ ¯ (τ) {\ displaystyle {\ bar {\ Gamma} } (\ tau)}$ ${\ bar {\ Gamma}} (\ тау)$ в конце, чтобы получить наиболее общий тип для данного выражения.

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

Эффективность несколько снижается, необходимо поддерживать привязку типа в контексте, чтобы можно было вычислить $Γ ¯ (τ) {\ displaystyle {\ bar {\ Gamma}} (\ tau)}$ ${\ bar {\ Gamma}} (\ тау)$ и включите , проверьте, чтобы предотвратить создание рекурсивных типов $union (α, τ) {\ displaystyle union (\ alpha, \ tau)}$ $union(\alpha,\tau)$ . Примером такого случая является $λ x. (Икс Икс) {\ Displaystyle \ лямбда \ х. (x \ x)}$ $\lambda \ x.(x\ x)$ , для которого ни один тип не может быть получен с помощью HM. На практике это небольшие сроки и не расширяющиеся структуры. Таким образом, при анализе сложности их можно рассматривать как постоянные, сохраняя затраты O (1).

Доказательство алгоритма

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

Наиболее важным моментом в приведенной выше аргументации является уточнение числа монотипа, связанного связом. Например, алгоритм смело изменяет контекст при выводе, например, $λ ф. (е 1) {\ Displaystyle \ лямбда ф. (f \ 1)}$ $\lambda f.(f\ 1)$ , потому что переменная монотипия добавлена в контекст для параметра $f {\ displaystyle f}$ $f$ позже необходимо улучшить до $int → β { \ displaystyle int \ rightarrow \ beta}$ $int\rightarrow \beta$ при работе с приложением. Проблема в том, что правила дедукции не допускают такого уточнения. Утверждение, что уточненный тип может быть добавлен раньше вместо альтернативного монотипа.

Ключом к достижению формально удовлетворительного аргумента является правильное включение контекста в уточнение. Формально типизация с заменой произвольного типа.

Γ ⊢ S e: τ ⟹ S Γ ⊢ S e: S τ {\ displaystyle \ Gamma \ vdash _ {S} e: \ tau \ quad \ Longrightarrow \ quad S \ Gamma \ vdash _ {S} e: S \ tau}

{\ displaystyle \ Gamma \ vdash _ {S} e: \ tau \ quad \ Longrightarrow \ quad S \ Gamma \ vdash _ {S} e: S \ tau}

Таким образом уточнить свободные переменные означает уточнить всю типизацию.

Алгоритм W

x: σ ∈ Γ τ = inst (σ) Γ ⊢ W x: τ, ∅ [V ar] Γ ⊢ W e 0: τ 0, S 0 S 0 Γ ⊢ W e 1: τ 1, S 1 τ ′ = newvar S 2 = mgu (S 1 τ 0, τ 1 → τ ′) Γ ⊢ W e 0 e 1: S 2 τ ′, S 2 S 1 S 0 [A pp] τ = newvar Γ, x: τ ⊢ W e: τ ′, S Γ ⊢ W λ x. e: S τ → τ ′, S [A bs] Γ ⊢ W e 0: τ, S 0 S 0 Γ, x: S 0 Γ ¯ (τ) ⊢ W e 1: τ ′, S 1 Γ ⊢ W letx знак равно е 0 ine 1: τ ', S 1 S 0 [L et] {\ displaystyle {\ begin {array} {cl} \ displaystyle {\ frac {x: \ sigma \ in \ Gamma \ quad \ tau = { \ mathit {inst}} (\ sigma)} {\ Gamma \ vdash _ {W} x: \ tau, \ emptyset}} [{\ mathtt {Var}}] \\\\\ displaystyle {\ frac {\ begin {array} {ll} \ Gamma \ vdash _ {W} e_ {0}: \ tau _ {0}, S_ {0} S_ {0} \ Gamma \ vdash _ {W} e_ {1}: \ tau _ {1}, S_ {1} \\\ tau '= {\ mathit {newvar}} S_ {2} = {\ mathsf {mgu}} (S_ {1} \ tau _ {0}, \ \ tau _ {1} \ rightarrow \ tau ') \ end {array}} {\ Gamma \ vdash _ {W} e_ {0} \ e_ {1}: S_ {2} \ tau', S_ {2} S_ { 1} S_ {0}}} [{\ mathtt {App}}] \\\\\ displaystyle {\ frac {\ tau = {\ mathit {newvar}} \ quad \ Gamma, \; x: \ tau \ vdash _ {W} e: \ tau ', S} {\ Gamma \ vdash _ {W} \ lambda \ x \. \ E: S \ tau \ rightarrow \ tau ', S}} и [{\ mathtt {Abs}}] \\\\\ displaystyle {\ frac {\ Gamma \ vdash _ {W} e_ {0}: \ tau, S_ {0} \ quad S_ {0} \ Gamma, \, x: {\ overline {S_ {0}} \ Gamma}} (\ tau) \ vdash _ {W} e_ {1}: \ tau ', S_ {1}} {\ Gamma \ vdash _ {W} {\ mathtt {let}} \ x = e_ {0} \ {\ mathtt {in}} \ e_ {1}: \ tau ', S_ {1} S_ {0}}} [{\ mathtt {Let}}] \ end {array}}}

{\begin{array}{cl}\displaystyle {\frac {x:\sigma \in \Gamma \quad \tau ={\mathit {inst}}(\sigma)}{\Gamma \vdash _{W}x:\tau,\emptyset }}[{\mathtt {Var}}]\\\\\displaystyle {\frac {\begin{array}{ll}\Gamma \vdash _{W}e_{0}:\tau _{0},S_{0}S_{0}\Gamma \vdash _{W}e_{1}:\tau _{1},S_{1}\\\tau '={\mathit {newvar}}S_{2}={\mathsf {mgu}}(S_{1}\tau _{0},\ \tau _{1}\rightarrow \tau ')\end{array}}{\Gamma \vdash _{W}e_{0}\ e_{1}:S_{2}\tau ',S_{2}S_{1}S_{0}}}[{\mathtt {App}}]\\\\\displaystyle {\frac {\tau ={\mathit {newvar}}\quad \Gamma,\;x:\tau \vdash _{W}e:\tau ',S}{\Gamma \vdash _{W}\lambda \ x\.\ e:S\tau \rightarrow \tau ',S}}[{\mathtt {Abs}}]\\\\\displaystyle {\frac {\Gamma \vdash _{W}e_{0}:\tau,S_{0}\quad S_{0}\Gamma,\,x:{\overline {S_{0}\Gamma }}(\tau)\vdash _{W}e_{1}:\tau ',S_{1}}{\Gamma \vdash _{W}{\mathtt {let}}\ x=e_{0}\ {\mathtt {in}}\ e_{1}:\tau ',S_{1}S_{0}}}[{\mathtt {Let}}]\end{array}}

Оттуда, доказательство алгоритма J приводит к алгоритму W, который только делает явными побочными эффектами, налагаемые процедуры $union { \ displaystyle {\ textit {union}}}$ ${\ displaystyle {\ textit {union}}}$ , выражая его последовательную композицию с помощью замены $S i {\ displaystyle S_ {i}}$ $S_ {i}$ . Представление алгоритма W на боковой панели по-прежнему использует побочные эффекты в операциях, выделенных курсивом, но теперь они ограничиваются генерацией новых символов. Форма суждения: $Γ ⊢ e: τ, S {\ displaystyle \ Gamma \ vdash e: \ tau, S}$ ${\ displaystyle \ Gamma \ vdash e: \ tau, S}$ , обозначающая функция с контекстом и выражением в качестве исполняющего монотипию. с заменой. $mgu {\ displaystyle {\ textf {mgu}}}$ ${\ displaystyle {\textf {mgu}}}$ - это версия $union {\ displaystyle {\ textit {union}}}$ ${\ displaystyle {\ textit {union}}}$ без побочных эффектов создание подстановки, которая является наиболее общим объединяющим элементом.

, алгоритм W обычно считается алгоритмом HM и часто используется его литература непосредственно после системы правил, его описана Милнером на стр. 369 следующим образом. :

В нынешнем виде W вряд ли эффективным алгоритмом; замены применяются слишком часто. Он был разработан, чтобы помочь в доказательстве надежности. Теперь мы представляем более простой алгоритм J, который имитирует W в точном смысле.

Хотя он считал более сложным и менее эффективным, он представил его в своей публикации перед J. Он имеет свои достоинства, когда побочные эффекты недоступны или нежелательны. Кстати, W также нужен для доказательства полноты, которая учитывается им при доказательстве корректности.

Обязательства по доказательству

Прежде чем указать обязательство по доказательству, необходимо указать расхождение между системами правил D и S и представленными алгоритмами.

В то время, как описанная выше разработка неправильно использовала монотипии как «открытые» переменные доказательства, возможность того, что правильные переменные монотипа могли быть повреждены, была устранена введением новых чисел и надеждой на лучшее. Но есть одна загвоздка: одно из обещаний заключалось в том, что эти новые переменные будут «учитываться» как таковые. Это обещание не действует.

Имея контекст $1: int, f: α {\ displaystyle 1: int, \ f: \ alpha}$ ${\ displaystyle 1: int, \ f : \ alpha}$ , выражение $f 1 {\ displaystyle f \ 1 }$ $f\ 1$ нельзя ни добиться в $⊢ D {\ displaystyle \ vdash _ {D}}$ $\vdash _{D}$ , и в $⊢ S {\ displaystyle \ vdash _ {S}. }$ $\vdash _{S}$ , но алгоритмы имеют тип $β {\ displaystyle \ beta}$ $\ beta$ , где W изменяет замену ${α ↦ int → β} {\ displaystyle \ left \ {\ alpha \ mapsto int \ rightarrow \ beta \ right \}}$ ${\ displaystyle \ left \ {\ alpha \ mapsto int \ rightarrow \ beta \ right \}}$ , что означает, что алгоритм не может быть всех ошибок типов. Это упущение может быть легко исправлено более тщательным различением доказательства и числа монотипии.

Авторы знали о проблеме, но решили не исправлять. Можно предположить, что за этим стоит прагматическая причина. Несмотря на то, что они не были необходимы для предполагаемых приложений, они не были необходимы для предполагаемых приложений, где ни один из элементов в уже существующем контексте не имеет размер. В этом свете ненужное усложнение было отброшено в пользу более простого алгоритма. Остающийся недостаток заключается в том, что доказательство алгоритма относительно системы правил менее общего и может быть выполнено только для контекстов с $free (Γ) = ∅ {\ displaystyle free (\ Gamma) = \ emptyset}$ $free(\Gamma)=\emptyset$ как побочное условие.

$(Правильность) Γ | - W e: τ, S ⟹ Γ ⊢ S e: τ (Полнота) Γ | - S e: τ ⟹ Γ ⊢ W e: τ ′, S для всех τ, где ∅ ¯ (τ ′) ⊑ τ {\ displaystyle {\ begin {array} {lll} {\ text {(Correctness)}} \ Гамма | -_ {W} e: \ tau, S \ quad \ Longrightarrow \ quad \ Gamma \ vdash _ {S} e: \ tau \\ {\ text {(Полнота)}} \ Gamma | -_ {S} e: \ tau \ quad \ Longrightarrow \ quad \ Gamma \ vdash _ {W} e: \ tau ', S \ quad \ quad {\ text {forall}} \ \ tau \ {\ text { где}} \ {\ overline {\ emptyset}} (\ tau ') \ sqsubseteq \ tau \ end {array}}}$ ${\begin{array}{lll}{\text{(Correctness)}}\Gamma |-_{W}e:\tau,S\quad \Longrightarrow \quad \Gamma \vdash _{S}e:\tau \\{\text{(Completeness)}}\Gamma |-_{S}e:\tau \quad \Longrightarrow \quad \Gamma \vdash _{W}e:\tau ',S\quad \quad {\text{forall}}\ \tau \ {\text{where}}\ {\overline {\emptyset }}(\tau ')\sqsubseteq \tau \end{array}}$

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

Чтобы правильно доказать обязательства, нужно сначала усилить их, чтобы активировать лемму о подстановке, распределяющую замену $S {\ displaystyle S}$ $S$ через $⊢ S {\ displaystyle \ vdash _ {S}}$ $\vdash _{S}$ и $⊢ W {\ displaystyle \ vdash _ {W}}$ ${\ displaystyle \ vdash _ {W}}$ . Отсюда презентация индукции по выражению.

Еще одно обязательство по доказательству - это сама лемма о замене, то есть замена типизации, которая, в конце концов, устанавливает все-количественное определение. Последнее невозможно формально доказать, так как такого синтаксиса нет.

Расширения

Рекурсивные определения

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

Правило ввода

Исходная статья показывает, что рекурсия может быть реализована с помощью комбинатора $f i x: ∀ α. (α → α) → α {\ Displaystyle {\ mathit {fix}}: \ forall \ alpha. (\ alpha \ rightarrow \ alpha) \ rightarrow \ alpha}$ ${\ mathit {fix}}: \ forall \ alpha. (\ alpha \ rightarrow \ alpha) \ rightarrow \ alpha$ . Таким образом, возможное рекурсивное определение может быть сформулировано как $recv = e 1 ine 2 :: = letv = fix (λ v. E 1) ine 2 {\ displaystyle {\ mathtt {rec}} \ v = e_ {1} \ {\ mathtt {in}} \ e_ {2} \ :: = {\ mathtt {let}} \ v = {\ mathit {fix}} (\ lambda v.e_ {1}) \ {\ mathtt {in }} \ e_ {2}}$ ${\mathtt {rec}}\ v=e_{1}\ {\mathtt {in}}\ e_{2}\ ::={\mathtt {let}}\ v={\mathit {fix}}(\lambda v.e_{1})\ {\mathtt {in}}\ e_{2}$ .

В качестве альтернативы возможно расширение синтаксиса выражения и дополнительное правило ввода:

Γ, Γ ′ ⊢ e 1: τ 1… Γ, Γ ′ ⊢ en: τ n Γ, Γ ″ ⊢ е: τ Γ ⊢ recv 1 = e 1 и… и vn = enine: τ [R ec] {\ displaystyle \ displaystyle {\ frac {\ Gamma, \ Gamma '\ vdash e_ {1}: \ tau _ {1} \ quad \ dots \ quad \ Gamma, \ Gamma '\ vdash e_ {n}: \ tau _ {n} \ quad \ Gamma, \ Gamma' '\ vdash e: \ tau} {\ Gamma \ \ vdash \ {\ mathtt {rec}} \ v_ {1} = e_ {1} \ {\ mathtt {and}} \ dots \ {\ mathtt {and}} \ v_ {n} = e_ {n} \ {\ mathtt {in}} \ e: \ tau}} \ quad [{\ mathtt {Rec}}]}

\displaystyle {\frac {\Gamma,\Gamma '\vdash e_{1}:\tau _{1}\quad \dots \quad \Gamma,\Gamma '\vdash e_{n}:\tau _{n}\quad \Gamma,\Gamma ''\vdash e:\tau }{\Gamma \ \vdash \ {\mathtt {rec}}\ v_{1}=e_{1}\ {\mathtt {and}}\ \dots \ {\mathtt {and}}\ v_{n}=e_{n}\ {\mathtt {in}}\ e:\tau }}\quad [{\mathtt {Rec}}]

где

$Γ ′ = v 1: τ 1,…, vn: τ n {\ displaystyle \ Гамма '= v_ {1}: \ tau _ {1}, \ \ dots, \ v_ {n}: \ tau _ {n}}$ $\Gamma '=v_{1}:\tau _{1},\ \dots,\ v_{n}:\tau _{n}$
$Γ ″ = v 1: Γ ¯ (τ 1),…, vn: Γ ¯ (τ N) {\ Displaystyle \ Gamma '' = v_ {1}: {\ bar {\ Gamma}} (\ \ tau _ {1} \), \ \ dots, \ v_ {n}: {\ bar {\ Gamma}} (\ \ tau _ {n} \)}$ $\Gamma ''=v_{1}:{\bar {\Gamma }}(\ \tau _{1}\),\ \dots,\ v_{n}:{\bar {\Gamma }}(\ \tau _{n}\)$

в основном слияние $[A bs] {\ displaystyle [{\ mathtt {Abs}}]}$ $[{\ mathtt {Abs}}]$ и $[L et] {\ displaystyle [{\ mathtt {Let}}]}$ $[{\mathtt {Let}}]$ при включении рекурсивно определенных переменных в монотипные позиции, где они встречаются слева от $в {\ displaystyle {\ mathtt {in}}}$ ${\ mathtt {in}}$ но как политипы справа от него. Эта формулировка, возможно, лучше всего резюмирует суть let-полиморфизма.

Последствия

Несмотря на то, что вышесказанное является простым, оно имеет свою цену.

Теория типов связывает лямбда-исчисление с вычислениями и логикой. Простая модификация, приведенная выше, влияет на оба:

свойство строгой нормализации недействительно, потому что могут быть сформулированы неограничивающие термины.
Логика сворачивается, потому что введите $∀ a. a {\ displaystyle \ forall a.a}$ $\forall aa$ становится обитаемым.

Перегрузка

Перегрузка означает, что разные функции по-прежнему могут определяться и использоваться с одним и тем же именем. Большинство языков программирования, по крайней мере, обеспечивают перегрузку с помощью встроенных арифметических операций (+, <,etc.), to allow the programmer to write arithmetic expressions in the same form, even for different numerical types like intили real. Поскольку смесь этих разных типов в одном выражении также требует неявного преобразования, перегрузка, особенно для этих операций, часто встроена в сам язык программирования. В некоторых языках эта функция обобщена и доступна пользователю, например, в C ++.

В то время как специальная перегрузка имеет В функциональном программировании избегали затрат на вычисления как при проверке типов, так и при логическом выводе, было введено средство систематизации перегрузки, которое по форме и именам напоминает объектно-ориентированное программирование, но работает на один уровень выше. "Экземпляры" в этой систематике не являются объекты (т.е. на уровне значений), а скорее типы. В примере быстрой сортировки, упомянутом во введении, используется перегрузка в заказах со следующей аннотацией типа в Haskell:

quickSort :: Ord a =>[a] ->[ a]

H erein, тип aне только полиморфен, но и ограничен как экземпляр некоторого класса типа Ord, который предоставляет предикаты порядка <и >=используется в теле функций. Соответствующие реализации этих предикатов затем передаются в quicksorts в качестве дополнительных параметров, как только быстрая сортировка используется для более конкретных типов, обеспечивая единственную реализацию перегруженной функции quickSort.

Поскольку «классы» допускают только один тип в качестве аргумента, результирующая система типов по-прежнему может обеспечивать вывод. Кроме того, классы типов могут быть оснащены неким порядком перегрузки, позволяющим упорядочить классы как решетку.

Мета-типы

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

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

В Haskell были введены части одного дополнительного уровня под названием kind, где они используются для ввода монад. Виды оставлены неявными, работая за кулисами во внутренней механике системы расширенных типов.

Подтипирование

Попытки объединить подтипирование и вывод типа вызвали некоторое разочарование. Хотя вывод типа необходим в объектно-ориентированном программировании по той же причине, что и в функциональных языках, такие методы, как HM, не могут использоваться для этой цели. Система типов с подтипами, обеспечивающая объектно-ориентированный стиль, например Карделли - его система $F <: {\displaystyle F_{<:}}$ ${\ displaystyle F _ {<:}}$ .

Эквивалентность типов может быть разбита на отношение подтипов «<:".
Правила дополнительных типов определяют это отношение, например, для функций.
Подходящий затем добавляется тип записи, значения которого представляют объекты.

Такие объекты будут неизменными в контексте функционального языка, но система типов позволит использовать объектно-ориентированный стиль программирования, и метод вывода типа может быть повторно использован в императивные языки.

Правило выделения подтипов для типов записей:

n ≤ m τ 1 <: τ 1 ′ … τ n <: τ n ′ Γ ⊢ R e c o r d v 1 : τ 1 … v n : τ n e n d <: R e c o r d v 1 : τ 1 ′ … v m : τ m ′ e n d [ R e c o r d ] {\displaystyle \displaystyle {\frac {n\leq m\quad \quad \tau _{1}<:\tau _{1}'\quad \dots \quad \tau _{n}<:\tau _{n}'}{\Gamma \ \vdash \ \mathbf {Record} \ v_{1}:\tau _{1}\ \dots \ v_{n}:\tau _{n}\ \mathbf {end} <:\mathbf {Record} \ v_{1}:\tau _{1}'\ \dots \ v_{m}:\tau _{m}'\ \mathbf {end} }}\quad [{\mathtt {Record}}]}

\displaystyle {\frac {n\leq m\quad \quad \tau _{1}<:\tau _{1}'\quad \dots \quad \tau _{n}<:\tau _{n}'}{\Gamma \ \vdash \ \mathbf {Record} \ v_{1}:\tau _{1}\ \dots \ v_{n}:\tau _{n}\ \mathbf {end} <:\mathbf {Record} \ v_{1}:\tau _{1}'\ \dots \ v_{m}:\tau _{m}'\ \mathbf {end} }}\quad [{\mathtt {Record}}]

Синтаксически выражения записи будут иметь форму

recordv 1 = e 1,… end {\ displaystyle \ mathbf {record} \ v_ {1} = e_ {1}, \ \ dots \ \ mathbf {end}}

{\ displaystyle \ mathbf {record} \ v_ {1} = e_ {1}, \ \ dots \ \ mathbf {end}}

и иметь правило типа, ведущее к указанному выше типу. Такие значения записи могут затем использоваться таким же образом как объекты в объектно-ориентированном программировании.

Примечания

Ссылки

Внешние ссылки

Грамотная реализация алгоритма W на Haskell вместе с его исходным кодом код на GitHub.
Простая реализация алгоритма Хиндли-Милнера на Python.