Haskell · Rust · linguaggi

Haskell vs Rust

Haskell e Rust sono entrambi a tipizzazione statica, entrambi compilati, ed entrambi attraggono programmatori attenti alla correttezza. Questa somiglianza superficiale nasconde una divergenza profonda su cio che ciascun linguaggio considera la fonte principale di bug, e quindi su cio che vi obbliga a gestire a tempo di compilazione.

Haskell considera gli effetti collaterali come il pericolo principale. Una funzione che legge un file o modifica una variabile porta questa informazione nel suo tipo. Le funzioni pure, che prendono valori e ne restituiscono senza altra interazione, sono il default, e l'impurita e l'eccezione che dovete dichiarare.

Rust considera gli errori nell'uso della memoria come il pericolo principale. Le sue regole di ownership e borrowing garantiscono a tempo di compilazione che due parti di un programma non detengano mai contemporaneamente un riferimento mutabile agli stessi dati. Le data race, i use-after-free e i double-free sono esclusi dal type checker, non da un garbage collector.

Nessuno dei due e un sovrainsieme dell'altro. La domanda non e quale sia migliore, ma quale problema state risolvendo.

Sistemi di tipi: purezza vs ownership

Il sistema di tipi di Haskell discende da Hindley-Milner. Supporta il polimorfismo parametrico, le classi di tipi (simili ai trait di Rust), i tipi di kind superiore e una separazione tra codice puro ed effettivo imposta dalla monade IO. L'inferenza dei tipi e pervasiva: potete scrivere programmi interi senza una singola annotazione e il compilatore inferira ogni tipo.

Il sistema di tipi di Rust e affine. Ogni valore ha esattamente un proprietario; quando l'ownership viene trasferita, il binding originale non e piu utilizzabile. Il borrowing (condiviso &T o esclusivo &mut T) permette di referenziare dati senza prenderne l'ownership, con la regola che potete avere un riferimento mutabile oppure un numero qualsiasi di riferimenti condivisi, mai entrambi. I lifetime, scritti come 'a, indicano al compilatore per quanto tempo un riferimento e valido.

In pratica la differenza si manifesta in cio su cui discutete con il compilatore. In Haskell lottate con il type checker quando le firme delle vostre funzioni non compongono. In Rust lottate con il borrow checker quando il flusso dei dati viola le regole di ownership.

Gestione della memoria

Haskell usa un garbage collector a tracciamento (GC). Il runtime GHC include un GC generazionale, per copia, che gira in modo concorrente su una capability separata. L'allocazione e veloce (incrementare un puntatore in una nursery), e i valori a breve durata sono economici. Il costo si manifesta come pause GC, che il flag -N di GHC e il dimensionamento della nursery possono ridurre ma non eliminare.

Rust non usa alcun garbage collector. La memoria viene liberata in modo deterministico quando la variabile proprietaria esce dal suo scope. Box, Rc, Arc e le collezioni standard gestiscono la memoria heap, ma tutte rilasciano il contenuto in un punto noto. Il compromesso e che dovete soddisfare il borrow checker, che e un costo a tempo di compilazione in sforzo dello sviluppatore, non un costo a runtime in pause.

Caratteristiche prestazionali

Rust compila in codice nativo senza overhead a runtime oltre a cio che il programmatore richiede esplicitamente. Il compilatore (rustc, basato su LLVM) produce binari paragonabili in velocita a C e C++. La libreria standard di Rust evita le allocazioni nascoste: quando una funzione alloca, lo dichiara nella sua firma prendendo o restituendo un tipo posseduto.

Haskell compila in codice nativo tramite GHC, ma la valutazione pigra rende il ragionamento sulle prestazioni piu difficile. La valutazione pigra significa che le espressioni non vengono calcolate finche il loro valore non e richiesto. Questo consente astrazioni eleganti (liste infinite, pipeline componibili) ma puo anche costruire catene di calcoli non valutati chiamati thunk che consumano memoria in modo inatteso. Le annotazioni strict (!, BangPatterns, seq) risolvono questo problema, ma sapere dove posizionarle e una competenza acquisita.

Nei benchmark come il Computer Language Benchmarks Game, i programmi Rust sono tipicamente da 2 a 10 volte piu veloci dei programmi Haskell equivalenti e usano significativamente meno memoria. Il divario si riduce quando il codice Haskell e ottimizzato con cura, ma lo sforzo di base richiesto e superiore.

Concorrenza e parallelismo

