Введіть умовивід з типами продуктів

Я працюю над компілятором для конкатенативної мови і хотів би додати підтримку виводу типу. Я розумію Хіндлі – Мілнера, але я вивчав теорію типів, коли йду, тому не знаю, як її адаптувати. Чи є наступна система звуковою і, можливо, незмінною?

Термін - це буквальне слово, склад термінів, цитата терміна або примітив.

e ::= x | e e | [e] | \dots

$e ::= x \:\big|\: e\:e \:\big|\: [e] \:\big|\: \dots$

Усі терміни позначають функції. Для двох функцій і , $e_1$ $e_2$ , тобто протиставлення позначає зворотний склад. Літерали позначаютьladin функції. $e_1\:e_2 = e_2 \circ e_1$

Терміни, окрім складу, мають основні правила типу:

\frac{}{x : ι} [Lit] \frac{Γ ⊢ e : σ}{Γ ⊢ [e] : \forall α . α \to σ \times α} [Quot], α not free in Γ

$\dfrac{}{x : \iota}\text{[Lit]} \\ \dfrac{\Gamma\vdash e : \sigma}{\Gamma\vdash [e] : \forall\alpha.\:\alpha\to\sigma\times\alpha}\text{[Quot]}, \alpha \text{ not free in } \Gamma$

Особливо відсутні правила застосування, оскільки в мовах сполучення їх немає.

Тип - це буквальний, змінний тип, або функція від стеків до стеків, де стек визначається як правильний вкладений кортеж. Усі функції неявно поліморфні щодо «решти стека».

\begin{aligned} τ & ::= ι | α | ρ \to ρ \\ ρ & ::= () | τ \times ρ \\ σ & ::= τ | \forall α . σ \end{aligned}

$\begin{aligned} \tau & ::= \iota \:\big|\: \alpha \:\big|\: \rho\to\rho \\ \rho & ::= () \:\big|\: \tau\times\rho \\ \sigma & ::= \tau \:\big|\: \forall\alpha.\:\sigma \end{aligned}$

Це перше, що здається підозрілим, але я не знаю точно, що з цим.

Щоб допомогти читаності і скоротити дужки, я буду вважати , що у типних схемах. Я також буду використовувати велику літеру для змінної, що позначає стек, а не одиничне значення. $a\:b = b \times (a)$

Є шість примітивів. Перші п’ять досить нешкідливі. dupприймає найвище значення і виробляє дві його копії. swapзмінює порядок двох перших значень. popвідкидає найвище значення. quoteприймає значення і виробляє пропозицію (функцію), яка повертає його. applyзастосовує котирування до стеку.

\begin{aligned} d u p & :: \forall A b . A b \to A b b \\ s w a p & :: \forall A b c . A b c \to A c b \\ p o p & :: \forall A b . A b \to A \\ q u o t e & :: \forall A b . A b \to A (\forall C . C \to C b) \\ a p p l y & :: \forall A B . A (A \to B) \to B \end{aligned}

$\begin{aligned} \mathtt{dup} & :: \forall A b.\: A\:b \to A\:b\:b \\ \mathtt{swap} & :: \forall A b c.\: A\:b\:c \to A\:c\:b \\ \mathtt{pop} & :: \forall A b.\: A\:b \to A \\ \mathtt{quote} & :: \forall A b.\: A\:b \to A\:(\forall C. C \to C\:b) \\ \mathtt{apply} & :: \forall A B.\: A\:(A \to B) \to B \\ \end{aligned}$

Останній комбінатор composeповинен взяти дві цитати та повернути тип їх конкатенації, тобто . У статично типізованій конкатенативній мовіCatтипдуже прямолінійний. $[e_1]\:[e_2]\:\mathtt{compose} = [e_1\:e_2]$ compose

c o m p o s e :: \forall A B C D . A (B \to C) (C \to D) \to A (B \to D)

$\mathtt{compose} :: \forall A B C D.\: A\:(B \to C)\:(C \to D) \to A\:(B \to D)$

