Haskell (linguaggio di programmazione)

Haskell linguaggio di programmazione
Autore	Simon Peyton Jones, Lennart Augustsson, Dave Barton, Brian Boutel, Warren Burton, Joseph Fasel, Kevin Hammond, Ralf Hinze, Paul Hudak, John Hughes, Thomas Johnsson, Mark Jones, John Launchbury, Erik Meijer, John Peterson, Alastair Reid, Colin Runciman, Philip Wadler
Data di origine	1990
Ultima versione	Haskell 2010 (luglio 2010)
Utilizzo	general-purpose
Paradigmi	funzionale, modulare
Tipizzazione	forte, statica
Estensioni comuni	.hs, .lhs
Influenzato da	Clean, FP, Gofer, Hope e Hope+, Id, ISWIM, KRC, Lisp, Miranda, ML e Standard ML, Orwell, SASL, SISAL, Scheme
Ha influenzato	Agda, Bluespec, C++11/Concepts, C#/LINQ, CAL, Cayenne, Clean, Clojure, CoffeeScript, Curry, D, Elm, Epigram, Escher, F#, Isabelle, Java/Generics, Kaya, Mercury, Omega, Perl 6, Python, Qi, Scala, Timber, Visual Basic 9.0, Rust
Implementazione di riferimento
Sistema operativo	Multipiattaforma
Sito web	www.haskell.org
Modifica dati su Wikidata · Manuale

Haskell è un linguaggio di programmazione puramente funzionale general-purpose creato da un apposito comitato alla fine degli anni ottanta principalmente per analizzare le caratteristiche dei linguaggi^[1]. È stato chiamato così in onore del matematico e logico statunitense Haskell Curry.

Lo stesso argomento in dettaglio: Programmazione funzionale.

Tutto iniziò nel 1978 con il discorso di John Backus intitolato "Can Programming be liberated from the Von Neumann style?"^[2] con il quale si proponeva la programmazione funzionale non solo come una mera curiosità matematica, bensì anche per scopi industriali.

Tra gli anni settanta ed ottanta del XX secolo, vennero implementati diversi linguaggi funzionali, seppur ancora strettamente legati ai linguaggi imperativi, che si basavano più sul concetto computazionale del lambda calcolo. Alcuni esempi possono essere Scheme, e i vari dialetti ML di questo periodo.

Nello stesso periodo, venne formulata la valutazione pigra (lazy evaluation, call-by-need) grazie alla pubblicazione di alcuni saggi. In seguito, questo nuovo sistema di valutazione, venne implementato in LazyML, Clean, Daisy, Orwell.

Dalla metà degli anni ottanta, numerosi ricercatori richiedevano un linguaggio di programmazione puramente funzionale e basato sul concetto del call-by-need. Nel 1987, due dei principali fondatori del comitato per la creazione del nuovo linguaggio, Simon Peyton Jones e Paul Hudak, si incontrarono a Yale per proseguire verso la conferenza Functional Programming and Architecture Conference (FPAC).

Per gettare basi solide di un nuovo linguaggio standardizzato, i ricercatori riuniti al FPAC, decisero di partire da quello sviluppato da David Turner, Miranda che era già puramente funzionale e aveva una robusta implementazione. Ma Turner, visto che il linguaggio aveva già avuto una discreta diffusione, si rifiutò di separarlo in diversi dialetti. Malgrado questo fatto, Miranda, rimarrà la principale influenza di Haskell.

Il nuovo comitato venne formato a Yale nel 1988, il suo scopo fu di formulare un linguaggio che rispettasse principalmente le seguenti caratteristiche^[3]:

• Adatto all'insegnamento, alla ricerca, alle applicazioni e alla costruzione di grandi sistemi;
• Completamente descritto attraverso la pubblicazione di una sintassi e semantica formale;
• Gratuitamente disponibile;
• Basato su idee con ampio consenso;
• Ridurre la diversità nei linguaggi funzionali.

Dopo due anni, cioè il 1º aprile 1990, venne pubblicata la prima versione del linguaggio che verrà chiamata Haskell 1.0 in onore a Haskell Curry, e l'inizio della pubblicazione inizia proprio con una citazione del famoso matematico statunitense^[4].

Dopo numerose versioni (1.1, 1.2, 1.3, 1.4) che si susseguirono tra il 1990 ed il 1998, c'era il bisogno di creare una versione stabile, considerato che i numerosi problemi che affliggevano il linguaggio, come quelli relativi all I/O, erano stati superati.

