Haskell (linguaggio di programmazione): differenze tra le versioni

Versione delle 19:29, 29 ago 2017

Versione attuale delle 00:33, 13 mar 2025

(40 versioni intermedie di 25 utenti non mostrate)

Riga 1:

{{Linguaggio di programmazione

|nome = Haskell

Line 5 ⟶ 4:

|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 = 1990

|utilizzo = general-purpose

|versione = Haskell 2010 (luglio 2010)

|paradigmi = [[Programmazione funzionale|funzionale]], [[Modularità (informatica)|modulare]]

|tipizzazione = [[Tipizzazione forte|forte]], [[Tipizzazione statica|statica]]

|estensione = .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_sharpC sharp|C#]]/[[LINQ]], CAL, Cayenne, Clean, [[Clojure]], CoffeeScript, Curry, [[D (linguaggio)|D]], Elm, Epigram, Escher, [[F Sharp|F#]], Isabelle, [[Java (linguaggio di programmazione)|Java]]/[[Generics Java|Generics]], Kaya, [[Mercury (linguaggio)|Mercury]], Omega, [[Perl 6]], [[Python]], Qi, [[Scala (linguaggio di programmazione)|Scala]], Timber, [[Visual Basic|Visual Basic 9.0]], [[Rust (linguaggio di programmazione)|Rust]]

|sistema_operativo = [[Multipiattaforma]]

|sito_web =[https://www.haskell.org/ Haskell Language]

}}

'''Haskell''' è un [[linguaggio di programmazione]] [[Linguaggio funzionale|puramente funzionale]] [[General purpose|general-purpose]] creato da un apposito comitato alla fine degli [[Anni 1980|anni ottanta]] principalmente per analizzare le caratteristiche dei linguaggi<ref>{{Citazione|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|We wanted a language that could be used, among other purposes, for research into language features;|lingua = EN}}</ref>. È stato chiamato così in onore del matematico e logico statunitense [[Haskell Curry]].

== Storia ==

=== L'inizio della programmazione funzionale ===

{{Per approfondire|Programmazione funzionale}}Tutto iniziò nel [[1978]] con il discorso di John Backus intitolato ''"Can Programming be liberated from the Von Neumann style?"''<ref>[{{cita testo|url=http://worrydream.com/refs/Backus-CanProgrammingBeLiberated.pdf |titolo=Can Programming Be Liberated from Von Neumann Style?]}}</ref> con il quale si proponeva la programmazione funzionale non solo come una mera curiosità matematica, bensì anche per scopi industriali.

Tra gli anni [[Anni 1970|settanta]] ed [[Anni 1980|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 (linguaggio di programmazione)|ML]] di questo periodo.

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

=== Haskell ===

Dalla metà degli [[Anni 1980|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 [[Università di Yale|Yale]] per proseguire verso la conferenza '''Functional Programming and Architecture Conference (FPAC)'''.

Per gettare basi solide addi un nuovo standardizzato linguaggio standardizzato, i ricercatori riuniti al FPAC, decidonodecisero di partire da quello sviluppato da David Turner, [[Miranda (linguaggio di programmazione)|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 [[Università di Yale|Yale]] nel [[1988]], il suo scopo fu di formulare un linguaggio che rispettasse principalmente le seguenti caratteristiche<ref name=":0" />:

Line 36 ⟶ 33:

* 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<ref>{{Pdf|sorgente = [https://www.haskell.org/definition/haskell-report-1.0.ps.gz Report of the Programming Language Haskell A Non-Strict, Purely Functional Language, Version 1.0, 1 April 1990]}} {{Cita web|autore = |url = https://www.haskell.org/definition/haskell-report-1.0.ps.gz|titolo = Report of the Programming Language Haskell A Non-Strict, Purely Functional Language, Version 1.0|accesso = |data = 1990}} </ref>.

=== Haskell 98 ===

Dopo numerose versioni (1.1, 1.2, 1.3, 1.4) che si susseguirono tra il [[1988|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 [[Input/output|I/O]], erano stati superati.

Nel [[1998]] fu pubblicato ''"The Haskell 98 Report: Language and Libraries"''<ref name=":0">{{Cita web|url = https://www.haskell.org/onlinereport/|titolo = The Haskell 98 Language Report|accesso = 30 gennaio 2016|sito = www.haskell.org}}</ref>, 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 ===

Nel [[2006]] fu creato il comitato '''Haskell Prime''' ('''Haskell'''')<ref>{{Cita web|url = https://prime.haskell.org/|titolo = Haskell Prime|accesso = 31 gennaio 2016|sito = prime.haskell.org|urlarchivio = https://web.archive.org/web/20160220103915/https://prime.haskell.org/|urlmorto = sì}}</ref>, il cui scopo è di produrre una revisione dello standard del 1998.

Nel [[2009]] è stata annunciata una nuova versione di Haskell chiamatochiamata Haskell 2010<ref>{{Cita web|nome = Simon|cognome = Marlow|url = https://mail.haskell.org/pipermail/haskell/2009-November/021750.html|titolo = [Haskell] Announcing Haskell 2010|accesso = 30 gennaio 2016|data = 24 novembre 2009}}</ref>. Le modifiche principali apportate furono la rimozione del 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''.

== Caratteristiche ==

Tra le sue funzionalità Haskell presenta la [[valutazione pigra]], le [[Funzione anonima|espressioni lambda]], ''[[pattern matching]]'', [[comprensione di lista]], classi di tipi, e [[Polimorfismo (informatica)|polimorfismo]]. È un linguaggio puramente funzionale, il che significa che le funzioni sono in genere pure, ovvero senza [[Effetto collaterale (informatica)|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.

=== Valutazione Lazy ===

{{Per approfondire|Valutazione lazy}}

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 [[Overloading|sovraccarico]],<ref name="wadler89">{{Cita libro|cognome1=Wadler|nome1=P.|nome2=S. |cognome2=Blott|titolo=Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '89 |capitolo=How to make ad-hoc polymorphism less ad hoc |anno=1989|editore=[[Association for Computing Machinery|ACM]]|pp=60-76|doi=10.1145/75277.75283|isbn=978-0-89791-294-5}}</ref> ma nel seguito usate in molti altri ambiti.<ref name="hallgren01">{{Cita pubblicazione|cognome=Hallgren|nome=T.|data=gennaio 2001|titolo=Fun with Functional Dependencies, or Types as Values in Static Computations in Haskell|rivista=Proceedings of the Joint CS/CE Winter Meeting|città=Varberg, Sweden|url=http://www.cs.chalmers.se/~hallgren/Papers/wm01.html}}</ref>

=== Tipizzazione statica ===

{{Per approfondire|Tipizzazione statica}}

Il costrutto che rappresenta gli effetti collaterali è un esempio di [[Monade (informatica)|monade]]: un quadro generale che può modellizzare vari calcoli come la gestione degli errori, il [[Algoritmo nondeterministico|nondeterminismo]], l'[[Parsing|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.

=== Puramente funzionale ===

Haskell ha una specifica aperta e pubblica e ne esistono numerose implementazioni. La principale, il [[Glasgow Haskell Compiler]] (GHC), è sia un [[Interprete (informatica)|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.<ref name="shootout">{{cita testo|url=https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/haskell.html|titolo=Computer Language Benchmarks Game}}</ref>

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.<ref name="hackage-stats">{{cita web|url=http://hackage.haskell.org/cgi-bin/hackage-scripts/stats|urlarchivio=https://web.archive.org/web/20130503114836/http://hackage.haskell.org/cgi-bin/hackage-scripts/stats|titolo=HackageDB statistics|accesso=26 giugno 2013}}</ref>

== Codice di esempio ==

=== [[Hello world|Hello, world!]] ===

Il seguente esempio stampa il testo "Hello World".

<sourcesyntaxhighlight lang="haskell">

main ::= IO ()do

main = putStrLn "Hello World!"

</sourcesyntaxhighlight>Una versione un po' più ''interattiva'':<syntaxhighlight lang="haskell">

main :: IO ()

main = do

Line 72 ⟶ 71:

</syntaxhighlight>

=== Calcolo del [[fattoriale]] ===

Classica definizione del fattoriale con ''pattern matching:''

<sourcesyntaxhighlight lang="haskell">

fac :: Int -> Int

fac 0 = 1

fac n = n * fac (n-1)

</sourcesyntaxhighlight>Un'altra definizione più ristretta, utilizzando la funzione ''product'':<syntaxhighlight lang="haskell">

fac' n = product [1.. n]

</syntaxhighlight>

=== Calcolo della [[successione di Fibonacci]] ===

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

<sourcesyntaxhighlight lang="haskell">

fib :: Int -> Int

fib 0 = 0

fib 1 = 1

fib n = fib (n-1) + fib (n-2)

</syntaxhighlight>

</source>

La più efficiente implementazione, tuttavia, è questa<ref>{{Cita web|url = https://wiki.haskell.org/The_Fibonacci_sequence#Fastest_Fib_in_the_West|titolo = The Fibonacci sequence - HaskellWiki|accesso = 31 gennaio 2016|sito = wiki.haskell.org}}</ref>:

<sourcesyntaxhighlight lang="haskell">

import Data.List

import Data.Bits

Line 103 ⟶ 102:

| otherwise = (ss, g*(2*f-g))

where ss = f*f+g*g

</syntaxhighlight>

</source>

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

=== Algoritmo di ordinamento generico [[quicksort]] ===

<sourcesyntaxhighlight lang="haskell">

Falsa<ref>{{Cita web|url = http://stackoverflow.com/questions/7717691/why-is-the-minimalist-example-haskell-quicksort-not-a-true-quicksort|titolo = Why is the minimalist, example Haskell quicksort not a "true" quicksort?|accesso = 31 gennaio 2016|sito = stackoverflow.com}}</ref> implementazione polimorfa con ''pattern matching'' e ''list comprehension'' :

-- Generica successione

<source lang="haskell">

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

</syntaxhighlight>

=== Algoritmo di ordinamento generico [[quicksort]] ===

Falsa<ref>{{Cita web|url = httphttps://stackoverflow.com/questions/7717691/why-is-the-minimalist-example-haskell-quicksort-not-a-true-quicksort|titolo = Why is the minimalist, example Haskell quicksort not a "true" quicksort?|accesso = 31 gennaio 2016|sito = stackoverflow.com}}</ref> implementazione polimorfa con ''pattern matching'' e ''list comprehension'' :

<syntaxhighlight lang="haskell">

qsort :: Ord a => [a] -> [a]

qsort [] = []

Line 113 ⟶ 124:

l1 = [y | y <- xs, y<x]

l2 = [z | z <- xs, z>=x]

</syntaxhighlight>

</source>

=== [[Crivello di Eratostene]] ===

<sourcesyntaxhighlight lang="haskell">

primes = dropall [2..]

where

Line 121 ⟶ 132:

where

dropmul x l = [y | y <- l, y `mod` x /= 0]

</syntaxhighlight>

</source>

== Implementazioni ==

* '''''[[Glasgow Haskell Compiler]]''''' ([http{{cita testo|url=https://www.haskell.org/ghc/ |titolo=The Glasgow Haskell Compiler]|postscript=nessuno}}), 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<ref>{{Cita web|url = https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=ghc&lang2=gpp|titolo = Haskell GHC vs C++ g++ (64-bit Ubuntu quad core) {{!}} Computer Language Benchmarks Game|accesso = 30 gennaio 2016|sito = benchmarksgame.alioth.debian.org|urlarchivio = https://web.archive.org/web/20160416220709/http://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=ghc&lang2=gpp|urlmorto = sì}}</ref>''.''

* [[Utrecht Haskell Compiler]] ('''UHC'''), sviluppato dall'[[Università di Utrecht]].

=== Implementazioni obsolete ===

Segue un elenco di implementazioni diventate ormai obsolete:

* '''''[[Hugs]]''''' ([http{{cita testo|url=https://www.haskell.org/hugs/ |titolo=Hugs 98]|postscript=nessuno}}), 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 GHCIGHCi, l'interprete interattivo di GHC, non viene più usato.

* '''''nhc98''''' ([{{cita testo|url=http://www.cs.york.ac.uk/fp/nhc98/ |titolo=nhc98]|postscript=nessuno|urlarchivio=https://web.archive.org/web/20050205041736/http://www.cs.york.ac.uk/fp/nhc98/ }}), compilatore ''bytecode'' particolarmente adatto a macchine un po' datate grazie al ridotto uso di memoria.

* '''''yhc''''' ([{{cita testo|url=http://www-users.cs.york.ac.uk/~ndm/yhc/ |titolo=Neil Mitchell - Yhc]|postscript=nessuno|urlarchivio=https://web.archive.org/web/20060203214652/http://www-users.cs.york.ac.uk/~ndm/yhc/ }}), o ''York Haskell Compiler'', è un [[Fork (sviluppo software)|fork]] di nhc98 mirato ad aumentarne le performance e la portabilità.

* '''''jhc''''' ([{{cita testo|url=http://repetae.net/john/computer/jhc/ |titolo=jhc]|postscript=nessuno}}) è un compilatore mirato a produrre codice ottimizzato il più possibile, ma allo stato attuale è da considerarsi sperimentale.

== Applicazioni ==

=== Industriali ===

Alcune delle principali aziende in cui viene utilizzato Haskell:<ref>{{Cita web|url = https://wiki.haskell.org/Haskell_in_industry|titolo = Haskell in industry - HaskellWiki|accesso = 25 gennaio 2016|sito = wiki.haskell.org}}</ref>

Line 146 ⟶ 156:

* [[NVIDIA]]

* [[Qualcomm|Qualcomm, Inc.]]

*[[Digital asset holding|Digital asset Holdings]]

== Librerie ==

Tra le librerie per lo sviluppo lato server troviamo:

* wai: Haskell Web Application Interface, un insieme di interfacce per lo sviluppo di applicazioni web;<ref>{{cita testo|url=http://www.yesodweb.com/book/web-application-interface|titolo=Web Application Interface}}</ref>

* warp: un web server veloce e leggero per applicazioni che implementano le interfacce di wai;<ref>{{cita testo|url=https://www.stackage.org/package/warp|titolo=warp}}</ref>

* scotty: un framework web ispirato da Sinatra, pensato per essere semplice;<ref>{{cita testo|url=https://github.com/scotty-web/scotty/wiki/Scotty-Tutorials-&-Examples|titolo=Scotty Tutorials & Examples}}</ref>

* spock: più leggero dei framework detti enterprise, ma avente più funzionalità di scotty;<ref>{{cita testo|url=https://www.spock.li/|titolo=spock}}</ref>

* yesod: un framework enterprise per lo sviluppo di applicazioni web;<ref>{{cita testo|url=http://www.yesodweb.com/|titolo=Yesod}}</ref>

* snap: un altro framework enterprise;<ref>{{cita testo|url=https://github.com/snapframework/snap-server|titolo=snap-server}}</ref>

* happstack-server: un altro framework enterprise;<ref>{{cita testo|url=http://www.happstack.com/page/view-page-slug/1/happstack|titolo=Happstack}}</ref>

* servant: una libreria che usa i tipi per definire le interfacce REST.<ref>{{cita testo|url=https://haskell-servant.github.io/|titolo=Servant}}</ref>

Librerie grafiche e lo sviluppo di videogiochi:

* apecs: una implementazione molto efficiente e type-driven;<ref>{{Cita web|url=https://github.com/jonascarpay/apecs|titolo=Apecs library}}</ref>

* gelatin: una collezione di funzionalità grafiche che si basa su sdl, freetype e openGL;<ref>{{Cita web|url=https://github.com/schell/gelatin|titolo=Gelatin library}}</ref>

* sdl2: package che fa da tramite con la libreria [[Simple DirectMedia Layer]].<ref>{{Cita web|url=https://hackage.haskell.org/package/sdl2|titolo=SDL2}}</ref>

== Note ==

<references/>

== Bibliografia ==

* {{Cita testo|autore = Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler|titolo = A history of Haskell: Being Lazy With Class|editore = |città = San Diego, CA|data = 2007}}

* {{Cita libro|autore = Graham Hutton|titolo = Programming in Haskell|url = https://archive.org/details/programminghaske00libg|anno = 2007|editore = Cambridge University Press|città = |pp = {{cita testo|url=https://archive.org/details/programminghaske00libg/page/n182|titolo=170|postscript=nessuno}}|ISBN = 978-0-521-87172-3}}

== Voci correlate ==

=== Concetti correlati ===

* [[Linguaggio di programmazione]]

* [[Programmazione funzionale]]

* [[Tipizzazione forte]]

Line 168 ⟶ 195:

* [[Objective Caml]]

* [[Scheme]]

*[[DAML]]

* [[Lisp]]

* [[ML (linguaggio di programmazione)]]

== Altri progetti ==

{{interprogetto|commons=Category:Haskell}}

== Collegamenti esterni ==

* {{Collegamenti esterni}}

* {{cita web|http://www.haskell.org|The Haskell Home Page|lingua=en}}

* {{En}}{{Cita web|lingua=En|autore = |url = https://www.haskell.org/hoogle/|titolo = Hoogle|accesso = |data = }}

* {{En}}{{Cita web|lingua=En|autore = |url = http://hayoo.fh-wedel.de/|titolo = Hayoo|accesso = |data = |urlarchivio = https://web.archive.org/web/20160128185255/http://hayoo.fh-wedel.de/|urlmorto = sì}}

=== Tutorial ===

* {{Cita web|autore = |url = https://github.com/bitemyapp/learnhaskell/blob/master/guide-it.md|titolo = Learn Haskell|accesso = |data = }}

* {{cita web|httpurl=https://www.haskell.org/haskellwiki/|titolo=The Haskell Wiki|lingua=en}}

* {{En}}{{Cita web|lingua=En|autore = |url = https://www.schoolofhaskell.com/|titolo = School of Haskell|accesso = |data = }}

=== Libri di testo ===

* {{cita web|url=http://learnyouahaskell.com/chapters|titolo=Learn You a Haskell for Great Good!|lingua=en}}

* {{En}}{{Cita web|lingua=En|autore = Bryan O'Sullivan, Don Stewart, John Goerzen|url = http://book.realworldhaskell.org/|titolo = Real World Haskell|accesso = |editore = O'Reilly Media|data = 2008}}

=== Community ===

* {{Cita web|autore = |url = https://mail.haskell.org/pipermail/haskell-cafe/|titolo = Haskell-Cafe Archives|accesso = |data = }}

* {{Cita web|autore = |url = https://mail.haskell.org/pipermail/haskell/|titolo = Haskell Archives|accesso = |data = }}

* {{Cita web|autore = |url = https://planet.haskell.org/|titolo = Planet Haskell|accesso = |data = }}

{{Principali linguaggi di programmazione}}