Una funzione è immediatamente impura se accetta una funzione come parametro?

Poiché la purezza di un parametro di input è sconosciuta fino al runtime, una funzione viene immediatamente considerata impura se accetta una funzione come parametro di input?

Correlati: se una funzione applica una funzione pura che è definita al di fuori della funzione, ma non viene passata come parametro, è ancora pura se soddisfa i criteri di non avere effetti collaterali e l'output dipende esclusivamente dall'input?

Per il contesto, sto scrivendo codice funzionale in JavaScript.

Fintanto che tutti i valori utilizzati nella funzione sono definiti esclusivamente dai suoi parametri, è una funzione pura.

L'aspetto che l'output è lo stesso ogni volta per lo stesso input è controllato dal fatto che i parametri siano puri. Se si presume che anche i parametri (come un argomento di funzione) siano pure, è puro.

In un linguaggio come Javascript in cui la purezza non viene applicata, ciò significa che è possibile fare in modo che una funzione altrimenti pura abbia un comportamento impuro invocando una funzione impura passata come parametro.

Ciò significa effettivamente che per i linguaggi che non impongono la purezza (cioè quasi tutti), è impossibile definire una funzione pura che invoca funzioni passate come argomenti. È ancora utile scriverli il più puro possibile e ragionare su di essi come funzioni pure, ma devi fare attenzione perché il presupposto che sia puro verrà rotto se passi argomenti sbagliati.

Nella mia esperienza pratica, di solito non è un grosso problema: trovo raro che funzioni impure vengano utilizzate come argomenti di funzioni per funzioni pure.

Poiché la purezza di un parametro di input è sconosciuta fino al runtime, una funzione viene immediatamente considerata impura se accetta una funzione come parametro di input?

No. controesempio:

function pure(other_function) {
    return 1;
}

Non importa se other_functionè una funzione pura, una funzione impura o non una funzione. La purefunzione è pura.

Altro controesempio:

function identity(x) {
    return x;
}

Questa funzione è pura, anche se xè una funzione impura. identity(impure_function)tornerà sempre impure_function, non importa quante volte si ripete la chiamata. Non importa se identity(impure_function)()restituisce sempre la stessa cosa; il valore restituito di una funzione non influisce sulla sua purezza.

In generale, se una funzione può chiamare una funzione che è stata passata come argomento, non è pura. Ad esempio, una funzione function call(f) {f();}non è pura, perché anche se non fa menzione di alcuno stato globale o mutevole, fpotrebbe essere qualcosa del genere alertche causa effetti collaterali visibili.

Se una funzione accetta funzioni come argomenti, ma non le chiama o non le fa chiamare, allora può essere pura. Potrebbe essere ancora impuro se fa qualche altra cosa impura. Ad esempio, function f(ignored_function) {alert('This isn't pure.');}è impuro, anche se non chiama mai ignored_function.

Poiché la purezza di un parametro di input è sconosciuta fino al runtime, una funzione viene immediatamente considerata impura se accetta una funzione come parametro di input?

Tecnicamente sì, a meno che non ci sia un modo nella tua lingua per garantire che anche la funzione di input sia pura.

se una funzione applica una funzione pura che è definita al di fuori della funzione, ma non viene passata come parametro, è ancora pura se soddisfa i criteri di non avere effetti collaterali e l'output dipende esclusivamente dall'input?

Sì. Quindi concentriamoci su ciò che conta qui. Chiamare una funzione pura o no non è di per sé utile. Le funzioni pure sono utili perché produrre lo stesso output per qualsiasi input e non dipendere dallo stato o avere effetti collaterali è un insieme molto utile di proprietà. Significa che una volta che la tua funzione è stata eseguita, puoi "ricordare" la risposta per quell'input e sarà sempre vera. Inoltre, non è necessario eseguire nuovamente la funzione per generare effetti collaterali. E puoi eseguire quella funzione in parallelo (o fuori servizio) con altre funzioni e sapere che non avranno interazioni nascoste che si comportano male.

Queste proprietà utili rimangono valide se la funzione utilizza altre funzioni di sola lettura per svolgere il proprio lavoro, indipendentemente da come le fa riferimento.

Come ha detto Telastyn: tecnicamente sì, a meno che non ci sia un modo nella tua lingua per garantire che anche la funzione di input sia pura.

Non è ipotetico, ci sono davvero buoni modi per garantirlo. Almeno in una lingua fortemente tipizzata.

Una funzione così pura che scriveresti in JavaScript come

function foo(f) {
   return f(1) + 2;
}

può essere tradotto direttamente in Haskell:

foo :: (Int -> Int) -> Int
foo f = f 1 + 2

Ora, in JavaScript puoi fare cose cattive come

js> foo (function(x) {console.log("muharhar"); return 0})
muharhar
2

Questo non è possibile in Haskell . Il motivo è che qualcosa di simile agli effetti collaterali console.log()deve sempre avere un tipo di risultato IO something, non somethingsolo.

GHCi> foo (\x -> print "muarhar" >> return 0)

<interactive>:7:12:
    Couldn't match expected type ‘Int’ with actual type ‘IO b0’
    In the expression: print "muarhar" >> return 0
    In the first argument of ‘foo’, namely
      ‘(\ x -> print "muarhar" >> return 0)’
    In the expression: foo (\ x -> print "muarhar" >> return 0)

Affinché l'espressione sia corretta, dovremmo fornire foola firma del tipo

foo :: (Int -> IO Int) -> Int

Ma poi non riesco più ad implementarlo: poiché la funzione argomento ha IOcome risultato, non posso usarlo all'interno foo.

<interactive>:8:44:
    Couldn't match expected type ‘Int’ with actual type ‘IO Int’
    In the first argument of ‘(+)’, namely ‘f 1’
    In the expression: f 1 + 2

L'unico modo in cui potrei usare IOun'azione fooè se il risultato di fooha il tipo IO Intstesso:

foo :: (Int -> IO Int) -> IO Int
foo f = do
   f1 <- f 1
   return (f1 + 2)

Ma a questo punto dalla firma emerge chiaramente fooche non è nemmeno una funzione pura.

No non lo è.

Se la funzione passata è impura E la tua funzione chiama la funzione passata, la tua funzione verrà considerata impura.

La relazione pura / impura è un po 'come sync / async in JS. Puoi usare liberamente il codice puro da impuro, ma non viceversa.