# Haskell: impararlo in modo semplice

Tra i linguaggi di programmazione funzionale, [Haskell](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/haskell/ "Haskell") svolge un ruolo speciale. Infatti, dalla definizione della prima versione nel 1990, Haskell è considerato **quasi come uno standard** per i linguaggi di programmazione che seguono il [paradigma di programmazione](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/paradigmi-di-programmazione/ "Paradigmi di programmazione") funzionale. Non a caso tanti altri linguaggi funzionali sono influenzati da Haskell. Imparare questo linguaggio di programmazione all’inizio può risultare alquanto frustrante, soprattutto perché i **concetti di programmazione funzionale** appaiono molto singolari agli occhi degli utenti inesperti. Una volta superate le prime difficoltà, però, anche i principianti saranno in grado di tuffarsi con successo nel mondo della programmazione con Haskell.

Nel seguente tutorial vi presenteremo la **modalità più semplice per iniziare,** vi illustreremo i singoli passaggi e vi spiegheremo come installare il linguaggio funzionale e il funzionamento preciso della programmazione con Haskell.

## Installare e avviare Haskell: come funziona

Come per tanti altri linguaggi di programmazione, anche con Haskell si hanno varie opzioni per preparare il proprio sistema al lavoro con questo linguaggio di programmazione. La soluzione più usata di tutte, per imparare e programmare facilmente con questo linguaggio, è **GHCi**. Si tratta di un **ambiente di sviluppo interattivo** pronto all’uso, disponibile con il pacchetto [Glasgow Haskell Compiler](https://www.haskell.org/ghc/ "Sito ufficiale di Glasgow Haskell Compilers (GHC)"). Oltre al compilatore, sono necessarie anche le librerie di Haskell, per le quali avrete bisogno di un **building software** come [Cabal](https://www.haskell.org/cabal/ "Costruire applicazioni e biblioteche con Cabal") o [Stack](https://docs.haskellstack.org/en/stable/README/ "Stack: building software di Haskell").

N.B. La combinazione del compilatore di Haskell e il corrispondente sistema di sviluppo si definisce anche **piattaforma Haskell**.

Per cominciare nel modo più semplice possibile, consigliamo di installare la piattaforma Haskell completa. Sul [sito ufficiale del progetto Haskell](https://www.haskell.org/platform/ "haskell.org") potete trovare i **file d’installazione** pronti all’uso **per Windows, macOS** e diverse distribuzioni di **Linux** da scaricare gratuitamente.

[![Immagine: Tutorial su Haskell: file d’installazione sul sito di Haskell](https://www.ionos.it/digitalguide/fileadmin/_processed_/2/e/csm_DE-haskell-tutorial-1_bd677df9a8.webp "Tutorial su Haskell: file d’installazione sul sito di Haskell")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-1.png) Tutorial su Haskell: file d’installazione sul sito di Haskell Nei sistemi di Linux potete intraprendere il percorso d’installazione anche attraverso il **gestore di pacchetti**. Se siete utenti di Ubuntu o Debian, digitate il seguente **comando** nel terminale:

```none
sudo apt-get install haskell-platform
```

Una volta concluso il processo d’installazione, dovreste riuscire ad **avviare** l’ambiente di sviluppo interattivo digitando il comando “**ghci**” nella riga di comando del vostro sistema. Con Windows, questo avviene tramite il [PowerShell](https://www.ionos.it/digitalguide/server/know-how/powershell/), consigliato anche per l’installazione.

N.B. Tenete conto del fatto che le **versioni della piattaforma Haskell nel gestore di pacchetti** non sono sempre le più aggiornate. In alcune circostanze può anche essere necessario un aggiornamento dei file d’installazione!

## Conoscere Haskell: comprendere i tipi di dati fondamentali

Haskell è un linguaggio puramente funzionale, fattore che lo rende molto più interattivo e intelligente rispetto ad altri linguaggi di programmazione. Tipi di dati come **numeri, lettere** o **valori logici** (booleani) su Haskell sono già predefiniti o ripartiti in modo intelligente dalla memoria del computer.

### Numeri su Haskell

Haskell riconosce i numeri naturali come tali. Sul piano concreto questo significa che nel codice di Haskell non dovrete definire al momento dell’**input** che si tratta di **un numero**. Una volta avviato l’ambiente di sviluppo, potrete svolgere semplicemente dei calcoli con i soliti operatori come il più (+) o il meno (-). Digitate ad esempio “2+2” e confermate l’input con il tasto Invio:

```none
Prelude> 2+2
```

Haskell vi presenterà il **risultato** di questo calcolo aritmetico: 4.

[![Immagine: Windows PowerShell: esempio di programmazione Haskell](https://www.ionos.it/digitalguide/fileadmin/_processed_/d/9/csm_DE-haskell-tutorial-2_171e682fc3.webp "Windows PowerShell: esempio di programmazione Haskell")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-2.png) Windows PowerShell: esempio di programmazione Haskell ### Lettere su Haskell

Haskell può riconoscere anche le lettere in modo intelligente, come vi dimostriamo di seguito con un esempio. In primo luogo inseriamo nella riga di comando l’opzione “:t”. Questo permette alla riga di comando di indicare il tipo di dato da emettere dopo la conferma. Dopo aver lasciato uno spazio bianco, inserite una lettera a piacere **tra virgolette singole o doppie** e inviate l’input premendo il tasto Invio:

```none
Prelude>:t "a"
```

In questo caso, il risultato indicherà correttamente “**\[Char\]**” abbreviazione del termine inglese “character” (in italiano: lettera).

[![Immagine: Conoscere Haskell: output con lettera](https://www.ionos.it/digitalguide/fileadmin/_processed_/e/a/csm_DE-haskell-tutorial-3_dab276bb28.webp "Conoscere Haskell: output con lettera")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-3.png) Conoscere Haskell: output con lettera ### Stringhe su Haskell

Haskell riesce a riconoscere senza problemi anche le stringhe, che nei linguaggi di programmazione sono conosciute soprattutto con il termine inglese “strings”. Anche in questo caso non è richiesta una sintassi specifica, vi basterà **inserire la stringa tra virgolette**. Un esempio è l’input seguente composto da numeri e lettere:

```none
Prelude>:t "12345abcde"
```

Visto che anche qui abbiamo inserito l’opzione “:t”, Haskell ci comunicherà nuovamente di che tipo di dato si tratta. Come nel caso della lettera singola, la riga di comando indicherà “\[Char\]”.

[![Immagine: Haskell: input di stringa su ghci (Windows PowerShell)](https://www.ionos.it/digitalguide/fileadmin/_processed_/3/1/csm_DE-haskell-tutorial-4_2b149dd2cd.webp "Haskell: input di stringa su ghci (Windows PowerShell)")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-4.png) Haskell: input di stringa su ghci (Windows PowerShell) ## Conoscere Haskell: presentazione delle operazioni più importanti

Come già anticipato, Haskell si presta allo svolgimento delle **operazioni algebriche più comuni** (addizione, sottrazione, divisione e moltiplicazione). Si può anche usare l’operatore di sequenza o di gamma per elencare facilmente le sequenze di valori.

N.B. Per eseguire e mostrare i risultati dei seguenti codici snippet in questo tutorial su Haskell, abbiamo utilizzato l’ambiente di sviluppo web [Online Haskell Compiler](https://www.tutorialspoint.com/compile_haskell_online.php "tutorialspoint.com: Online Haskell Compiler").

### Addizioni su Haskell

Anche l’operatore di addizione per il calcolo di due o più valori è indicato su Haskell con il classico **simbolo più** (+). Nel seguente esempio di codice, che inseriremo nel file ***main.hs***, con l’aiuto della condizione “**let**” uniamo due variabili (“var1” e “var2”) che dovranno essere sommate tra loro. La riga di comando presenterà infine il risultato sotto forma di un **messaggio di testo**, definito nella condizione “**putStrLn**”:

```none
main = do
let var1 = 2
let var2 = 3
putStrLn "Il risultato delle due cifre sommate tra loro."
print(var1 + var2)
```

Nello strumento online sopra menzionato, vedrete l’**input** (finestra a sinistra) e l’**output** (finestra a destra) come mostrato di seguito:

[![Immagine: Esempio su Haskell: addizione di due valori](https://www.ionos.it/digitalguide/fileadmin/_processed_/c/e/csm_DE-haskell-tutorial-5_cd337dd8a9.webp "Esempio su Haskell: addizione di due valori")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-5.png) Esempio su Haskell: addizione di due valori ### Sottrazioni su Haskell

Per indicare a Haskell di sottrarre un valore numerico ad un altro, bisogna usare il classico operatore di sottrazione, vale a dire il simbolo meno (-). Il seguente esempio di codice è molto simile a quello usato per le addizioni, bisogna semplicemente sostituire l’operatore e modificare leggermente il messaggio di output:

```none
main = do
let var1 = 2
let var2 = 3
putStrLn "Il risultato della sottrazione tra i due numeri è:"
print(var1 - var2)
```

[![Immagine: Haskell: sottrazione di due variabili di un valore](https://www.ionos.it/digitalguide/fileadmin/_processed_/8/6/csm_DE-haskell-tutorial-6_f19db2705d.webp "Haskell: sottrazione di due variabili di un valore")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-6.png) Haskell: sottrazione di due variabili di un valore  N.B. Anche per le operazioni di **divisione** e **moltiplicazione**, Haskell utilizza i simboli più comuni: con lo slash o barra (/) potrete dividere i valori, con il simbolo dell’asterisco (\*) indicherete a Haskell di moltiplicare i valori.

### Elenco di valori su Haskell

L’operatore di sequenza è un operatore speciale di Haskell che vi permette in modo semplice **di dichiarare un elenco con una sequenza di valori**, e si indica con “**\[..\]**”. Se volete ad esempio che Haskell vi mostri tutti i numeri da 1 a 10, potete indicare per questo spettro numerico l’input “\[1..10\]”. Lo stesso vale per le lettere: con “\[a..z\]”, ad esempio, darete l’input affinché Haskell emetta l’intero alfabeto. Anche per l’operatore di sequenza abbiamo preparato un semplice esempio:

```none
main ::IO()
main = do
print [1..10]
```

[![Immagine: Esempio di Haskell: operatore di sequenza](https://www.ionos.it/digitalguide/fileadmin/_processed_/0/6/csm_DE-haskell-tutorial-7_5aa4613393.webp "Esempio di Haskell: operatore di sequenza")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-7.png) Esempio di Haskell: operatore di sequenza ## Haskell: come dichiarare e definire le funzioni

Haskell è un linguaggio puramente funzionale. Non sarà dunque una grande sorpresa scoprire che le funzioni svolgono un ruolo fondamentale nella programmazione con Haskell. Come tanti altri linguaggi, anche Haskell ha un suo modo per **dichiarare** e **definire le funzioni**.

N.B. La **dichiarazione** di una funzione suggerisce al compilatore l’esistenza di una funzione precisa. Inoltre, gli indica i parametri da attendere e l’aspetto che dovrà avere l’output. La **definizione** di una funzione definisce l’inclusione effettiva della funzione nel codice.

Per rendere il concetto di funzione con Haskell ancora più comprensibile, guardiamo di nuovo un esempio concreto di codice:

```none
add ::Integer -> Integer -> Integer   --function declaration
add x y =  x + y                       --function definition
main = do
putStrLn "La somma dei due numeri è: "
print(add 3 5)    --calling a function
```

Nella prima riga del codice è dichiarata la funzione: tutti e tre i valori della funzione (input e output) sono numeri interi (Integer). Nella riga 2 si definisce la funzione: vengono sommati i due argomenti “x” e “y”. Con il **metodo** “**main**”, già anticipato, si procederà alla compilazione del codice e l’indicazione del risultato della funzione per entrambi i valori di input “3” e “5”.

[![Immagine: Conoscere Haskell: dichiarazione e definizione di una funzione](https://www.ionos.it/digitalguide/fileadmin/_processed_/6/9/csm_DE-haskell-tutorial-8_538ea10e5e.webp "Conoscere Haskell: dichiarazione e definizione di una funzione")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-8.png) Conoscere Haskell: dichiarazione e definizione di una funzione Nel seguente tutorial YouTube per principianti, troverete una panoramica ancora più approfondita sul lavoro con le funzioni di Haskell:

[YouTube video](https://www.youtube.com/watch?v=AtsPtAf2avQ)## Altri consigli per conoscere e programmare con Haskell

Haskell è un linguaggio molto popolare perciò online troverete molti manuali, tutorial e forum di aiuto. Vi consigliamo ad esempio la **serie di tutorial YouTube** [“Haskell for Imperative Programmers”](https://www.youtube.com/playlist?list=PLe7Ei6viL6jGp1Rfu0dil1JH1SHk9bgDV "Serie di tutorial su YouTube “Haskell for Imperative Programmers“") di Philipp Hagenlocher, che riassume le componenti più importanti del linguaggio funzionale **nei 30 video in cui tratta diverse tematiche su Haskell**. Un’ampia panoramica per trovare ulteriore assistenza nel web è fornita dalla [Community del sito ufficiale di Haskell](https://www.haskell.org/community/ "haskell.org:Community"). Consigliamo agli amanti della carta stampata di investire nel **libro** [“Haskell from the very beginning”](https://www.haskellfromtheverybeginning.com/ "Sito ufficiale di “Haskell from the very beginning“") di John Whitington.

Se utilizzate l’ambiente di sviluppo ghci, mentre imparate a usare Haskell potete farvi **mostrare** una **panoramica** completa **di tutti i comandi disponibili**. Vi basta digitare il seguente codice nella riga di comando e confermare l’input con il tasto invio:

```none
Prelude>:?
```

[![Immagine: Tutorial Haskell: panoramica dei comandi ghci](https://www.ionos.it/digitalguide/fileadmin/_processed_/5/6/csm_DE-haskell-tutorial-9_4dca38c27d.webp "Tutorial Haskell: panoramica dei comandi ghci")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-9.png) Tutorial Haskell: panoramica dei comandi ghci


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tutorial-haskell/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tutorial-haskell/) for AI/LLM consumption.