Nel 1998 fu pubblicato "The Haskell 98 Report: Language and Libraries"^[3], che contiene la descrizione dello standard e di alcune librerie, il quale verrà ulteriormente revisionato da Simon Peyton Jones e ripubblicato nel 2002.

Nel 2006 fu creato il comitato Haskell Prime (Haskell')^[5], il cui scopo è di produrre una revisione dello standard del 1998.

Nel 2009 è stata annunciata una nuova versione di Haskell chiamata Haskell 2010^[6]. Le modifiche principali apportate furono la rimozione dell'n+k pattern e l'implementazione di numerose espressioni semplificate o anche chiamate zucchero sintattico (syntactic sugar), come la notazione do, le guards, l'espressione if then else.

Tra le sue funzionalità Haskell presenta la valutazione pigra, le espressioni lambda, pattern matching, comprensione di lista, classi di tipi, e polimorfismo. È un linguaggio puramente funzionale, il che significa che le funzioni sono in genere pure, ovvero senza effetti collaterali. Esiste un costrutto diverso apposta per rappresentare gli effetti collaterali, ed è ortogonale alle funzioni. Una funzione pura può restituire un effetto collaterale che è successivamente eseguito, imitando così le funzioni impure degli altri linguaggi.

Haskell ha un sistema di tipi forte e statico, basato sull'inferenza di Hindley-Milner. La principale innovazione portata in questo campo sono le classi di tipi, concepite in origine come maniera di principio per introdurre il sovraccarico,^[7] ma nel seguito usate in molti altri ambiti.^[8]

Il costrutto che rappresenta gli effetti collaterali è un esempio di monade: un quadro generale che può modellizzare vari calcoli come la gestione degli errori, il nondeterminismo, l'analisi sintattica e la memoria transazionale. Sono definite come tipi di dato ordinari, ma Haskell fornisce un po' di zucchero sintattico per facilitarne l'uso.

Haskell ha una specifica aperta e pubblica e ne esistono numerose implementazioni. La principale, il Glasgow Haskell Compiler (GHC), è sia un interprete sia un compilatore di codice nativo e gira su molte piattaforme. GHC è noto per il suo ricco sistema di tipi che incorpora innovazioni recenti come i tipi di dati algebrici generalizzati e le famiglie di tipi. Il Computer Language Benchmarks Game ne evidenzia anche l'implementazione ad alte prestazioni della concorrenza e del parallelismo.^[9]

Intorno al linguaggio esiste una comunità attiva e in crescita e più di 5.400 librerie e strumenti liberi di terze parti sono disponibili in rete nell'archivio di pacchetti Hackage.^[10]

Il seguente esempio stampa il testo "Hello World".

main = do
  putStrLn "Hello World!"

Una versione un po' più interattiva:

main :: IO ()
main = do
    putStr   "Scrivi il tuo nome:"
    nome     <- getLine
    putStrLn $ "Ciao " ++ nome

Classica definizione del fattoriale con pattern matching:

fac :: Int -> Int
fac 0 = 1
fac n = n * fac (n-1)

Un'altra definizione più ristretta, utilizzando la funzione product:

fac' n = product 

Definizione con pattern matching per numeri naturali e applicazione di higher order functions:

fib   :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

La più efficiente implementazione, tuttavia, è questa^[11]:

import Data.List
import Data.Bits
 
fib :: Int -> Integer
fib n = snd . foldl' fib' (1, 0) . dropWhile not $
            ]
    where
        fib' (f, g) p
            | p         = (f*(f+2*g), ss)
            | otherwise = (ss, g*(2*f-g))
            where ss = f*f+g*g

Un'altra possibile implementazione passa attraverso l'utilizzo della ricorsione in coda e l'applicazione parziale di una funzione:

-- Generica successione
addSeries :: Int -> Int -> Int -> Integer
addSeries a _ 0 = a
addSeries a b n = addSeries b (a + b) (n - 1)

-- Applicazione parziale della funzione addSeries
fib :: Int -> Integer
fib = addSeries 0 1 -- sono passati solo i termini iniziali della serie

Falsa^[12] implementazione polimorfa con pattern matching e list comprehension :

