Che cos’è una funzione pura

Il prossimo concetto è forse il più delicato da affrontare, perché chi è abituato alla programmazione imperativa, quando lo scopre, non vuole più farne a meno. Vedremo perché questo concetto è così affine alla programmazione imperativa e anche perché, in React, la cosa è molto pericolosa.

In programmazione funzionale, che è uno dei quattro grandi gruppi della programmazione dichiarativa, tutte le funzioni sono funzioni pure. 

Che cos’è una funzione pura?

Una funzione pura è una funzione che usa solo gli argomenti che riceve, più eventuali variabili dichiarate all’interno della funzione, per trasformarli in qualcos’altro, che viene restituito. Facciamo un esempio:

// Funzione pura: number => number
function sum(a, b) {
  return a + b;
}

// Funzione pura: User => boolean
function isOfAge(user) {
  const now = new Date();
  const differenceYears = user.dateOfBirth.getFullYear() - now().getFullYear();
  const differenceMonths = user.dateOfBirth.getMonth() - now().getMonth();
  const differenceDays = user.dateOfBirth.getDate() - now().getDate();

  const age = (() => {
    if (differenceMonths > 0) {
      return differenceYears;
    } else if (differenceMonths === 0) {
      if (differenceDays > 0) {
        return differenceYears;
      } else {
        return differenceYears - 1;
      }
    } else {
      return differenceYears - 1;
    }
  })();

  return age >= 18;
}

Quando una funzione non è pura? 

Una funzione non è pura (e, quindi, si definisce spuria) quando fa più di una cosa, per esempio salvare un valore in local storage o session storage, scrivere qualcosa in console, lanciare un errore. Queste operazioni si chiamano effetti collaterali, perché causano comportamenti in più rispetto a quello della funzione, che è quello di trasformare qualcosa in ingresso in qualcosa in uscita.

In programmazione funzionale, perfino modificare un valore è considerato un effetto collaterale. Per esempio:

let n = 0;
n = 42; // <- Effetto collaterale

const response = { status: false };
response.status = true; // <- Effetto collaterale

const list = [1, 2, 3];
list[1] = 20; // <- Effetto collaterale

Le 3 proprietà delle funzioni pure

Le funzioni pure hanno tre proprietà che le rendono importanti per la programmazione informatica:

1. Riutilizzabilità: le funzioni pure possono essere chiamate infinite volte e si comporteranno sempre nello stesso modo. Non facendo nient’altro che trasformare qualcosa in qualcos’altro, dato lo stesso input, restituiranno sempre lo stesso output. Di contro, le funzioni spurie, che contengono effetti collaterali, potrebbero avere comportamenti diversi a seconda di valori che non hanno a che fare con il loro input.
2. Componibilità: se una funzione trasforma A in B e un’altra trasforma B in C, possiamo comporle per trasformare A in C, anche se non conosciamo il funzionamento interno del sistema (perché non abbiamo scritto noi il codice, per esempio). Questo finché le funzioni sono pure, altrimenti trasformeremmo A in C e ci troveremmo una serie di effetti collaterali che possiamo prevedere solo leggendo il codice delle funzioni.
3. Confidenza: quando le funzioni sono pure, è più facile fidarsi di loro. Una funzione che si chiama isOfAge(user) e ci dice se un utente è maggiorenne, può essere usata ad occhi chiusi. Se, invece, sappiamo che la funzione possa contenere effetti collaterali – per esempio mandare una richiesta di rete per inviare un’e-mail – non possiamo sapere se è sicuro utilizzarla finché non sappiamo esattamente cosa fa.

Il fatto che gli stati in React non possano essere modificati ma solo rimpiazzati in toto, deriva proprio da questa regola della programmazione funzionale. Per lo stesso motivo, non vedrai esempi in questa guida che utilizzano let o che modificano strutture dati sul posto, a meno che non siano esempi legati alla programmazione imperativa.