Supponi di estendere il calcolo delle costruzioni con "buchi", ovvero pezzi di codice incompleti che non hai ancora compilato. Mi chiedo se esiste un algoritmo per ricoprire automaticamente quei ruoli. Ad esempio (usando la sintassi di Morte ):
Caso A:
λ (pred : ?)
-> λ (Nat : *)
-> λ (Succ : Nat -> Nat)
-> λ (Zero : Nat)
-> (Succ (pred Nat Succ Zero))
In questa situazione, un algoritmo di inferenza di tipo può identificare che ?
può ovviamente essere solo ∀ (Nat : *) -> (Nat -> Nat) -> Nat -> Nat
perché pred
riceve Nat : *
, Succ : Nat -> Nat
, Zero : Nat
, e deve tornare Nat
, perché è il primo argomento Succ
.
Caso B:
(Id ? 4)
Dove 4 è codificato λ ed Id
è la funzione di identità (cioè, ∀ (t:*) -> λ (x:t) -> x
). In quella situazione, "?" È di nuovo chiaramente ∀ (N:*) -> (N -> N) -> N -> N
, perché questo è il tipo di 4
.
Caso C:
(Id (Equals Nat 7 (add 3 ?)) (Refl 7))
Qui, Equals
e Refl
sono definiti in modo simile a Idris. ?
ovviamente può essere solo 4
, ma come lo capisci? Un modo sarebbe quello di usare il fatto che ? : Nat
, ed Nat
è un tipo che sappiamo enumerare, quindi possiamo provare tutto Nats
fino a quando non viene eseguito il controllo dei caratteri. Questo può essere fatto per qualsiasi tipo enumerabile.
Caso D:
(Id (Equal Nat 10 (MulPair ?)) 10)
Qui, ?
può essere solo di tipo Pair Nat
; ha solo più di una risposta valida, però: può essere (Pair 10 1)
, (Pair 2 5)
, (Pair 5 2)
e (Pair 1 10)
.
Caso E:
(Id (Equal Nat 7 (Mul 2 ?)) 7)
Qui non esiste una risposta valida, poiché 7
non è un multiplo di 2
.
Tutti quegli esempi mi hanno fatto notare che possiamo creare un algoritmo generale che identifica alcuni schemi noti e dà una risposta selezionando manualmente un algoritmo specifico (inferenza di tipo, forza bruta e così via), un po 'come Wolfram Alpha capisce la strategia giusta per risolvere un integrale. Ma sembra un approccio ingegneristico / hardcoded. Esiste un modo di principio per risolvere questo problema? C'è qualche studio / area di ricerca su di esso?