Come si chiama una funzione in cui lo stesso input restituirà sempre lo stesso output, ma ha anche effetti collaterali?

Supponiamo che abbiamo una normale funzione pura come

function add(a, b) {
  return a + b
}

E poi lo alteriamo in modo tale che abbia un effetto collaterale

function add(a, b) {
  writeToDatabase(Math.random())
  return a + b;
}

Per quanto ne so, non è considerata una funzione pura perché sento spesso che le persone chiamano funzioni pure "funzioni senza effetti collaterali". Tuttavia, si comporta come una funzione pura per il fatto che restituirà lo stesso output per gli stessi input.

Esiste un nome diverso per questo tipo di funzione, è senza nome o è ancora in realtà puro e mi sbaglio sulla definizione di purezza?

Non sono sicuro delle definizioni universali di purezza, ma dal punto di vista di Haskell (un linguaggio in cui i programmatori tendono a preoccuparsi di cose come la purezza e la trasparenza referenziale), solo la prima delle tue funzioni è "pura". La seconda versione di addnon è pura . Quindi, in risposta alla tua domanda, lo definirei "impuro";)

Secondo questa definizione, una funzione pura è una funzione che:

1. Dipende solo dal suo input. Cioè, dato lo stesso input, restituirà sempre lo stesso output.
2. È referenzialmente trasparente: la funzione può essere liberamente sostituita dal suo valore e il "comportamento" del programma non cambierà.

Con questa definizione, è chiaro che la tua seconda funzione non può essere considerata pura, poiché infrange la regola 2. Cioè, i seguenti due programmi NON sono equivalenti:

function f(a, b) { 
    return add(a, b) + add(a, b);
}

e

function g(a, b) {
    c = add(a, b);
    return c + c;
}

Questo perché anche se entrambe le funzioni restituiranno lo stesso valore, la funzione fscriverà due volte nel database ma gscriverà una volta! È molto probabile che le scritture nel database facciano parte del comportamento osservabile del tuo programma, nel qual caso ho mostrato che la tua seconda versione di addnon è "pura".

Se le scritture nel database non sono una parte osservabile del comportamento del tuo programma, entrambe le versioni addpossono essere considerate equivalenti e pure. Ma non riesco a pensare a uno scenario in cui la scrittura nel database non ha importanza. Anche la registrazione conta!

Come si chiama una funzione [per la quale] lo stesso input restituirà sempre lo stesso output, ma ha anche effetti collaterali?

Tale funzione è chiamata

deterministico

Un algoritmo il cui comportamento può essere completamente previsto dall'input.

termwiki.com

Per quanto riguarda lo stato:

A seconda della definizione di funzione utilizzata, una funzione non ha stato. Se vieni dal mondo orientato agli oggetti, ricorda che x.f(y)è un metodo. Come funzione sembrerebbe f(x,y). E se ti piacciono le chiusure con ambito lessicale chiuso, ricorda che lo stato immutabile potrebbe anche far parte dell'espressione delle funzioni. È solo uno stato mutabile che avrebbe un impatto sulla natura deterministica delle funzioni. Quindi f (x) = x + 1 è deterministico fintanto che l'1 non cambia. Non importa dove è memorizzato l'1.

Le tue funzioni sono entrambe deterministiche. Il tuo primo è anche una funzione pura. Il tuo secondo non è puro.

Funzione pura

1. 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 mentre procede l'esecuzione del programma o tra diverse esecuzioni del programma, né può dipendere da alcun input esterno dai dispositivi I / O.

2. 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.

wikipedia.org

Il punto 1 significa deterministico . Il punto 2 significa trasparenza referenziale . Insieme significano che una funzione pura consente solo la modifica dei suoi argomenti e del valore restituito. Nient'altro causa il cambiamento. Nient'altro è cambiato.

Se non ti interessa l'effetto collaterale, allora è referenzialmente trasparente. Naturalmente è possibile che non ti interessi, ma lo fa qualcun altro, quindi l'applicabilità del termine dipende dal contesto.

Non conosco un termine generale proprio per le proprietà che descrivi, ma un sottoinsieme importante sono quelli che sono idempotenti . Nell'informatica, leggermente diversa dalla matematica *, una funzione idempotente può essere ripetuta con lo stesso effetto; vale a dire il risultato netto di effetti collaterali di farlo molte volte è lo stesso di farlo una volta.

