Variabili monouso: nessuna lingua le ha mai avute?

Nella teoria dei tipi, le variabili monouso sono modellate con (una derivata di) logica lineare . Nella logica lineare, una proposizione può essere utilizzata solo una volta; la logica lineare a volte è vista come una logica delle risorse . Nella logica lineare, se si desidera utilizzare A due volte, è necessario disporre di A⊗A (sia A che A) disponibili; se vuoi usare A tutte le volte che vuoi, è necessario avere! A ("ovviamente A").

La logica lineare non è stata introdotta in molti linguaggi di programmazione tradizionali. È la base della digitazione di unicità nel linguaggio di programmazione pulito utilizzato per modellare gli effetti collaterali. In Clean, un'espressione di tipo Int denota un puro calcolo che produce un valore intero, cioè un calcolo che può essere eseguito in qualsiasi momento, o più volte, senza modificare il comportamento del programma. Un'espressione di tipo u:Int denota un calcolo che produce un intero e che deve essere eseguito esattamente una volta, ad esempio perché esegue un effetto collaterale.

Probabilmente dovresti dare un'occhiata a ATS e Mercury . Entrambi hanno il supporto per i tipi lineari, anche se in paradigmi diversi.

In particolare, vorrei aggiungere che ATS utilizza tipi lineari per il monitoraggio dell'utilizzo delle risorse, e questo ha implicazioni sia di prestazioni che di correttezza, ad es. consentendo il recupero esplicito della memoria e il supporto di efficienti matrici mutevoli.

Inoltre, i termini dei tipi lineari non sono necessariamente "usati una volta", ma non lo farò lontano (PDF).

In questo modo è possibile utilizzare le variabili di classe di memorizzazione automatica in C. Basta avviare un nuovo blocco con {, dichiarare e inizializzare alcune variabili automatiche, eseguire il calcolo, quindi chiudere il blocco con}, e tutte le variabili automatiche nel blocco scompaiono. Un esempio di un mio codice:

{
    int term = tar->array[i];
    int offset = isnegation(term) ? 41 : 0;
    int var = variable(term);
    int bx = ((var + offset) / bits_per_sigblock) % CLAUSE_SIGNATURE_SIZE;
    int shift = ((var + offset) % bits_per_sigblock) - 1;
    sp[bx] |= (signature_type)1 << shift;
}

Questo potrebbe essere stato inserito in una riga di codice, ma sarebbe stato illeggibile, anche per me!

• Haskell ha un costrutto where che si adatta alla tua descrizione, oltre a let…in .
• La famiglia Lisp / Scheme ha let , letrec e let* .
• ML mostra anche let…in .

Il mio amico Joe Groff ha inviato una risposta via email:

Questi sono chiamati "tipi di unicità". Il linguaggio di programmazione Clean è un puro linguaggio funzionale che costruisce la sua gestione degli effetti collaterali sistema attorno a loro. IIRC Mercury e Oz supportano anche i tipi di unicità, e c'è un'estensione GHC che consente l'annotazione di unicità in Haskell. C ++ 11 li ha anche sotto forma di riferimenti rvalue.

Tecnicamente qualsiasi variabile fattorizzata verrà utilizzata due volte: prima per memorizzare il risultato di qualche sottoespressione e quindi come riferimento a tale risultato come parte dell'espressione più grande.

Come hai sperimentato la maggior parte dei linguaggi, supporti anche le variabili monouso nel senso che è perfettamente possibile usare quell'idioma. C'è qualche specifica gestione diversa di loro che vorresti?

Dovrebbero essere rimossi dallo spazio dei nomi dopo l'uso? O vuoi solo un modo per indicare "non essere attaccato a questa variabile"? Il primo dovrebbe, si spera, essere curato con scopi generalmente limitati: tutto ciò che è monouso dovrebbe essere limitato a zone ben tenute che non causeranno problemi di ingombramento. Quest'ultima possibilità dovrebbe essere gestita da convenzioni o commenti di denominazione variabile.

C'è qualcos'altro che ti piacerebbe accadere?

Il modo in cui i linguaggi concatenativi o basati sullo stack in genere usano valori è in realtà "letto una volta", con la differenza che ovviamente non ci sono variabili, solo valori in pila.

Poiché la maggior parte del tempo viene inoltrata nello stack (le variabili vengono solitamente evitate) e i valori vengono consumati dalle funzioni ("parole") che li leggono, devi duplicare esplicitamente i valori a cui devi fare riferimento più di una volta.

Alla fine ciò rappresenta un passaggio dal normale e l'eccezione nella maggior parte delle altre lingue.

In c / c ++ è uno degli usi principali per l'operatore di falegnameria

const int color = in_the_matrix() ? red : blue;

Particolarmente utile per cose come il threading / OMP in cui è necessario mostrare che una variabile non può essere modificata da un altro thread.