Brontekst bekijken van Haskell (programmeertaal)

{{Infobox programmeertaal
| naam = Haskell
| logo = Haskell-Logo.svg
| extensies = .hs, .lhs
| paradigma = puur [[Functioneel programmeren|functioneel]]
| jaar = 1990
| ontwerper = 
| ontwikkelaar = [[Simon Peyton Jones]], [[Paul Hudak]], Philip Wadler en anderen
| versie = Haskell 2010 (juli 2010)
| typesystem = statisch, sterk, ''inferred''
| implementaties = [[Glasgow Haskell Compiler|GHC]], [[Hugs]] en anderen
| dialecten = [[Helium (Haskell)|Helium]], [[Gofer]]
| beinvloed = [[Lisp (programmeertaal)|Lisp]], [[APL (programmeertaal)|APL]], [[Hope (programmeertaal)|Hope]], [[Miranda (programmeertaal)|Miranda]], [[ML (programmeertaal)|ML]], [[Id (programmeertaal)|Id]]
| invloed = [[C Sharp|C#]], [[Curry (programmeertaal)|Curry]], [[F Sharp|F#]], [[Language Integrated Query|LINQ]], [[Perl 6]], [[Python (programmeertaal)|Python]], [[Scala (programmeertaal)|Scala]]
| besturingssysteem = [[Multiplatform]]
| licentie = 
| website = https://haskell.org/
}}
'''Haskell''' is een [[functioneel programmeren|functionele programmeertaal]] vernoemd naar de [[wiskunde|wiskundige]] [[Haskell Curry|Haskell Brooks Curry]].

== Geschiedenis ==
Aan Haskell wordt voornamelijk gewerkt aan de [[Universiteit van Glasgow]].

=== Begin ===
Door het verschijnen van de programmeertaal Miranda in 1985 (uitgebracht door Research Software Ltd.) steeg de interesse in [[Luie evaluatie|luie]] [[Functioneel programmeren|functionele talen]]. Tegen 1987 waren er al een heleboel functionele talen in gebruik. Miranda was de meest verspreide taal, maar was [[propriëtaire software]]. Op de Internationale Conferentie over Functionele Talen in 1987 te [[Portland (Oregon)|Portland]] heerste consensus dat een [[open standaard]] voor dergelijke talen opgesteld moest worden. Het doel van de commissie was bestaande functionele consolideren tot een gemeenschappelijke taal die moest dienen als basis voor verder onderzoek naar functionele talen.<ref name=":0">{{Citeer boek|titel=Haskell 98 Language and Libraries|auteurlink=Simon Peyton Jones|voornaam=Simon Peyton|achternaam=Jones|taal=en|url=https://www.haskell.org/onlinereport/index.html|uitgever=Cambridge University Press|datum=december 2002|ISBN=9780521826143|hoofdstuk=Preface|archiefurl=https://web.archive.org/web/20230606145738/https://www.haskell.org/onlinereport/index.html|archiefdatum=2023-06-06}}</ref>

=== Haskell 1.0 tot 1.4 ===
De eerste versie van Haskell, ''Haskell 1.0'', is opgesteld in 1990. Het werk van de commissie resulteerde in reeks taaldefinities (1.0, 1.1, 1.2, 1.3 en 1.4).<ref>{{Citeer journal|auteur=Hudak, Paul|datum=16 april 2007|titel=A History of Haskell: Being Lazy With Class|journal=Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages (HOPL III)|pagina's=12–1–55|doi=10.1145/1238844.1238856|url=http://research.microsoft.com/~simonpj/papers/history-of-haskell/history.pdf|taal=en|medeauteurs=Hughes, John; Jones, Simon Peyton; Wadler, Philip}}</ref>

=== Haskell 98 ===
Eind 1997 resulteerde de reeks definities in Haskell 98, met als doel een stabiele, minimale, [[Portable software|draagbare]] versie van de taal en bijhorende standaard te publiceren. De commissie verwachtte en maakte het expliciet mogelijk om extensies toe te voegen aan de taal via ''experimentele functies''.<ref name=":0" />

In februari 1999 werd de standaard voor Haskell 98 gepubliceerd als ''The Haskell 98 Report''. In januari 2003 werd een herziene editie gepubliceerd als ''Haskell 98 Language and Libraries: The Revised Report''.<ref name=":0" /> De taal blijft zich sterk ontwikkelen. De Glasgow Haskell Compiler is [[de facto]] de standaardimplementatie.<ref>{{Citeer web|url=https://wiki.haskell.org/Implementations|titel=Implementations - HaskellWiki|bezochtdatum=4 augustus 2019|auteur=|achternaam=|voornaam=|datum=17 februari 2017|werk=|uitgever=|taal=en|archiefurl=https://web.archive.org/web/20190602212529/https://wiki.haskell.org/Implementations|archiefdatum=2019-06-02}}</ref>

=== Haskell 2010 ===
Begin 2006 werden de eerste stappen gezet om een opvolger voor Haskell 98 te maken, onder de naam ''Haskell Prime''.<ref>{{Citeer web|url=https://prime.haskell.org/|titel=Haskell Prime|bezochtdatum=4 augustus 2019|auteur=|achternaam=|voornaam=|datum=29 april 2016|uitgever=|taal=en|archiefurl=https://web.archive.org/web/20160220103915/https://prime.haskell.org/|archiefdatum=20 februari 2016|dodeurl=ja|dodelink=ja}}</ref> Het doel was incrementele updates te produceren, met hoogstens één nieuwe versie per jaar. De eerste revisie, Haskell 2010, is aangekondigd in november 2009 en gepubliceerd in juli 2010.<ref>{{Citeer web|url=https://mail.haskell.org/pipermail/haskell/2009-November/021750.html|titel=Announcing Haskell 2010|bezochtdatum=4 augustus 2019|achternaam=Marlow|voornaam=Simon|datum=24 november 2009|uitgever=|taal=en|archiefurl=https://web.archive.org/web/20190412221851/https://mail.haskell.org/pipermail/haskell/2009-November/021750.html|archiefdatum=2019-04-12}}</ref>

Haskell 2010 is een incrementele update, die verschillende vaak gebruikte en niet-controversiële functies toevoegt, die voorheen via compilervlaggen aangezet moesten worden:

* Hiërarchische modulenamen., bv. <code>Data.List</code> in plaats van <code>List</code>. Deze functionaliteit is oorspronkelijk toegevoegd aan Haskell 98 middels een addendum en wordt universeel gebruikt.
* Met de foreign function interface is het mogelijk om andere programmeertalen aan te spreken. In de standaard zijn enkel bindingen naar [[C (programmeertaal)|C]] gedefinieerd, maar het ontwerp laat andere talen toe. Ook deze functie was oorspronkelijk een addendum bij Haskell 98.
* De zogenaamde <math>n+k</math>-patronen zijn niet meer toegelaten.
* De regels omtrent de [[type-inferentie]] zijn versoepeld teneinde meer mogelijkheden te geven aan programma's.
* Enkele syntaxisproblemen zijn verholpen.
* De pragma <code>LANGUAGE</code> is toegevoegd om beter met extensies te kunnen werken.

== Implementaties ==
Parallel aan de ontwikkeling van de theoretische Haskell-taal is er een aantal werkomgevingen voor Haskell ontwikkeld. De bekendste hiervan zijn de [[Hugs]]- en Gofer-systemen en de [[Glasgow Haskell Compiler]], die alle gratis beschikbaar worden gesteld door de universitaire teams die eraan werken. Speciaal voor het leren van Haskell heeft men aan de [[Universiteit Utrecht|Universiteit van Utrecht]] [[Helium (Haskell)|Helium]] ontwikkeld waarbij men aandacht heeft besteed aan de duidelijkheid van de foutmeldingen.

In [[Nijmegen]] is de programmeertaal [[Clean (programmeertaal)|Clean]] ontwikkeld, die zeer sterk op Haskell lijkt, maar de programmeur meer controle over de luie evaluatie geeft.

== Functionele basis ==
In tegenstelling tot vele bekende [[programmeertaal|programmeertalen]] zoals [[C (programmeertaal)|C]], [[C++]] en [[Java (programmeertaal)|Java]] is Haskell geen [[imperatief programmeren|imperatieve taal]], maar een [[functioneel programmeren|functionele taal]]. Dat wil zeggen dat de taal niet gebaseerd is op het [[turingmachine]]-model van berekening, maar op het [[Lambdacalculus]]model van [[Alonzo Church]] waarin het toepassen van [[functie (wiskunde)|functies]] op termen en termenreductie de basis is van berekening.

Haskell is een [[Luie evaluatie|luie]] ("lazy"), puur functionele taal. Puur functioneel zijn wil zeggen dat erin gedefinieerde functies geen neveneffecten kunnen vertonen. Voorbeelden van niet-pure functionele programmeertalen zijn [[ML (programmeertaal)|Standaard ML]] en [[Scheme]]. Een luie functionele taal gebruikt [[luie evaluatie]] om te voorkomen dat resultaten die niet gebruikt worden, berekend worden. Hoewel het niet door iedereen als een intuïtieve eigenschap wordt aangezien, wordt luie evaluatie beschouwd als een manier om meer modularisatie te kunnen realiseren.

De programmeertaal is sterk en statisch getypeerd (typefouten kunnen tijdens de uitvoering van een programma niet optreden), en steunt sterk op [[type-inferentie]] (meestal kunnen de types van functies en variabelen door de compiler ontdekt worden). Het typesysteem is zeer uitgebreid, en ondersteunt het concept van klassen van types, waarbij deze klassen van elkaar afgeleid kunnen worden.

== Voorbeelden ==

=== [[Hello world (programma)|Hello world]] ===
<syntaxhighlight lang="haskell">
module Main (main) where            -- niet nodig bij interpreter, standaard bij modulebestanden

main :: IO ()                       -- optioneel, de compiler kan dit bepalen
main = putStrLn "Hello, World!"
</syntaxhighlight>

=== Faculteit ===
De onderstaande functie berekent de [[Faculteit (wiskunde)|faculteit]] van een getal. De functie is voor negatieve waarden ongedefinieerd. Ze is gedefinieerd op enkele verschillende manieren:
<syntaxhighlight lang="haskell">
 -- Type-annotatie (optioneel, zelfde voor elke implementatie)
faculteit :: (Integral a) => a -> a

-- Middels recursie (met de "ifthenelse"-expressie)
faculteit n = if n < 2
              then 1
              else n * faculteit (n - 1)

-- Met recursie (met patroonvergelijking)
faculteit 0 = 1
faculteit n = n * faculteit (n - 1)

-- Met recursie (met guards)
faculteit n
   | n < 2     = 1
   | otherwise = n * faculteit (n - 1)

-- Met een lijst en de "product"-functie
faculteit n = product [1..n]

-- Met fold (implementeert "product")
faculteit n = foldl (*) 1 [1..n]

-- In "point-free"-stijl
faculteit = foldr (*) 1 . enumFromTo 1
</syntaxhighlight>

=== Invoegen in een lijst ===
De volgende functie voegt een getal in een lijst in, op volgorde van klein naar groot:
<syntaxhighlight lang="haskell">
insert :: Int -> [Int] -> [Int]
insert a [] = [a]
insert a list@(x:xs) | a <= x = a : list
                     | a >  x = x : insert a xs
</syntaxhighlight>
Bij het invoegen van een getal zijn er twee gevallen te onderscheiden: het invoegen van een getal in een lege lijst en in een lijst met één of meerdere getallen. Het invoegen in de lege lijst is eenvoudig want dat is een lijst met dat getal. Bij het invoegen van een getal in een gevulde lijst kijken we naar het eerste getal, ''x'', en de rest, ''xs''. Als het in te voegen getal kleiner of gelijk is aan het eerste getal, dan zetten we het getal op kop van de hele lijst. Als het getal groter is dan het eerste getal dan nemen we het eerste element en voegen we het getal in de rest van de lijst in. Op deze manier wordt de lijst doorlopen totdat de plek is gevonden waar het getal neergezet kan worden.

=== Hogere-ordefuncties en luie evaluatie ===
In Haskell kan men [[hogere-ordefunctie]]s gebruiken, dit zijn functies die een of meerdere functie(s) als argument meekrijgen of die een functie opleveren. Voorbeelden hiervan zijn <code>[[Map (hogere-ordefunctie)|map]]</code>, <code>[[Filter (hogere-ordefunctie)|filter]]</code> en <code>[[fold]]</code>. De functie <code>filter</code> krijgt bijvoorbeeld een functie mee (een predicaat) en een lijst. Deze functie levert een lijst op waarin alleen de elementen zitten uit de gegeven lijst die aan het predicaat voldoen. Bijvoorbeeld:

<syntaxhighlight lang="haskell">
filter even [0..]
</syntaxhighlight>

Het bovenstaande levert een oneindige lijst op met even getallen (formeler: alle elementen uit de lijst [0, 1, 2, ..] waarvoor de functie <code>even</code> de waarde <code>True</code> teruggeeft). Het feit dat deze lijst oneindig is, is geen probleem, want de lijst hoeft, vanwege het feit dat Haskell luie evaluatie toepast, alleen maar opgebouwd te worden indien nodig. Zo kan men schrijven:

<syntaxhighlight lang="haskell">
take 10 (filter isPriem [1..])
</syntaxhighlight>

De functie <code>take</code> levert de eerste n elementen van een lijst op. Als men de functie <code>isPriem</code> heeft gedefinieerd (die voor een getal bepaalt of het een [[priemgetal]] is) dan levert het bovenstaande de eerste 10 priemgetallen op.

== Gebruik ==
Een greep uit de applicaties die geschreven zijn in of gebruik maken van Haskell:

* [[Darcs]], een [[versiebeheersysteem]], is geschreven in Haskell.<ref>{{Citeer web|url=http://darcs.net/|titel=Darcs - FrontPage|bezochtdatum=4 augustus 2019|auteur=|achternaam=|voornaam=|datum=|uitgever=|taal=en}}</ref>
* Xmonad is een [[windowmanager]] voor het [[X Window System]], geschreven in Haskell.<ref>{{Citeer web|url=https://xmonad.org/|titel=xmonad {{!}} the tiling window manager that rocks|bezochtdatum=4 augustus 2019|auteur=|achternaam=|voornaam=|datum=|uitgever=|taal=en|archiefurl=https://web.archive.org/web/20190902185150/https://xmonad.org/|archiefdatum=2019-09-02}}</ref>
* git-annex is een hulpmiddel voor [[Git (software)|git]] om met grote bestanden te werken.<ref>{{Citeer web|url=http://git-annex.branchable.com/|titel=git-annex|bezochtdatum=4 augustus 2019|auteur=|achternaam=|voornaam=|datum=29 december 2017|uitgever=|taal=en}}</ref>
* Pandoc, een programma om documenten te converteren tussen verschillende formaten.<ref>{{Citeer web|url=https://github.com/jgm/pandoc|titel=Pandoc|bezochtdatum=4 augustus 2019|auteur=|achternaam=MacFarlane|voornaam=John|datum=12 juni 2019|uitgever=|taal=en|archiefurl=https://web.archive.org/web/20190921223952/https://github.com/jgm/pandoc/|archiefdatum=2019-09-21}}</ref>
* [[Facebook]] gebruikt Haskell in zijn anti-spamprogramma's.<ref>{{Citeer web|url=https://www.wired.com/2015/09/facebooks-new-anti-spam-system-hints-future-coding/|titel=Facebook's New Spam-Killer Hints at the Future of Coding|bezochtdatum=4 augustus 2019|achternaam=Metz|voornaam=Cade|datum=1 september 2019|uitgever=[[Wired]]|taal=en|archiefurl=https://web.archive.org/web/20190716080139/https://www.wired.com/2015/09/facebooks-new-anti-spam-system-hints-future-coding/|archiefdatum=2019-07-16}}</ref>

== Kritiek ==
In 2002 en 2003 bespraken respectievelijk Jan-Willem Maessen en [[Simon Peyton Jones]] problemen geassocieerd met luie evaluatie. Naast de praktische overwegingen, zoals betere performantie, maakte luie evaluatie het moeilijker voor programmeurs om over de code te redeneren.<ref>{{Citeer journal|auteur=Maessen, Jan-Willem|datum=2002|titel=Eager Haskell: Resource-bounded Execution Yields Efficient Iteration|journal=Proceedings of the 2002 ACM SIGPLAN Workshop on Haskell|pagina's=38-50|uitgever=Association for Computing Machinery|pmid=|doi=10.1145/581690.581694|url=https://dl.acm.org/citation.cfm?id=581694|taal=en|bezochtdatum=}}</ref><ref>{{Citeer web|url=https://www.microsoft.com/en-us/research/publication/wearing-hair-shirt-retrospective-haskell-2003/|titel=Wearing the hair shirt: a retrospective on Haskell|bezochtdatum=4 augustus 2019|achternaam=Jones|voornaam=Simon Peyton|datum=januari 2003|uitgever=Microsoft Research|taal=en|archiefurl=https://web.archive.org/web/20190804141054/https://www.microsoft.com/en-us/research/publication/wearing-hair-shirt-retrospective-haskell-2003/|archiefdatum=2019-08-04}}</ref>

Anderen observeerden dat Haskell niet eenvoudig is om te leren voor beginners:<ref>{{Citeer journal|auteur=Heeren, Bastiaan|datum=augustus 2003|titel=Helium, for Learning Haskell|journal=Proceedings of the 2003 ACM SIGPLAN Workshop on Haskell|pagina's=62-71|uitgever=Association for Computing Machinery|doi=10.1145/871895.871902|url=http://www.open.ou.nl/bhr/heeren-helium.pdf|taal=|bezochtdatum=|medeauteurs=Leijen, Daan; IJzendoorn, Arjan van|archiefurl=https://web.archive.org/web/20220122010312/http://www.open.ou.nl/bhr/heeren-helium.pdf|archiefdatum=2022-01-22}}</ref> <blockquote>The subtle syntax and sophisticated type system of Haskell are a double edged sword – highly appreciated by experienced programmers but also a source of frustration among beginners, since the generality of Haskell often leads to cryptic error messages.</blockquote>Dit was ook een van de redenen om [[Helium (Haskell)|Helium]] te maken.

== Gerelateerde talen ==
[[Clean (programmeertaal)|Clean]] is een nauw verwante, maar iets oudere taal van Haskell.

Een reeks talen die geïnspireerd zijn door Haskell, maar met verschillend typesysteem, zijn o.a.:

* [[Agda]], een functionele taal met dependent types.
* [[Idris (programmeertaal)|Idris]], een generieke functionele taal, ontwikkeld aan de [[universiteit van St Andrews]].
* [[Epigram (programmeertaal)|Epigram]], een functionele taal, gebruikt voor het bewijzen van eigenschappen van programma's.
* [[Cayenne (programmeertaal)|Cayenne]], een functionele taal met dependent types.
* Ωmega, een [[interpreter]] gelijkaardig aan [[Hugs]].
* Elm, een functionele taal, bedoeld om [[Webapplicatie|webapplicaties]] mee te maken.

== Verder lezen ==
* {{nl}}[http://www.staff.science.uu.nl/~hage0101/FP-elec.pdf Functional Programming] (pdf). Dit is het collegedictaat van het vak ''Functioneel Programmeren'' aan de [[Universiteit Utrecht]] (zie [http://www.cs.uu.nl/docs/vakken/fp/ Bachelor Course on Functional Programming] voor meer informatie).

== Externe links ==
* {{en}}[https://www.haskell.org De Haskell pagina]
* {{en}}[https://www.haskell.org/onlinereport/haskell2010/ Het Haskell 2010 Language Report] - Over de taal zelf en haar bibliotheken
* {{en}}[http://research.microsoft.com/~simonpj/papers/history-of-haskell/history.pdf A History of Haskell: being lazy with class] - Geschiedenis van Haskell
* {{en}}[http://www.cs.nott.ac.uk/~gmh//faq.html De FAQ van Usenet nieuwsgroep comp.lang.functional]
* {{en}}[https://web.archive.org/web/20050910025440/http://www.md.chalmers.se/~rjmh/Papers/whyfp.html Why Functional Programming Matters] - Een paper door John Hughes die o.a. de voordelen van lazy evaluatie beschrijft.
{{Appendix}}{{Navigatie programmeertalen}}

[[Categorie:Haskell| ]]
[[Categorie:Functionele programmeertaal]]