Ketikkan inferensi dengan jenis produk

Saya sedang mengerjakan kompiler untuk bahasa concatenative dan ingin menambahkan dukungan jenis inferensi. Saya mengerti Hindley-Milner, tetapi saya telah mempelajari teori jenis ketika saya pergi, jadi saya tidak yakin bagaimana mengadaptasinya. Apakah sistem berikut ini masuk akal dan dapat disimpulkan?

Istilah adalah literal, komposisi istilah, kutipan istilah, atau primitif.

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

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

Semua istilah menunjukkan fungsi. Untuk dua fungsi $e_1$ dan $e_2$ , $e_1\:e_2 = e_2 \circ e_1$ , yaitu, penjajaran menunjukkan komposisi terbalik. Literal menunjukkan fungsi niladik.

Istilah selain komposisi memiliki aturan tipe dasar:

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

Yang terutama absen adalah aturan untuk aplikasi, karena bahasa concatenative tidak memilikinya.

Tipe adalah literal, variabel tipe, atau fungsi dari tumpukan ke tumpukan, di mana tumpukan didefinisikan sebagai tupel bersarang kanan. Semua fungsi secara implisit polimorfik sehubungan dengan "sisa tumpukan".

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

Ini adalah hal pertama yang tampaknya mencurigakan, tetapi saya tidak tahu persis apa yang salah dengannya.

Untuk membantu keterbacaan dan mengurangi tanda kurung, saya akan menganggap bahwa dalam skema jenis. Saya juga akan menggunakan huruf kapital untuk variabel yang menunjukkan tumpukan, daripada nilai tunggal. $a\:b = b \times (a)$

Ada enam primitif. Lima yang pertama cukup berbahaya. dupmengambil nilai teratas dan menghasilkan dua salinannya. swapmengubah urutan dua nilai teratas. popmembuang nilai teratas. quotemengambil nilai dan menghasilkan kutipan (fungsi) yang mengembalikannya. applyberlaku kutipan untuk stack.

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

Combinator terakhir compose,, harus mengambil dua kutipan dan mengembalikan tipe gabungannya, yaitu, . Dalam bahasa concatenative yang diketik secara statisCat, jenisini sangat mudah. $[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)$

Namun, tipe ini terlalu membatasi: mengharuskan produksi fungsi pertama sama persis dengan konsumsi fungsi kedua. Pada kenyataannya, Anda harus mengasumsikan tipe yang berbeda, lalu menyatukannya. Tetapi bagaimana Anda menulis tipe itu?

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$

Jika Anda membiarkan menunjukkan perbedaan dua jenis, maka saya pikir Anda dapat menulis jenis dengan benar. $\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))$

Ini masih relatif mudah: composemengambil fungsi dan satu . Hasilnya mengkonsumsi di atas konsumsi tidak diproduksi oleh , dan menghasilkan di atas produksi tidak dikonsumsi oleh . Ini memberikan aturan untuk komposisi biasa. $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]}$

Namun, saya tidak tahu bahwa hipotesis ini sebenarnya sesuai dengan apa pun, dan saya telah mengejarnya cukup lama sehingga saya pikir saya salah belok. Mungkinkah itu perbedaan tuple yang sederhana? $\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}$

Apakah ada sesuatu yang sangat buruk tentang hal ini yang tidak saya lihat, atau apakah saya berada di jalur yang benar? (Saya mungkin salah mengukur beberapa hal ini dan akan menghargai perbaikan di daerah itu juga.)

programming-languages logic compilers type-theory type-checking Jon Purdy
sumber

Bagaimana Anda menggunakan variabel dalam tata bahasa Anda? Pertanyaan ini seharusnya membantu Anda dalam menangani "subtyping" yang tampaknya Anda butuhkan.

jmad

@jmad: Saya tidak yakin saya mengerti pertanyaannya. Tipe variabel hanya ada demi skema tipe yang secara formal mendefinisikan, dan bahasa itu sendiri tidak memiliki variabel sama sekali, hanya definisi, yang dapat [saling] rekursif.

Jon Purdy

Cukup adil. Bisakah Anda mengatakan mengapa (mungkin dengan contoh) aturan composeterlalu ketat? Saya mendapat kesan bahwa ini baik-baik saja seperti ini. (misalnya pembatasan

C = D

$C=D$ dapat ditangani dengan penyatuan seperti untuk aplikasi dalam seperti di λ-calculus)

jmad

@jmad: Tentu. Pertimbangkan twicedidefinisikan sebagai dup compose apply, yang mengambil kutipan dan menerapkannya dua kali. [1 +] twicebaik-baik saja: Anda membuat dua fungsi tipe

ι \to ι

$\iota\to\iota$ . Tetapi [pop] twicetidak: jika

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

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

A \neq A b

$A \neq A\:b$ , jadi ekspresi tidak diizinkan meskipun harus valid dan bertipe

\forall A b . A b b \to A

$\forall A b.\:A\:b\:b\to A$ . Solusinya tentu saja untuk menempatkan kualifikasi di tempat yang tepat, tetapi saya terutama bertanya-tanya bagaimana sebenarnya menulis jenis composetanpa beberapa definisi melingkar.

Jon Purdy

Berikut peringkat tipe-2

menyusun : \forall SEBUAH B C δ . δ (\forall α . α SEBUAH \to α B) (\forall β . β B \to β C) \to δ (\forall γ . γ SEBUAH \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)$ tampaknya cukup umum. Ini jauh lebih polimorfik daripada tipe yang diusulkan dalam pertanyaan. Di sini variabel mengkuantifikasi potongan-potongan stack yang berdekatan, yang menangkap fungsi multi-argumen.

Huruf Yunani digunakan untuk variabel sisa tumpukan untuk kejelasan saja.

Ini mengungkapkan kendala bahwa tumpukan output dari elemen pertama pada tumpukan harus sama dengan tumpukan input dari elemen kedua. Instantiating variabel dengan tepat $B$ karena dua argumen yang sebenarnya adalah cara mendapatkan kendala untuk bekerja dengan baik, daripada mendefinisikan operasi baru, seperti yang Anda usulkan dalam pertanyaan.

Tipe memeriksa tipe-2 tipe tidak dapat diputuskan secara umum, saya percaya, meskipun beberapa pekerjaan telah dilakukan yang memberikan hasil yang baik dalam praktek (untuk Haskell):

Simon L. Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, Mark Shields: Inferensi tipe praktis untuk tipe peringkat sewenang-wenang. J. Funct. Program. 17 (1): 1-82 (2007)

Aturan jenis untuk komposisi hanyalah:

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

Agar sistem tipe berfungsi secara umum, Anda memerlukan aturan spesialisasi berikut:

\frac{Γ ⊢ e : \forall α . α SEBUAH \to α B}{Γ ⊢ e : \forall α . C SEBUAH \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
sumber

Terima kasih, ini sangat membantu. Tipe ini benar untuk fungsi argumen tunggal, tetapi tidak mendukung banyak argumen. Misalnya, dup +harus memiliki tipe

ι \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)$ . The nesting isn’t right, unless you flip the stack around so that the top is the last (deepest nested) element.

Jon Purdy

I may be building my stack in the wrong direction. I don't think the nesting matters, so long as the pairs building up the stack do not appear in the programming language. (I'm planning to update my answer, but need to do a little research first.)

Dave Clarke

Yeah, nesting is pretty much an implementation detail.

Jon Purdy

Ketikkan inferensi dengan jenis produk

Jawaban: