Haskell (linguaggio)

Da Wikipedia, l'enciclopedia libera.
Haskell
Haskell-Logo.svg
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
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, Elm, Epigram, Escher, F#, Isabelle, Java/Generics, Kaya, Mercury, Omega, Perl 6, Python, Qi, Scala, Timber, Visual Basic 9.0
Implementazione di riferimento
Sistema operativo Multipiattaforma
Sito web Haskell Language

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.

Storia[modifica | modifica wikitesto]

L'inizio della programmazione funzionale[modifica | modifica wikitesto]

Exquisite-kfind.png 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 lazy (call-by-need) grazie alla pubblicazione di alcuni saggi. In seguito, questo nuovo sistema di valutazione, venne implementata in LazyML, Clean, Daisy, Orwell.

Haskell[modifica | modifica wikitesto]

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 ad un nuovo standardizzato linguaggio, i ricercatori riuniti al FPAC, decidono 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].

Haskell 98[modifica | modifica wikitesto]

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.

Haskell 2010[modifica | modifica wikitesto]

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 chiamato Haskell 2010[6]. Le modifiche principali apportate furono la rimozione del n+k pattern e l'implementazione di numerose espressioni semplificate o anche chiamate zucchero sintattico (syntatcic sugar), come la notazione do, le guards, l'espressione if then else.

Caratteristiche[modifica | modifica wikitesto]

Valutazione Lazy[modifica | modifica wikitesto]

Exquisite-kfind.png Lo stesso argomento in dettaglio: Valutazione lazy.

Tipizzazione statica[modifica | modifica wikitesto]

Exquisite-kfind.png Lo stesso argomento in dettaglio: Tipizzazione statica.

Puramente funzionale[modifica | modifica wikitesto]

Codice di esempio[modifica | modifica wikitesto]

Hello, world![modifica | modifica wikitesto]

Il seguente esempio stampa il testo "Hello World".

main :: IO ()
main = putStrLn "Hello World!"

Una versione un po' più interattiva:

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

Calcolo del fattoriale[modifica | modifica wikitesto]

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 [2.. n]

Calcolo della successione di Fibonacci[modifica | modifica wikitesto]

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[7]:

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

Algoritmo di ordinamento generico quicksort[modifica | modifica wikitesto]

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

qsort        :: Ord a => [a] -> [a]
qsort []     = []
qsort (x:xs) = qsort l1 ++ [x] ++ qsort l2
                where
                    l1 = [y | y <- xs, y<x]
                    l2 = [z | z <- xs, z>=x]

Crivello di Eratostene[modifica | modifica wikitesto]

primes = 1 : dropall [2..] 
    where
        dropall (x:xs) = x:dropall(dropmul x xs) 
            where
                dropmul x l = [y | y <- l, y `mod` x /= 0]

Implementazioni[modifica | modifica wikitesto]

Implementazioni obsolete[modifica | modifica wikitesto]

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), compilatore bytecode particolarmente adatto a macchine un po' datate grazie al ridotto uso di memoria.
  • yhc (Neil Mitchell - Yhc), 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.

Applicazioni[modifica | modifica wikitesto]

Industriali[modifica | modifica wikitesto]

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

Note[modifica | modifica wikitesto]

  1. ^
    (EN)

    « We wanted a language that could be used, among other purposes, for research into language features; »

    (IT)

    « Noi volevamo un linguaggio che potesse essere usato, oltre agli altri scopi, per studiare le caratteristiche del linguaggio; »

    (A History of Haskell: Being Lazy With Class, Simon Peyton Jones, Paul Hudak, John Hughes, Philip Wadler)
  2. ^ Can Programming Be Liberated from Von Neumann Style?
  3. ^ a b The Haskell 98 Language Report, su www.haskell.org. URL consultato il 30 gennaio 2016.
  4. ^ (PDF) Report of the Programming Language Haskell A Non-Strict, Purely Functional Language, Version 1.0, haskell.org, 1990.
  5. ^ Haskell Prime, su prime.haskell.org. URL consultato il 31 gennaio 2016.
  6. ^ Simon Marlow, [Haskell] Announcing Haskell 2010, mail.haskell.org, 24 novembre 2009. URL consultato il 30 gennaio 2016.
  7. ^ The Fibonacci sequence - HaskellWiki, su wiki.haskell.org. URL consultato il 31 gennaio 2016.
  8. ^ Why is the minimalist, example Haskell quicksort not a "true" quicksort?, su stackoverflow.com. URL consultato il 31 gennaio 2016.
  9. ^ Haskell GHC vs C++ g++ (64-bit Ubuntu quad core) | Computer Language Benchmarks Game, su benchmarksgame.alioth.debian.org. URL consultato il 30 gennaio 2016.
  10. ^ Haskell in industry - HaskellWiki, su wiki.haskell.org. URL consultato il 25 gennaio 2016.

Bibliografia[modifica | modifica wikitesto]

  • 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.

Voci correlate[modifica | modifica wikitesto]

Concetti correlati[modifica | modifica wikitesto]

Linguaggi correlati[modifica | modifica wikitesto]

Altri progetti[modifica | modifica wikitesto]

Collegamenti esterni[modifica | modifica wikitesto]

Tutorial[modifica | modifica wikitesto]

Libri di testo[modifica | modifica wikitesto]

Community[modifica | modifica wikitesto]

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