Однак цей тип є занадто обмежуючим: він вимагає, щоб виробляти першу функцію точно відповідало споживанню другої. Насправді ви повинні взяти на себе різні типи, а потім уніфікувати їх. Але як би ти написав цей тип?

c o m p o s e :: \forall A B C D E . A (B \to C) (D \to E) \to A \dots

$\mathtt{compose} :: \forall A B C D E. A\:(B \to C)\:(D \to E) \to A \dots$

Якщо дозволити позначати різницю двох типів, то я $\setminus$ думаю, ви можете composeправильно написати тип .

c o m p o s e :: \forall A B C D E . A (B \to C) (D \to E) \to A ((D ∖ C) B \to ((C ∖ D) E))

$\mathtt{compose} :: \forall A B C D E.\: A\:(B \to C)\:(D \to E) \to A\:((D \setminus C)\:B \to ((C \setminus D)\:E))$

Це по - , як і раніше відносно проста: composeприймає функцію і один . Його результат споживає зверху споживання не вироблене , і виробляє на вершині виробництва не споживаного . Це дає правило для звичайної композиції. $f_1 : B \to C$ $f_2 : D \to E$ $B$ $f_2$ $f_1$ $D$ $f_1$ $f_2$

\frac{Γ ⊢ e_{1} : \forall A B . A \to B Γ ⊢ e_{2} : \forall C D . C \to D}{Γ ⊢ e_{1} e_{2} : ((C ∖ B) A \to ((B ∖ C) D))} [Comp]

$\dfrac{\Gamma\vdash e_1 : \forall A B.\: A \to B \quad \Gamma\vdash e_2 : \forall C D. C \to D}{\Gamma\vdash e_1 e_2 : ((C \setminus B)\:A \to ((B \setminus C)\:D))}\text{[Comp]}$

Однак я не знаю, що ця гіпотетична насправді відповідає чому-небудь, і я досить довго переслідував її по колах, я вважаю, що я прийняв неправильний поворот. Чи може це бути простою різницею кортежів? $\setminus$

\begin{aligned} \forall A . () ∖ A & = () \\ \forall A . A ∖ () & = A \\ \forall A B C D . A B ∖ C D & = B ∖ D iff A = C \\ otherwise & = undefined \end{aligned}

$\begin{align} \forall A. () \setminus A & = () \\ \forall A. A \setminus () & = A \\ \forall A B C D. A B \setminus C D & = B \setminus D \textit{ iff } A = C \\ \text{otherwise} & = \textit{undefined} \end{align}$

Чи є в цьому щось жахливо зламане, чого я не бачу, чи я на чомусь схожий на правильний шлях? (Я, мабуть, неправильно оцінив деякі з цих матеріалів і вдячний за виправлення в цій області.)

— Джон Перді
джерело

Як ви використовуєте змінні у своїй граматиці? Це запитання має допомогти вам в обробці "підтипу", який вам здається потрібним.

— jmad

@jmad: Я не впевнений, що розумію питання. Змінні типу існують саме для того, щоб формально визначити схеми типів, а сама мова взагалі не має змінних, а лише визначення, які можуть бути [взаємно] рекурсивними.

— Джон Перді

