Differenze tra Agda e Idris

Sto iniziando ad immergermi nella programmazione tipicamente dipendente e ho scoperto che i linguaggi Agda e Idris sono i più vicini a Haskell, quindi ho iniziato da lì.

La mia domanda è: quali sono le principali differenze tra loro? I sistemi di tipi sono ugualmente espressivi in ​​entrambi? Sarebbe bello avere un confronto completo e una discussione sui benefici.

Sono stato in grado di individuare alcuni:

• Idris ha le classi di tipi alla Haskell, mentre Agda segue argomenti di istanza
• Idris include la notazione monadica e applicativa
• Entrambi sembrano avere una sorta di sintassi riutilizzabile, anche se non sono davvero sicuri che siano uguali.

Modifica : ci sono altre risposte nella pagina Reddit di questa domanda: http://www.reddit.com/r/dependent_types/comments/q8n2q/agda_vs_idris/

Potrei non essere la persona migliore a cui rispondere, dato che avendo implementato Idris sono probabilmente un po 'di parte! Le FAQ - http://docs.idris-lang.org/en/latest/faq/faq.html - hanno qualcosa da dire su questo, ma per ampliarlo un po ':

Idris è stato progettato da zero per supportare la programmazione generale prima della dimostrazione del teorema, e come tale ha caratteristiche di alto livello come classi di tipo, notazione, parentesi di linguaggio, comprensione dell'elenco, sovraccarico e così via. Idris pone la programmazione di alto livello davanti alla dimostrazione interattiva, sebbene poiché Idris sia basato su un elaboratore basato sulla tattica, esiste un'interfaccia per un proverore di teoremi interattivo basato sulla tattica (un po 'come Coq, ma non così avanzato, almeno non ancora).

Un'altra cosa che Idris intende supportare bene è l'implementazione DSL integrata. Con Haskell puoi fare molta strada con la notazione, e puoi farlo anche con Idris, ma puoi anche ricollegare altri costrutti come l'applicazione e l'associazione delle variabili, se necessario. Puoi trovare maggiori dettagli su questo nel tutorial o dettagli completi in questo documento: http://eb.host.cs.st-andrews.ac.uk/drafts/dsl-idris.pdf

Un'altra differenza è nella compilazione. Agda passa principalmente tramite Haskell, Idris tramite C. Esiste un back-end sperimentale per Agda che utilizza lo stesso back-end di Idris, tramite C. Non so quanto sia ben mantenuto. Un obiettivo primario di Idris sarà sempre quello di generare codice efficiente: possiamo fare molto meglio di quanto facciamo attualmente, ma ci stiamo lavorando.

I sistemi di tipi in Agda e Idris sono abbastanza simili per molti aspetti importanti. Penso che la differenza principale sia nella gestione degli universi. Agda ha un polimorfismo nell'universo, Idris ha la cumulatività (e puoi avere Set : Setin entrambi se lo trovi troppo restrittivo e non ti dispiace che le tue prove potrebbero essere non fondate).

Un'altra differenza tra Idris e Agda è che l'uguaglianza proposizionale di Idris è eterogenea, mentre quella di Agda è omogenea.

In altre parole, la definizione putativa di uguaglianza in Idris sarebbe:

data (=) : {a, b : Type} -> a -> b -> Type where
  refl : x = x

mentre ad Agda lo è

data _≡_ {l} {A : Set l} (x : A) : A → Set a where
    refl : x ≡ x

La l nella definizione di Agda può essere ignorata, poiché ha a che fare con il polimorfismo dell'universo che Edwin menziona nella sua risposta.

La differenza importante è che il tipo di uguaglianza in Agda accetta due elementi di A come argomenti, mentre in Idris può assumere due valori con tipi potenzialmente diversi .

In altre parole, in Idris si può affermare che due cose con tipi diversi sono uguali (anche se finisce per essere un'affermazione non dimostrabile), mentre in Agda l'affermazione stessa è assurda.

Ciò ha conseguenze importanti e di vasta portata per la teoria dei tipi, in particolare per quanto riguarda la fattibilità di lavorare con la teoria dei tipi di omotopia. Per questo, l'uguaglianza eterogenea non funzionerà perché richiede un assioma incompatibile con HoTT. D'altra parte, è possibile affermare teoremi utili con uguaglianza eterogenea che non può essere dichiarata in modo diretto con uguaglianza omogenea.

Forse l'esempio più semplice è l'associatività della concatenazione vettoriale. Date le liste indicizzate per lunghezza chiamate vettori così definiti:

data Vect : Nat -> Type -> Type where
  Nil : Vect 0 a
  (::) : a -> Vect n a -> Vect (S n) a 

e concatenazione con il seguente tipo:

(++) : Vect n a -> Vect m a -> Vect (n + m) a

potremmo voler dimostrare che:

concatAssoc : (xs : Vect n a) -> (ys : Vect m a) -> (zs : Vect o a) ->
              xs ++ (ys ++ zs) = (xs ++ ys) ++ zs

Questa affermazione è senza senso sotto l'uguaglianza omogenea, perché il lato sinistro dell'uguaglianza ha tipo Vect (n + (m + o)) ae il lato destro ha tipo Vect ((n + m) + o) a. È un'affermazione perfettamente sensata con l'uguaglianza eterogenea.