Calcola se una funzione è pura

Secondo Wikipedia:

Nella programmazione al computer, una funzione può essere descritta come pura se entrambe queste affermazioni sulla funzione sono valide: la funzione valuta sempre lo stesso valore di risultato dati gli stessi valori di argomento. Il valore del risultato della funzione non può dipendere da alcuna informazione o stato nascosto che può cambiare man mano che procede l'esecuzione del programma o tra diverse esecuzioni del programma, né può dipendere da alcun input esterno dai dispositivi I / O. La valutazione del risultato non provoca alcun effetto collaterale o output osservabile semanticamente, come la mutazione di oggetti mutabili o l'output a dispositivi I / O.

Mi chiedo se è possibile scrivere una funzione che calcoli se una funzione è pura o no. Codice di esempio in Javascript:

function sum(a,b) {
    return a+b;
}

function say(x){
    console.log(x);
}

isPure(sum) // True
isPure(say) // False

Sì, è possibile, a seconda della lingua.

In JavaScript, puoi sapere se una funzione è pura secondo i seguenti criteri:

• Legge solo parametri e locali;

• Scrive solo gente del posto;

• Sui non locali, chiama solo funzioni pure;

• Tutte le funzioni che chiama implicitamente sono pure, ad esempio toString; e

• Scrive le proprietà dei locali solo se non alias i non locali.

Aliasing non è possibile determinare in JavaScript nel caso generale, poiché è sempre possibile cercare dinamicamente le proprietà di un oggetto ( object["property"]). Se non lo fai mai e hai la fonte dell'intero programma, penso che il problema sia trattabile. Avresti anche bisogno di informazioni su quali funzioni native hanno effetti collaterali, come console.logo quasi tutto ciò che coinvolge il DOM.

Il termine "puro" potrebbe anche usare alcuni chiarimenti. Anche in un linguaggio di programmazione fortemente tipicamente statico e puramente funzionale, in cui tutte le funzioni sono referenzialmente trasparenti, una funzione può ancora non riuscire a terminare. Quindi, quando parliamo id :: a -> a, ciò che stiamo davvero dicendo non è:

Dato un valore di tipo a, la funzione idproduce un valore di tipo a.

Ma piuttosto:

Dato un valore di tipo a, la funzione idnon non produce un valore che è non di tipo a.

Perché un'implementazione valida di idè error "Not implemented!". Come sottolinea Peteris, questa non totalità potrebbe essere vista come una sorta di impurità. Koka è un linguaggio di programmazione funzionale — con sintassi modellata su JavaScript — che può inferire possibili effetti come divergenza (non termine), trasparenza referenziale, lancio di eccezioni e azioni I / O.

No. Puoi facilmente verificare se una funzione esegue solo operazioni "pure-safe", come descritto nella risposta di Jon Purdy, ma questo non è abbastanza IMO per rispondere alla domanda.

Considera questa funzione:

function possiblyPure(x) {
    if (someCheck(x)) {
        return x+1; // pure code path
    }
    else {
        console.log("I'm so unpure..."); // unpure code path
    }
}

Ovviamente, se someCheckè impuro, lo è anche possiblyPure. Ma, se someCheckè puro e restituisce trueper ogni possibile valore di x, possiblyPureè puro, poiché il percorso del codice non puro è irraggiungibile!

E qui arriva la parte difficile: determinare se someCheckritorna vero per ogni possibile input. Cercare di rispondere a questa domanda immensamente ti porta nel regno del problema di arresto e simili problemi indecidibili.

EDIT: prova che è impossibile

C'è qualche incertezza se una funzione pura deve terminare su ogni possibile input. Ma in entrambi i casi, il problema dell'arresto può essere usato per dimostrare che il controllo di purezza è impossibile.

Caso A) Se è necessaria una funzione pura per terminare su ogni possibile input, è necessario risolvere il problema di arresto per determinare se la funzione è pura. Poiché ciò è noto per essere impossibile, con questa definizione, la purezza non può essere calcolata.

Caso B) Se una funzione pura non può terminare su alcuni input, possiamo costruire qualcosa del genere: supponiamo che isPure(f)calcoli se fè una stringa che definisce una funzione pura.

function halts(f) {
   var fescaped = f.replace(/\"/g, '\\"');
   var upf = 'function() { '+f+'("'+fescaped+'\); console.log("unpure"); }';
   return isPure(upf);
}

Ora isPuredeve determinare se si fferma o meno sulla propria fonte come input. Se si ferma, upfè impuro; se non termina, upfè puro se fè puro.

Se isPurefunzionasse come previsto (restituisce risultati corretti e termina con ogni input), avremmo risolto il problema di arresto (*)! Poiché questo è noto per essere impossibile, isPurenon può esistere.

(*) per funzioni JavaScript pure, che è sufficiente per risolverlo anche per il turing machine.

Questa domanda StackOverflow ha una risposta di yfeldblum che è rilevante qui. (E ha un downvote per qualche motivo che non riesco a capire. Sarebbe una cattiva etichetta a votare qualcosa che ha 3 anni?) Fornisce una prova che se una funzione è pura è riducibile al problema di arresto in un commento.

Penso che dal punto di vista pratico non sarebbe troppo difficile per alcune lingue se si lascia che la funzione ritorni sì, no o forse. Stavo guardando un video su Clojure un paio di giorni fa e l'oratore aveva fatto un conteggio di casi di impurità in una base di codice cercando circa 4 stringhe diverse (come "ref"). A causa dell'enfasi di Clojure sulla purezza e sulla segregazione delle cose impure, era banale, ma non era esattamente quello che stai cercando.

Quindi, teoricamente impossibile, praticamente possibile se modifichi un po 'la domanda, e penso che quanto sarebbe difficile dipenderebbe molto dal linguaggio. Linguaggi più semplici / più puliti, con particolare attenzione all'immutabilità e una buona riflessione, sarebbero più facili.

Ottima domanda

Il meglio che puoi fare in pratica, non assumendo alcuna capacità di ascoltare le azioni di I / o per chiamare la funzione il più volte possibile. Quindi verifica se il valore restituito è coerente.

Ma non puoi farlo in generale. Probabilmente, i programmi non-stop sono non-puri e non possiamo decidere il problema.

Non è possibile nel caso generale. Vedi problema di arresto . In breve, è impossibile scrivere un programma che, dato una funzione e un input arbitrari, determina se il programma si arresterà o funzionerà per sempre. Se funziona per sempre, non è una funzione pura che si adatta alla definizione che hai dato.