Pure Functions vs. Side Effects

1. Cosa sono le Funzioni Pure e gli Effetti Collaterali?

Per iniziare, vediamo una definizione chiara e concisa di questi concetti. Una funzione pura è come una funzione matematica: è prevedibile e isolata dal resto del mondo.

Per una spiegazione introduttiva, guarda i primi minuti del seguente video. Si concentra su due idee principali:

1. Una funzione pura, per lo stesso input, produce sempre lo stesso output.
2. Una funzione pura non ha interazioni osservabili con il mondo esterno (i cosiddetti "side effects").

Come hai visto, le due regole per una funzione pura sono semplici ma rigorose:

• Determinismo: L'output dipende esclusivamente dai suoi argomenti di input.
• Nessun effetto collaterale: La funzione non modifica alcuno stato esterno (variabili globali, file system, database) né ha interazioni osservabili con l'esterno (chiamate di rete, output sulla console).

L'immagine seguente riassume visivamente questa idea.

2. Esempi in Python

Vediamo come si traducono questi concetti in Python. L'articolo seguente mostra esempi chiari di funzioni pure e impure.

La funzione add_to_result è un classico esempio di funzione impura perché viola entrambe le regole:

1. Il suo output (implicito, attraverso la modifica dello stato globale) dipende dallo stato precedente della variabile result. Chiamandola più volte con lo stesso input 5 si ottengono risultati diversi per lo stato globale (5, 10, 15, ...).
2. Ha un effetto collaterale: modifica la variabile globale result, che esiste al di fuori del suo scope.

Questo comportamento introduce imprevedibilità, rendendo il codice più difficile da testare, da eseguire in parallelo e da analizzare.

3. Il Cuore del Pensiero Funzionale: Data-Flow vs. Control-Flow

La distinzione tra puro e impuro non è solo una classificazione accademica; rappresenta un cambiamento radicale nel modo in cui strutturiamo i programmi. La programmazione imperativa, a cui sei abituato, si concentra sul control-flow: una sequenza di istruzioni che manipolano uno stato condiviso. La programmazione funzionale si concentra sul data-flow: come i dati fluiscono attraverso una catena di funzioni pure che li trasformano.

L'articolo "What's Functional Programming All About?" di Li Haoyi illustra magnificamente questa differenza usando un'analogia con una ricetta di Tiramisù. Ti guiderò attraverso le parti salienti.

Riflettiamo sull'analogia del Tiramisù:

• Ricetta Imperativa: È una lista di comandi. "Sbatti le uova", "aggiungi lo zucchero", "mescola". C'è una variabile implicita, mixture, che viene continuamente modificata (mutata). Questo è un side effect. Se vuoi parallelizzare il lavoro o capire le dipendenze, devi analizzare attentamente ogni passo per capire cosa dipende da cosa.
• Ricetta Funzionale (il diagramma): Mostra le dipendenze in modo esplicito. beat(eggs) produce beat_eggs. whip(cream) produce whipped_cream. Per ottenere folded_mixture, hai bisogno di cheese_mixture e whipped_cream. Il flusso dei dati è chiaro. Le funzioni sono pure: non modificano i loro ingredienti, ma ne creano di nuovi.

Questo è il vantaggio principale: le funzioni pure rendono il flusso dei dati esplicito, eliminando gli effetti collaterali nascosti. Il codice diventa più simile a un diagramma di flusso matematico, più facile da analizzare, ottimizzare e parallelizzare.

4. Esercizio Pratico: Identifica le Funzioni

Ora, mettiamo alla prova la tua comprensione. Per ciascuna delle seguenti funzioni Python, stabilisci se è pura o impura e spiega brevemente il perché.

Funzione 1:

import random

def get_random_choice(items):
    return random.choice(items)

Funzione 2:

def create_greeting(name):
    return f"Hello, {name}!"

Funzione 3:

user_cache = {}

def get_user_from_db(user_id):
    if user_id in user_cache:
        return user_cache[user_id]
    



    # Immagina che qui ci sia del codice che legge da un database
    user_data = f"data_for_{user_id}" 
    user_cache[user_id] = user_data
    return user_data

Funzione 4:

def add_item_to_list(items, item):
    items.append(item)
    return items

Riepilogo e Prossimi Passi

In questa lezione abbiamo introdotto il concetto fondamentale di funzione pura, il mattone della programmazione funzionale.

Punti chiave:

• Una funzione pura è deterministica (stesso input -> stesso output) e non ha effetti collaterali (non interagisce con il mondo esterno né lo modifica).
• Gli effetti collaterali (side effects) rendono il codice più difficile da analizzare, testare e parallelizzare.
• Il passaggio al pensiero funzionale è un passaggio dalla focalizzazione sul control-flow (sequenza di comandi) alla focalizzazione sul data-flow (trasformazione dei dati).

L'ultimo esempio dell'esercizio (add_item_to_list) ha evidenziato un tipo comune di effetto collaterale: la modifica di una struttura dati passata come argomento. Un modo per evitare questo problema è rendere le nostre strutture dati non modificabili.

Nella prossima lezione, esploreremo esattamente questo: i benefici dell'immutabilità. Vedremo come l'uso di dati immutabili in Python sia una tecnica chiave per scrivere codice in stile funzionale, più sicuro e prevedibile.