Quindi, se il tuo effetto collaterale fosse aggiornare un database con un certo valore in una determinata riga o creare un file con contenuti esattamente coerenti, sarebbe idempotente , ma se aggiunto al database o aggiunto a un file , quindi non lo sarebbe.

Le combinazioni di funzioni idempotenti possono o meno essere idempotenti nel loro insieme.

* L'uso dell'idempotente in modo diverso nell'informatica rispetto alla matematica sembra derivare da un uso errato del termine matematico che è stato poi adottato perché il concetto è utile.

Non so come si chiamino tali funzioni (o se esiste anche un nome sistematico), ma chiamerei la funzione che non è pura (come altre risposte nascoste) ma restituisce sempre lo stesso risultato se fornita con gli stessi parametri "funzione della sua parametri "(rispetto alla funzione dei suoi parametri e qualche altro stato). La chiamerei solo funzione, ma sfortunatamente quando diciamo "funzione" nel contesto della programmazione, intendiamo qualcosa che non deve essere affatto una funzione reale.

Dipende fondamentalmente dal fatto che ti preoccupi o meno dell'impurità. Se la semantica di questa tabella è che non ti importa quante voci ci sono, allora è puro. Altrimenti, non è puro.

O, per dirla in altro modo, va bene purché le ottimizzazioni basate sulla purezza non rompano la semantica del programma.

Un esempio più realistico sarebbe se si cercasse di eseguire il debug di questa funzione e di aggiungere istruzioni di registrazione. Tecnicamente, la registrazione è un effetto collaterale. I registri lo rendono impuro? No.

Direi che la cosa migliore da chiedere non è come la chiameremmo, ma come analizzeremmo un simile codice. E la mia prima domanda chiave in tale analisi sarebbe:

• L'effetto collaterale dipende dall'argomento della funzione o dal risultato dall'effetto collaterale?
  • No: la "funzione efficace" può essere trasformata in una funzione pura, un'azione efficace e un meccanismo per combinarle.
  • Sì: la "funzione efficace" è una funzione che produce un risultato monadico.

Questo è semplice da illustrare in Haskell (e questa frase è solo una mezza battuta). Un esempio del caso "no" sarebbe qualcosa del genere:

double :: Num a => a -> IO a
double x = do
  putStrLn "I'm doubling some number"
  return (x*2)

In questo esempio l'azione che eseguiamo (stampa la linea "I'm doubling some number") non ha alcun impatto sulla relazione tra xe il risultato. Questo significa che possiamo refactoring in questo modo (usando la Applicativeclasse e il suo *>operatore), il che dimostra che la funzione e l'effetto sono in effetti ortogonali:

double :: Num a => a -> IO a
double x = action *> pure (function x)
  where
    -- The pure function 
    function x = x*2  
    -- The side effect
    action = putStrLn "I'm doubling some number"

Quindi in questo caso, personalmente, direi che è un caso in cui è possibile calcolare una funzione pura. Molta programmazione di Haskell riguarda questo aspetto: imparare a separare le parti pure dal codice efficace.

Un esempio del tipo "sì", in cui le parti pure ed efficaci non sono ortogonali:

double :: Num a => a -> IO a
double x = do
  putStrLn ("I'm doubling the number " ++ show x)
  return (x*2)

Ora, la stringa che stampi dipende dal valore di x. La parte della funzione (moltiplicata xper due), tuttavia, non dipende affatto dall'effetto, quindi possiamo ancora tenerne conto:

logged :: (a -> b) -> (a -> IO x) -> IO b
logged function logger a = do
  logger a
  return (function a)

double x = logged function logger
  where function = (*2) 
        logger x putStrLn ("I'm doubling the number " ++ show x)

Potrei continuare a svelare altri esempi, ma spero che questo sia abbastanza per illustrare il punto con cui ho iniziato: non lo "chiami" qualcosa, analizzi come le parti pure ed efficaci si collegano e le fattori quando sono a tuo vantaggio.

Questo è uno dei motivi per cui Haskell usa la sua Monadclasse così ampiamente. Le monadi sono (tra le altre cose) uno strumento per eseguire questo tipo di analisi e refactoring.

Le funzioni che hanno lo scopo di causare effetti collaterali sono spesso chiamate efficaci . Esempio https://slpopejoy.github.io/posts/Effectful01.html