Đa hình cấp cao hơn các loại không có hộp

Tôi có một ngôn ngữ trong đó các loại được bỏ hộp theo mặc định, với loại suy luận dựa trên Hindley Kẻ Milner. Tôi muốn thêm đa hình cấp cao hơn, chủ yếu để làm việc với các loại tồn tại.

Tôi nghĩ rằng tôi hiểu cách kiểm tra các loại này, nhưng tôi không biết phải làm gì khi biên dịch. Hiện tại, tôi biên dịch các định nghĩa đa hình bằng cách tạo các chuyên môn, giống như các mẫu C ++, để chúng có thể hoạt động với các giá trị không được đóng hộp. Ví dụ, đưa ra một định nghĩa về f<T>, nếu chương trình chỉ gọi f<Int32>và f<Char>, thì chỉ những chuyên ngành đó mới xuất hiện trong chương trình được biên dịch. (Hiện tại tôi đang giả sử biên dịch toàn bộ chương trình.)

Nhưng khi truyền một hàm đa hình như một đối số, tôi không thấy làm thế nào tôi có thể tạo ra chuyên môn đúng, bởi vì hàm này có thể được chọn trong thời gian chạy. Tôi không có lựa chọn nào khác ngoài việc sử dụng một đại diện đóng hộp? Hoặc có một cách xung quanh vấn đề?

Suy nghĩ đầu tiên của tôi là bằng cách nào đó mã hóa rank- n đa hình như bậc 1, nhưng tôi không tin nó có thể nói chung bởi vì một công thức trong logic mang tính xây dựng không nhất thiết phải có một hình thức bình thường prenex.

Tôi đã nghĩ một chút về điều này. Vấn đề chính là nói chung, chúng ta không biết giá trị của loại đa hình lớn đến mức nào. Nếu bạn không có thông tin này, bạn phải lấy nó bằng cách nào đó. Monomorp4ation lấy thông tin này cho bạn bằng cách chuyên đi đa hình. Quyền anh có được thông tin này cho bạn bằng cách đưa mọi thứ vào một đại diện có kích thước đã biết.

Một cách khác thứ ba là theo dõi thông tin này trong các loại. Về cơ bản, những gì bạn có thể làm là giới thiệu một loại khác nhau cho từng kích thước dữ liệu và sau đó các hàm đa hình có thể được xác định trên tất cả các loại có kích thước cụ thể. Tôi sẽ phác thảo một hệ thống như vậy dưới đây.

$$\newcommand{\bnfalt}{\;\;|\;\;} \newcommand{\rule}[2]{{\mathord{\array{#1}} \over {\mathord{#2}}}} \newcommand{\judge}[3]{{#1} \vdash {#2} : {#3}}$$ $$\begin{array}{llcl} \mbox{Kinds} & \kappa & ::= n \\ \mbox{Type constructors} & A & ::= & \forall a:\kappa.\; A \bnfalt \alpha \bnfalt A \times B \bnfalt A + B \bnfalt A \to B \\ & & | & \mathsf{ref}\;A \bnfalt \mathsf{Pad}(k) \bnfalt \mu \alpha:\kappa.\; A\\ \end{array}$$

Ở đây, ý tưởng cấp cao là loại của một loại cho bạn biết cần bao nhiêu từ để bố trí một đối tượng trong bộ nhớ. Đối với bất kỳ kích thước nhất định, thật dễ dàng để được đa hình trên tất cả các loại kích thước cụ thể đó. Vì mọi loại - ngay cả loại đa hình - vẫn có kích thước đã biết, việc biên dịch không khó hơn so với C.

Các quy tắc sắp xếp biến tiếng Anh này thành toán học và sẽ trông giống như thế này:

$$\rule{ \alpha:n \in \Gamma} { \judge{\Gamma}{\alpha}{n} } \qquad \rule{ \judge{\Gamma, \alpha:n}{A}{m} } { \judge{\Gamma}{\forall \alpha:n.\; A}{m} }$$ $$\rule{ \judge{\Gamma}{A}{n} & \judge{\Gamma}{B}{m} } { \judge{\Gamma}{A \times B}{n + m} } \qquad \rule{ \judge{\Gamma}{A}{n} & \judge{\Gamma}{B}{n} } { \judge{\Gamma}{A + B}{n + 1} }$$ $$\rule{ \judge{\Gamma}{A}{m} & \judge{\Gamma}{B}{n} } { \judge{\Gamma}{A \to B}{1} } \qquad \rule{ \judge{\Gamma}{A}{n} } { \judge{\Gamma}{\mathsf{ref}\;A}{1} }$$ $$\rule{ } { \judge{\Gamma}{\mathsf{Pad}(k)}{k} } \qquad \rule{ \judge{\Gamma, \alpha:n}{A}{n} } { \judge{\Gamma}{\mu \alpha:n.\; A}{n} }$$

Vì vậy, bộ định lượng forall yêu cầu bạn đưa ra loại bạn đang sử dụng. Tương tự như vậy, ghép nối là loại cặp không có hộp, chỉ đặt ra một bên cạnh trong bộ nhớ (như kiểu cấu trúc C). Các hiệp hội rời rạc lấy hai giá trị có cùng kích thước và sau đó thêm một từ cho thẻ phân biệt đối xử. Các hàm là các bao đóng, được biểu diễn như bình thường bằng một con trỏ tới bản ghi môi trường và mã.A $A \times B$$A$$B$

Tài liệu tham khảo rất thú vị - con trỏ luôn là một từ, nhưng chúng có thể trỏ đến các giá trị ở bất kỳ kích thước nào. Điều này cho phép các lập trình viên thực hiện đa hình cho các đối tượng tùy ý bằng quyền anh, nhưng không yêu cầu họ làm như vậy. Cuối cùng, một khi các kích thước rõ ràng đang hoạt động, việc giới thiệu một loại đệm, sử dụng không gian nhưng không làm gì cả thường rất hữu ích. (Vì vậy, nếu bạn muốn sử dụng liên kết rời rạc của một int và một cặp int, bạn sẽ cần thêm phần đệm int đầu tiên, để bố cục đối tượng được thống nhất.)

Các kiểu đệ quy có quy tắc hình thành tiêu chuẩn, nhưng lưu ý rằng các lần đệ quy phải có cùng kích thước, điều đó có nghĩa là bạn thường phải dán chúng vào một con trỏ để thực hiện công việc phân loại. Ví dụ, kiểu dữ liệu danh sách có thể được biểu diễn dưới dạng

$$\mu \alpha:1.\; \mathsf{ref}\;(\mathsf{Pad}(2) + \mathsf{int} \times \alpha)$$

Vì vậy, điều này trỏ đến một giá trị danh sách trống, hoặc một cặp int và một con trỏ đến một danh sách liên kết khác.

Kiểm tra loại cho các hệ thống như thế này cũng không khó lắm; thuật toán trong bài báo ICFP của tôi với Joshua Dunfield, Đánh máy hai chiều hoàn chỉnh và dễ dàng cho Đa hình bậc cao áp dụng cho trường hợp này mà hầu như không có thay đổi.

Điều này dường như gần với một vấn đề biên dịch hơn là một vấn đề "khoa học máy tính lý thuyết", vì vậy có lẽ bạn nên hỏi những nơi khác.

Trong trường hợp chung, thực sự, tôi nghĩ không có giải pháp nào khác ngoài việc sử dụng một đại diện đóng hộp. Nhưng tôi cũng mong đợi rằng trong thực tế có nhiều lựa chọn thay thế khác nhau, tùy thuộc vào chi tiết cụ thể về tình huống của bạn.

Ví dụ: biểu diễn mức thấp của các đối số không được đóng hộp thường có thể được phân loại thành rất ít lựa chọn thay thế, ví dụ: số nguyên hoặc tương tự, dấu phẩy động hoặc con trỏ. Vì vậy, đối với một hàm f<T>, có thể bạn thực sự chỉ cần tạo 3 triển khai chưa được đóng hộp khác nhau và bạn có thể biểu diễn một đa hình dưới dạng một tuple của 3 hàm đó, vì vậy, khởi tạo T thành Int32 chỉ là chọn phần tử đầu tiên của tuple, ...