产品类型的类型推断

我正在为连接语言开发编译器，并希望添加类型推断支持。我了解Hindley–Milner，但是我一直在学习类型理论，所以我不确定如何适应它。以下系统是否合理，可以推断？

术语是文字，术语的组合，术语的引用或基元。

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

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

所有术语表示功能。对于两个函数和，，即，并置表示反向组合。文字表示尼拉德功能。 $e_1$ $e_2$ $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 ü p & :: \forall 一种 b 。 一种 b \to 一种 b b \\ s w 一种 p & :: \forall 一种 b C 。 一种 b C \to 一种 C b \\ p Ø p & :: \forall 一种 b 。 一种 b \to 一种 \\ q ü Ø Ť Ë & :: \forall 一种 b 。 一种 b \to 一种 （ \forall C 。 C \to C b ） \\ 一种 p p 升 ÿ & :: \forall 一种 乙 。 一种 （ 一种 \to 乙 ） \to 乙 \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 Ø 米 p Ø s Ë :: \forall 一种 乙 C d 。 一种 （ 乙 \to C ） （ C \to d ） \to 一种 （ 乙 \to d ）

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

但是，这种类型的限制太多：它要求第一个函数的产生与第二个函数的消耗完全匹配。实际上，您必须假设不同的类型，然后统一它们。但是，您将如何编写该类型？

C Ø 米 p Ø s Ë :: \forall 一种 乙 C d Ë 。 一种 （ 乙 \to C ） （ d \to Ë ） \to 一种 \dots

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

如果让表示两种类型的差异，那么我认为您可以正确地编写类型。 $\setminus$ compose

C Ø 米 p Ø s Ë :: \forall 一种 乙 C d Ë 。 一种 （ 乙 \to C ） （ d \to Ë ） \to 一种 （ （ d ∖ C ） 乙 \to （ （ C ∖ d ） Ë ） ）

$\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 一种 。 （ ） ∖ 一种 & = （ ） \\ \forall 一种 。 一种 ∖ （ ） & = 一种 \\ \forall 一种 乙 C d 。 一种 乙 ∖ C d & = 乙 ∖ d iff 一种 = C \\ 除此以外 & = 未定义 \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}$

我没有看到与此有关的可怕问题，还是我走在正确的道路上？（我可能错误地量化了其中的一些内容，并且希望在该领域进行修复。）

— 乔恩·普迪
source

您如何在语法中使用变量？这个问题应该可以帮助您处理似乎需要的“子类型化”。

— jmad 2012年

@jmad：我不确定我是否理解这个问题。类型变量只是为了正式定义类型方案而存在，语言本身根本没有变量，只有定义，可以[相互]递归。

— 乔恩·普迪

很公平。你能说为什么（也许举个例子）规则compose太严格？我的印象是这样很好。（例如，限制

可以像在λ微积分中那样通过统一处理）

C = D

$C=D$

— jmad 2012年

@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

— 乔恩·普迪

下面秩2型似乎是足够通用。它比问题中提出的类型多态得多。此处变量对堆栈的连续块进行量化，从而捕获了多参数函数。

compose : \forall A B C δ . δ (\forall α . α A \to α B) (\forall β . β B \to β C) \to δ (\forall γ . γ A \to γ C)

$\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$

我认为，尽管已经完成了一些工作，在实践中会产生良好的结果（对于Haskell），但一般来说，类型检查级别2的类型是不确定的：

Simon L. Peyton Jones，Dimitrios Vytiniotis，Stephanie Weirich，Mark Shields：任意等级类型的实用类型推断。J.功能程序。17（1）：1-82（2007）

组成的类型规则很简单：

\frac{Γ ⊢ e_{1} : \forall α . α A \to α B Γ ⊢ e_{1} : \forall α . α B \to α C}{Γ ⊢ e_{1} e_{2} : \forall α . α A \to α C}

$\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}$

— 戴夫·克拉克
source

dup +

ι \to ι

$\iota\to\iota$ +

ι ι \to ι

$\iota\:\iota\to\iota$

堆栈类型对堆栈碎片进行量化，因此处理两个自变量函数没有问题。我不确定这如何应用于dup +，因为它不使用您在上面定义的compose。

— 戴夫·克拉克

[dup] [+] compose

α B

$\alpha\:B$

B \times α

$B\times\alpha$

B = ι \times ι

$B=\iota\times\iota$

(ι \times ι) \times α

$(\iota\times\iota)\times\alpha$

ι \times (ι \times α)

$\iota\times(\iota\times\alpha)$

我可能在错误的方向上构建堆栈。我认为嵌套并不重要，只要建立堆栈的对不出现在编程语言中即可。（我打算更新我的答案，但需要先做一点研究。）

— Dave Clarke 2012年

是的，嵌套几乎是一个实现细节。

— 乔恩·普迪