Linguaggi funzionali

Sono dei linguaggi di programmazione, che vietano il cambio di valore a una variabile. Un paio di esempi possono essere Scala o Erlang.

In questo tipo di linguaggi, una volta che il valore viene memorizzato, ci rimane per sempre. Se vogliamo memorizzare un altro valore, il linguaggio forza a creare una nuova variabile.

Stile imperativo

public class Esempio {
 
    // Approccio Imperativo
    public static Integer maxImperative(int[] numbers) {
        Integer max = null;
 
        if(numbers.length > 0) {
            max = numbers[0];
            for(int e : numbers) {
                if(e % 10 ==0 && e > max)
                    max = e;
            }
        }
 
        return max;
    }
 
    public static void main(String[] args) {
        int[] values = new int[] {2, 5, 6, 10, 8, 30, 150, 11, 100, 247, 45, 40, 132};
 
        System.out.println(Esempio.maxImperative(values));
 
    }
}

Siamo noi a dire COME fare per calcolare il max tra i multipli di 10, iterando nella lista, verificando le condizioni ecc… Quetsa implementazione sè pur giusta e funzionate può avere dei problemi:

• Variabili Mutabili: Lo stile imperativo implica spesso l’uso di variabili mutabili. In questo stile, generalmente inizializziamo le variabili con un valore predefinito o iniziale e mentre iteriamo, spesso modifichiamo queste variabili. Nell’esempio precedente, max viene modificata più volte, ciò causa un problema, perché in un ambiente multi-thread devono essere gestite dal programmatore tutte le istanze che accedono e modificano tali variabili. Ciò in presenza di codice di una certa complessità la cosa non è proprio semplice.
• Uso di variabili spazzatura: Quando si programma in modo imperativo, spesso creiamo variabili inutili. Questi sono segnaposti temporanei, variabili che ci servono per uno scopo, come appoggio per qualche valore intermedio del nostro algoritmo, o per memorizzare un risultato, come può essere la variabile max in questo esempio. Più variabili temporanee vengono create più “spazzatura” c’è da raccogliere

Stile funzionale

// Approccio Funzionale
public static Integer maxFunctional(int[] numbers) {
  OptionalInt max = Arrays.stream(numbers)
                          .filter(number -> number % 10 == 0)
                          .max();
  // qui usiamo gli Optionals per verifcare se c'è un risultato
  return max.isPresent() ? max.getAsInt() : null;
}
 
public static void main(String[] args) { 
  int[] values = new int[] {2, 5, 6, 10, 8, 30, 150, 11, 100, 247, 45, 40, 132};
  System.out.println(Esempio.maxFunctional(values));      
}

L’approccio funzionale è di tipo dichiarativo. Nello stile dichiarativo ci si concentra sul COSA abbiamo bisogno e non sul COME ottenerlo (come si fà nella programmazione imperativa) e si delegano i dettagli a librerie di funzioni. Ne risulta uno stile conciso, espressivo, che non utilizza variabili spazzatura e non ha alcuna mutazione di variabili esplicita (nella nostra funzione max viene modificata una sola volta). In un ambiente multi-thread usando un codice con queste caratteristiche è molto più semplice gestire la concorrenza.

Ma il functional style nel nostro esempio entra in gioco con l’argomento passato al metodo filter:

Questa chiamata di funzione è molto diversa da quella a cui siamo abituati a vedere nelle versioni precedenti di linguaggi come Java e C. Invece di prendere valori o oggetti come argomento, questa funzione accetta come argomento una funzione anonima (una espressione lambda). Ciò rende questa funzione “funzionale nello stile”.

Nello stile funzionale si usano quelle che si chiamano funzioni di ordine superiore (high order function).

Le funzioni di ordine superiore possono:

• ricevere funzioni come argomento, allo stesso modo di tipi primitivi e oggetti.
• creare funzioni, allo stesso modo di come creiamo tipi primitivi e oggetti all’interno delle funzioni.
• restituire funzioni, allo stesso modo di come possiamo restituire tipi primitivi e oggetti dalle funzioni.

Lo stile funzionale ha tutti i vantaggi dello stile dichiarativo e possiamo usare la scomposizione in funzioni come strumento di progettazione. Nella programmazione OO usiamo gli oggetti per modellare la separazione delle responsabilità. Con lo stile funzionale, deleghiamo diverse responsabilità a diverse funzioni.