Справедливо. Чи можете ви сказати, чому (можливо, на прикладі) правило composeзанадто обмежувальне? У мене таке враження, що це добре. (наприклад, обмеження

можна було б обробити об'єднанням, як для застосування, як у λ-обчисленні)

C = D

$C=D$

— jmad

@jmad: Звичайно. Розглянемо twiceяк визначений як dup compose apply, який бере пропозицію і застосовує її двічі. [1 +] twiceдобре: ви складаєте дві функції типу

. Але це не так: якщо

ι \to ι

$\iota\to\iota$ [pop] twice

, проблема полягає в тому, що

\forall A b . f_{1}, f_{2} : A b \to A

$\forall A b.\:f_1, f_2 : A\:b\to A$

, тому вираз заборонено, навіть якщо він повинен бути дійсним і мати тип

A \neq A b

$A \neq A\:b$

\forall A b . A b b \to A

$\forall A b.\:A\:b\:b\to A$ compose

складати : \forall А Б С δ . δ (\forall α . α А \to α Б) (\forall β . β Б \to β С) \to δ (\forall γ . γ А \to γ С)

$\text{compose}:\forall ABC\delta. \delta\ (\forall \alpha.\alpha\ A\to \alpha B)\ (\forall \beta.\beta\ B\to \beta C) \to \delta\ (\forall \gamma.\gamma\ A\to \gamma C)$ видається достатньо загальним. Це набагато поліморфніше, ніж тип, запропонований у питанні. Тут змінна кількісно визначається за суміжними фрагментами стека, що фіксує функції багатьох аргументів.

Грецькі літери використовуються для змінних решти стека лише для наочності.

Він виражає обмеження, що вихідний стек першого елемента на стеку повинен бути таким же, як і вхідний стек другого елемента. Відповідне інстанціювання змінної $B$ для двох власне аргументів - це спосіб отримання обмежень для належної роботи, а не визначення нової операції, як ви пропонуєте у питанні.

Я вважаю, що перевірка типів типів 2 загалом не визначається, хоча зроблено певну роботу, яка дає хороші результати на практиці (для Haskell):

Саймон Л. Пейтон Джонс, Дімітріос Вітініотис, Стефані Вейріх, Марк Шилдс: Практичне виведення типу для довільно-рангових типів. J. Функція. Програма. 17 (1): 1-82 (2007)

Правило типу композиції просто:

\frac{Γ ⊢ е_{1} : \forall α . α А \to α Б Γ ⊢ е_{1} : \forall α . α Б \to α С}{Γ ⊢ е_{1} е_{2} : \forall α . α А \to α С}

$\dfrac{\Gamma\vdash e_1:\forall \alpha. \alpha\ A\to \alpha\ B\qquad \Gamma\vdash e_1:\forall \alpha. \alpha\ B\to \alpha\ C} {\Gamma\vdash e_1\ e_2:\forall \alpha.\alpha\ A\to\alpha\ C}$

Щоб система типів працювала в цілому, вам потрібно таке правило спеціалізації:

\frac{Γ ⊢ e : \forall α . α A \to α B}{Γ ⊢ e : \forall α . C A \to α C B}

$\dfrac{\Gamma\vdash e:\forall \alpha. \alpha\ A \to \alpha\ B} {\Gamma\vdash e:\forall \alpha.C\ A\to \alpha\ C\ B}$

— Dave Clarke
джерело

Thanks, this was very helpful. This type is correct for functions of a single argument, but it doesn’t support multiple arguments. For instance, dup + should have type

ι \to ι

$\iota\to\iota$ because + has type

ι ι \to ι

$\iota\:\iota\to\iota$ . But type inference in the absence of annotations is an absolute requirement, so clearly I need to go back to the drawing board. I have an idea for another approach to pursue, though, and will blog about it if it works out.

— Jon Purdy

The stack types quantify over stack fragments, so there is no problem dealing with two argument functions. I'm not sure how this applies to dup +, as that does not use compose, as you defined it above.

— Dave Clarke

Er, right, I meant [dup] [+] compose. But I read

α B

$\alpha\:B$ as

B \times α

$B\times\alpha$ ; say

B = ι \times ι

$B=\iota\times\iota$ ; then you have

(ι \times ι) \times α

$(\iota\times\iota)\times\alpha$ and not

ι \times (ι \times α)

$\iota\times(\iota\times\alpha)$ . Гніздування неправильно, якщо ви не переверніть стек навколо, щоб верхній був останнім (найглибшим вкладеним) елементом.

— Джон Перді

Я, можливо, будую свій стек у неправильному напрямку. Я не думаю, що вкладення має значення, доки пари, що складають стек, не з'являються на мові програмування. (Я планую оновити свою відповідь, але спочатку потрібно зробити невелике дослідження.)

— Дейв Кларк

Так, вкладення - це майже деталь реалізації.

— Джон Перді