Il runtime di Haskell fornisce thread verdi leggeri (lanciati da forkIO), memoria transazionale software (STM) e la libreria async per la concorrenza strutturata. Poiche il codice puro non ha effetti collaterali, e trivialmente sicuro eseguirlo in parallelo: il compilatore puo persino parallelizzare automaticamente i calcoli puri con par e pseq.

Rust previene le data race a tempo di compilazione tramite l'ownership. Send e Sync sono trait marker che il compilatore verifica automaticamente: un tipo che non e sicuro inviare tra thread semplicemente non compilera in un contesto che tenta di farlo. Il runtime tokio fornisce un esecutore async; rayon fornisce il parallelismo dei dati. Entrambi sono librerie, non funzionalita del linguaggio.

La differenza pratica: Haskell rende la concorrenza facile da scrivere ma piu difficile da prevedere (i thunk pigri possono migrare tra thread). Rust rende la concorrenza piu difficile da scrivere (il borrow checker e rigoroso sullo stato mutabile condiviso) ma piu facile da prevedere (sapete esattamente cosa gira dove).

Ecosistema e strumenti

Il gestore di pacchetti di Rust e cargo. Gestisce compilazione, test, benchmarking, documentazione e risoluzione delle dipendenze. Il registro, crates.io, ospita oltre 150.000 crate nel 2026. rustfmt formatta il codice, clippy lo analizza, ed entrambi sono distribuiti con la toolchain.

I principali strumenti di build di Haskell sono cabal-install e stack, che coesistono in modo un po' scomodo. Hackage ospita circa 17.000 pacchetti. ghcup gestisce le versioni di GHC e della toolchain. L'Haskell Language Server (HLS) fornisce le funzionalita IDE. L'ecosistema e piu piccolo ma profondo in domini specifici: parsing (megaparsec, attoparsec), compilatori, metodi formali e modellazione finanziaria.

Curva di apprendimento

Entrambi i linguaggi sono difficili da imparare rispetto a Python o JavaScript. Sono difficili in modi diversi.

Haskell richiede di imparare un nuovo paradigma di programmazione. Se provenite da un background imperativo, monadi, funtori, applicativi, classi di tipi e valutazione pigra sono concetti genuinamente nuovi. La sintassi e insolita, e i messaggi di errore di GHC possono essere criptici finche non imparate a leggere i report di discordanza dei tipi.

Rust richiede di imparare un nuovo modello di memoria. I concetti di ownership, borrowing, lifetime e la distinzione tra Copy e Clone non hanno un equivalente diretto nella maggior parte dei linguaggi. Il borrow checker rifiuta codice che compilerebbe senza problemi in C++, e capire perche e la parte difficile.

Quando scegliere quale

Scegliete Haskell quando la correttezza della logica conta piu del controllo sull'hardware. Compilatori, interpreti, parser, linguaggi specifici di dominio, motori di regole finanziarie e prototipi di ricerca sono buoni candidati. Se il vostro problema si esprime meglio come composizione di trasformazioni pure, Haskell vi permette di scriverlo direttamente.

Scegliete Rust quando avete bisogno di prestazioni prevedibili senza garbage collector. Programmazione di sistema, firmware embedded, motori di gioco, moduli WebAssembly, servizi di rete con vincoli stretti di latenza e strumenti a riga di comando che devono avviarsi istantaneamente sono buoni candidati. Se il vostro programma non deve fare pause, Rust lo impone strutturalmente.

Si sovrappongono nei backend web (Haskell ha Servant e Yesod; Rust ha Actix-web e Axum), negli strumenti CLI e nell'elaborazione dati. In questi ambiti la scelta dipende dal fatto che preferiate il prototipaggio rapido con astrazioni forti (Haskell) o il throughput grezzo con controllo esplicito (Rust).

Cosa hanno in comune

Entrambi i linguaggi usano tipi di dati algebrici (data in Haskell, enum in Rust). Entrambi hanno pattern matching esaustivo imposto dal compilatore. Entrambi supportano i generici (polimorfismo parametrico in Haskell, parametri di tipo generico in Rust). Entrambi hanno trait o classi di tipi come meccanismo per il polimorfismo ad-hoc. Entrambi producono binari autonomi senza interprete.

Ed entrambi premiano il programmatore che legge attentamente i messaggi di errore del compilatore, perche in entrambi i casi il compilatore ha generalmente ragione.

Letture correlate: cos'e WebAssembly.