qsort        :: Ord a =>  -> 
qsort      = 
qsort (x:xs) = qsort l1 ++  ++ qsort l2
                where
                    l1 = 
                    l2 = 

primes = dropall  
    where
        dropall (x:xs) = x:dropall(dropmul x xs) 
            where
                dropmul x l = 

• Glasgow Haskell Compiler ( The Glasgow Haskell Compiler), o GHC, costituisce il compilatore Haskell più diffuso ad oggi, grazie a numerosi plugin e all'efficienza tale che gli permette un confronto diretto con il C++, in alcuni casi^[13].
• Utrecht Haskell Compiler (UHC), sviluppato dall'Università di Utrecht.

Segue un elenco di implementazioni diventate ormai obsolete:

• Hugs ( Hugs 98), o Haskell User's Gofer System, è un interprete bytecode portabile per numerose piattaforme. Grazie anche ad un'interfaccia grafica e alla modalità interattiva, costituisce un mezzo eccellente per apprendere il linguaggio Haskell. Da quando è stato creato GHCi, l'interprete interattivo di GHC, non viene più usato.
• nhc98 ( nhc98 (archiviato dall'url originale il 5 febbraio 2005)), compilatore bytecode particolarmente adatto a macchine un po' datate grazie al ridotto uso di memoria.
• yhc ( Neil Mitchell - Yhc (archiviato dall'url originale il 3 febbraio 2006)), o York Haskell Compiler, è un fork di nhc98 mirato ad aumentarne le performance e la portabilità.
• jhc ( jhc) è un compilatore mirato a produrre codice ottimizzato il più possibile, ma allo stato attuale è da considerarsi sperimentale.

Alcune delle principali aziende in cui viene utilizzato Haskell:^[14]

• AT&T
• Facebook
• Galois, Inc.
• Google
• Intel
• Microsoft
• NVIDIA
• Qualcomm, Inc.
• Digital asset Holdings

Tra le librerie per lo sviluppo lato server troviamo:

• wai: Haskell Web Application Interface, un insieme di interfacce per lo sviluppo di applicazioni web;^[15]
• warp: un web server veloce e leggero per applicazioni che implementano le interfacce di wai;^[16]
• scotty: un framework web ispirato da Sinatra, pensato per essere semplice;^[17]
• spock: più leggero dei framework detti enterprise, ma avente più funzionalità di scotty;^[18]
• yesod: un framework enterprise per lo sviluppo di applicazioni web;^[19]
• snap: un altro framework enterprise;^[20]
• happstack-server: un altro framework enterprise;^[21]
• servant: una libreria che usa i tipi per definire le interfacce REST.^[22]

Librerie grafiche e lo sviluppo di videogiochi:

• apecs: una implementazione molto efficiente e type-driven;^[23]
• gelatin: una collezione di funzionalità grafiche che si basa su sdl, freetype e openGL;^[24]
• sdl2: package che fa da tramite con la libreria Simple DirectMedia Layer.^[25]

• Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler, A history of Haskell: Being Lazy With Class, San Diego, CA, 2007.
• Graham Hutton, Programming in Haskell, Cambridge University Press, 2007, pp.  170, ISBN 978-0-521-87172-3.

• Linguaggio di programmazione
• Programmazione funzionale
• Tipizzazione forte
• Tipizzazione statica
• Valutazione lazy

• Miranda (linguaggio di programmazione)
• Objective Caml
• Scheme
• DAML
• Lisp
• ML (linguaggio di programmazione)

• Wikimedia Commons contiene immagini o altri file su Haskell

• (EN) Sito ufficiale, su haskell.org.
• (EN) Opere riguardanti Haskell, su Open Library, Internet Archive.
• (EN) Hoogle, su haskell.org.
• (EN) Hayoo, su hayoo.fh-wedel.de (archiviato dall'url originale il 28 gennaio 2016).

• Learn Haskell, su github.com.
• (EN) The Haskell Wiki, su haskell.org.
• (EN) School of Haskell, su schoolofhaskell.com.

• (EN) Learn You a Haskell for Great Good!, su learnyouahaskell.com.
• (EN) Bryan O'Sullivan, Don Stewart, John Goerzen, Real World Haskell, su book.realworldhaskell.org, O'Reilly Media, 2008.

• Haskell-Cafe Archives, su mail.haskell.org.
• Haskell Archives, su mail.haskell.org.
• Planet Haskell, su planet.haskell.org.

Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica