Il compilatore per il tipo dipendente è molto più difficile di un intero?

Ho imparato qualcosa sull'implementazione di tipi dipendenti, come questo tutorial , ma la maggior parte di essi sta implementando interpreti. La mia domanda è, sembra che l'implementazione di un compilatore per il tipo dipendente sia molto più difficile di un compilatore, perché puoi davvero valutare gli argomenti del tipo dipendente per il controllo del tipo.

Così

• La mia impressione ingenua è giusta?
• Se è giusto, qualche esempio / risorsa sull'implementazione di un linguaggio controllato staticamente che supporti il ​​tipo dipendente?

Questa è una domanda interessante! Come suggerisce la risposta di Anthony, si possono usare i soliti approcci per compilare un linguaggio funzionale non dipendente, purché si abbia già un interprete per valutare i termini per il controllo del tipo .

Questo è l'approccio adottato da Edwin Brady. Ora questo è concettualmente più semplice, ma perde i vantaggi di velocità della compilazione quando si esegue il controllo del tipo. Questo è stato affrontato in diverse maniere.

Innanzitutto, è possibile implementare una macchina virtuale che compila i termini in byte-code al volo per eseguire il controllo di conversione. Questa è l'idea alla base vm_computeimplementata in Coq da Benjamin Gregoire . Apparentemente c'è anche questa tesi di Dirk Kleeblatt su questo argomento esatto, ma verso il basso il codice macchina reale piuttosto che una macchina virtuale.

In secondo luogo, si può generare codice in un linguaggio più convenzionale che, al momento dell'esecuzione, controlla tutte le conversioni necessarie per il controllo del tipo di un programma tipizzato in modo dipendente. Questo significa che possiamo usare Haskell, diciamo, per controllare il tipo di un modulo Agda. Il codice può essere compilato ed eseguito, e se accetta, si può presumere che il codice nel linguaggio di tipo dipendente sia ben digitato (salvo errori di implementazione e compilatore). Ho sentito per la prima volta questo approccio suggerito da Mathieu Boesflug .

Infine, si potrebbe richiedere che i termini che compaiono nei tipi e i termini che si intende eseguire siano parte di due lingue distinte. Se i termini che appaiono a livello di tipo non hanno essi stessi tipi dipendenti, si può compilare in due fasi: in primo luogo, compilare il codice "a livello di tipo" e quindi è possibile eseguirlo quando si controllano i tipi di "livello a termine" codice. Non sono a conoscenza di alcun sistema che procede in questo modo, ma è potenzialmente possibile per molti sistemi, come il linguaggio F$^*$ di Microsoft che ha termini distinti a livello di tipo e di programma.

La tesi di dottorato di Edwin Brady delinea come costruire un compilatore per un linguaggio di programmazione tipicamente dipendente. Non sono un esperto, ma direi che non è estremamente difficile implementare un compilatore simile a System F. Molti dei principi sono abbastanza simili e alcuni sono gli stessi (ad es. Compilazione di supercombinatori). La tesi copre molte altre preoccupazioni.