Хаскел (програмски језик)

Haskell
Originalni naziv	engl. Haskell
Изговара се	Хаскел
Модел	функционални
Појавио се	1990.
Дизајнер(и)	Леннарт Аугустссон, Даве Бартон, Бриан Боутел, Wаррен Буртон, Јосепх Фасел, Кевин Хаммонд, Ралф Хинзе, Паул Худак, Јохн Хугхес, Тхомас Јохнссон, Марк Јонес, Симон Пеyтон Јонес, Јохн Лаунцхбурy, Ерик Меијер, Јохн Петерсон, Аластаир Реид, Цолин Рунциман, Пхилип Wадлер
Актуелна верзија	Р7РС (ратификован стандард)
Датум актуелне верзије	2010
Систем типова	статички
Имплементације	ГХЦ, Хугс, НХЦ, ЈХЦ, Yхц, УХЦ
Дијалекти	Хелиум, Гофер
Утицаји	Цлеан, ФП, Гофер, Хопе анд Хопе+, Ид, ИСWИМ, КРЦ, Лисп, Миранда, ML анд Стандард ML, Орwелл, САСЛ, Сцхеме, СИСАЛ
Утицао на	Агда, Блуеспец, C++11/Цонцептс, C#/ЛИНQ, ЦАЛ, Цаyенне, Цлеан, Цлојуре, ЦоффееСцрипт, Цуррy, Елм, Епиграм, Есцхер, Ф#, Фреге, Хацк, Идрис, Исабелле, Јава/Генерицс, ЛивеСцрипт, Мерцурy, Омега, Перл 6, Пyтхон, Руст, Сцала, Сwифт, Тимбер, Висуал Басиц 9.0
Оперативни системи	[мулти-платформе]
Веб-сајт	haskell.org

Хаскел је стандардизован, функционални, строго типизиран програмски језик опште намјене, са нестриктном семантиком. Име је добио по логичару који се зове Haskell Curry. Посљедњи стандард Хаскела је Haskell 2010, међутим, постоји група која ради на сљедећој верзији Haskell 2020.

Лого програмског језика Хаскел

Хаскел карактеришу систем типова са статичким типизирањем и лијено израчунавање. Класе типова први пут се појављују у програмском језику Хаскел. Његова главна имплементација је Glasgow Haskell Compiler.

Хаскел је заснован на семантици, али не и на синтакси програмског језика Miranda.

Три су основне карактеристике које га раздвајају од програмског језика ML. Прво, функције у Хаскелу могу бити преоптерећене, друго Хаскел користи нестриктну семантику, и треће, Хаскел је чист функционални језик, што значи да у њему не постоје изрази или наредбе које имају бочне ефекте.

Настанак програмског језика Хаскел

Након изласка програмског језика Миранда 1985.године, интересовање за функционалне језике који подржавају лијено израчунавање је расло. До 1987.године постојало је више од десет нестриктних, чистих, функционалних програмских језика. Од њих, Миранда је свакако била највише коришћена, иако је власнички софтвер (не-слободан). На конференцији FPCA(Functional Programming Languages and Computer Architecture) одржаној 1987.године у Портланду у Орегону, одржан је састанак на којем су учесници склопили споразум да би требало да се направи одбор, који би дефинисао отворени стандард за такве језике.

Циљ одбора је био да се постојећи функционални језици споје у заједничку цјелину, која би служила као основа за даља истраживања у дизајну функционалних језика.

Haskell 1.0 до 1.4

Прва верзија Хаскела, именована са Haskell 1.0, дефинисана је 1990. године. Напори комитета резултовали су низом дефиниција језика (1.0, 1.1, 1.2, 1.3, 1.4).

Haskell 98

Током 1997. године низ стандарда је достигао свој врхунац као Haskell 98, са намјером да одреди стабилну, минималну, портабилну верзију језика пропраћену стандардном библиотеком за учење која би била база за будуће екстензије. Комитет је одмах прихватио креацију стандарда Haskell 98 са додатим експерименталним карактеристикама.

У фебруару 1999.године стандард Haskell 98 је формално објављен као "Haskell 98 report". У јануару 2003.године прерађена верзија је објављена под називом "Haskell 98 Language and Libraries: The Revised Report". Даље, језик наставља убрзано да напредује,док са ГХЦ имплементацијом данас представља de facto стандард.

Haskell 2010

Почетком 2006.године, почео је процес тражења насљедника стандарду Haskell 98, назван Haskell Prime. То је требало да буде константан и постепен процес ревидирања дефиниција језика, са представљањем нове ревизије једном годишње. Прва ревизија, именована као Haskell 2010, најављена је у новембру 2009. а објављена у јуну 2010. године.

Haskell 2010 додаје интерфејс страних функција (FFI) дозвољавајући везе ка другим програмским језицима. Такође, поправљени су неки синтаксни проблеми (промјене у формалној граматици) и забрањени су такозвани "n+k шаблони", тј. дефиниције функција попут fact(n+1)=(n+1)*fact n нису више дозвољене.

Поред овога, додате су неке екстензије попут DoAndIfThenElse, HierarhicalModules, FixityResolution, ForeignFunctionInterface, PatternGuards, NoNPlusKPatterns, итд.

Опис језика

Хаскел карактеришу лијено израчунавање, упаривање шаблона, техника задавања листи, класе типова и полиморфизам типова. Хаскел је чист програмски језик, што значи да функције у њему немају споредне (бочне) ефекте. Постоји посебан конструкт језика којим се репрезентују споредни ефекти.

Хаскел је строго и статички типизиран програмски језик, чији се систем типова базира на Hindley-Milner систему типова. Иновација Хаскела у овој области је додавање класа типова, које су првобитно настале како би се омогућило преоптерећивање (overloading), али су пронашле још многе употребе.

Конструкт језика којим су обезбијеђени споредни ефекти је примјер монаде. Генерално, монаде су општа структура која може моделовати разне облике израчунавања, укључујући обраду грешака, недетерминизам, синтаксну анализу итд. Монаде су дефинисане као обични типови података, али Хаскел обезбјеђује синтаксне олакшице при њиховом коришћењу. Дакле, монаде укључују скуп програмских техника вишег реда које се могу корисити да замијене експлицитно стање у многим случајевима, али њихова примјена обухвата и много више од самог симулирања стања.

Језик има отворену, јавну спецификацију и постоје многе имплементације. Главна имплементација Хаскела, ГХЦ, је истовремено и интерпретатор и компилатор који ради на многим платформама. ГХЦ се издваја по ефикасној имплементацији која користи конкурентност и паралелизам, као и по богатом систему типова који инкорпорира иновације попут фамилија типова и конструктора за типове података.

Примјери кодова у Хаскелу

Слиједи Здраво свијете програм, написан у Хаскелу, при чему све осим посљедње линије може бити изостављено.

module Main where

main :: IO ()
main = putStrLn "Zdravo, svijete!"

Сљедећи примјер је функција у Хаскелу која израчунава факторијел броја помоћу упаривања шаблона:

fact 0 = 1
fact 1 = 1
fact n = n * fact (n-1)

У Хаскелу не постоји резервисана (кључна) ријеч којом би започињала дефиниција функције.

Јос један примјер функције која израчунава факторијел броја дат је са:

factorial :: Int -> Int
factorial 0 = 1
factorial n | n > 0 = n * factorial (n-1)

Прва линија је потпис функције и она специфицира да је фацториал функција која очекује аргумент типа Int и враћа резултат типа Int. У Хаскелу је присутно статичко типизирање, тачније, компајлер је у стању да аутоматски закључи потписе, за скоро све функције. Ово се догађа чак и кад је потпис функције наведен, у том случају компајлер провјерава да ли је потпис тачан. Потписи функција су дио корисне документације.

Наредне двије линије су код за factorial. У Хаскелу, дефиниција функције се може састојати од више једначина. Да би се функција примијенила на аргумент користи се упаривање шаблона: испитују се једначине једна по једна, од врха према дну, док се не пронађе прва чији шаблон одговара аргументу. Прва линија факторијела упарује само 0, у овом случају одговор је аутоматски 1. Ако је аргумент не-нула покушава се са упаривањем друге једначине. Ова једначина има буловски услов који мора бити True, тј.тачан да би упаривање било успјешно. Друга једначина упарује све аргументе који су већи од 0, и у том случају израчунава се факторијел броја n изразом n * factorial (n-1). Уколико се функција factorial примијени на негативан аргумент ниједна од једначина не може бити упарена, и програм ће избацити run-time грешку.

У наставку је функција factorial дефинисана помоћу функција вишег реда foldl и foldr, које се налазе у библиотеци Хаскела.

factorial n = foldl (*) 1 [1..n]


factorial = foldr (*) 1 . enumFromTo 1

Имплементација помоћу функције foldl заснива се на имплементацији функције продуцт, док дефиниција коришћењем функције foldr илустрије дефинисање функције без навођења њеног агрумента, и коришћењем нотације са тачком, која означава композицију функција.

Сљедећа функција, која такође користи упаривање шаблона, израчунава n-ти члан Фибоначијевог низа.

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

Дефиниција факторијела која користи ограђене једначине (guarded expressions).

fact n =
	| n==0 = 1
	| n==1 = 1
	| n>1 = n * fact (n-1)

Њима се специфицирају услови под којима дефиниција функције може бити примијењена. Ова дефиниција факторијела је прецизнија од претходне, јер је извршена рестрикција њеног параметра на оне вриједности за које функција ради. Оваква форма дефиниције функције назива се кондиционални израз, по математичком изразу на коме је заснована.

Може се појавити otherwise као посљедњи услов у кондиционалном изразу са очигледном семантиком. На примјер,

sub n
	| n < 10 = 0
	| n > 100 = 2
	| otherwise = 1

Функција

 square x = x * x

која враћа квадрат задатог броја може да прими аргумент који је било ког нумеричког типа, пошто Хаскел подржава полиморфизам.

Још неке имплементације функција за израчунавање Фибоначијевих бројева дате су у наставку.

fib n = fibs !! n
        where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

fib n = fibs (0,1) !! n
        where fibs (a,b) = a : fibs (b,a+b)

Листе у Хаскелу се пишу у заградама, на примјер:

boje = ["plava", "zelena", "crvena", "zuta"]

Хаскел укључује колекцију оператора над листама. На примјер, листе се могу надовезивати са ++, : служи за одвајање главе и репа листе, и .. се користи да се специфицира аритметичка серија у листи.

На примјер, 5: [2,7,9] као резултат даје [5,2,7,9], [1,3..11] као резултат даје [1,3,5,7,9,11], док [1,3,5] ++ [2,4,6] као резултат даје [1,3,5,2,4,6]

Коришћењем оператора : и упаривања шаблона може се дефинисати функција која рачуна производ задате листе бројева:

product [] = 1
product (a:x) = a * product x

Користећи управо дефинисану функцију product може се дефинисати функција која рачуна факторијел броја.

fact n = product [1..n]

Хаскелова техника задавања листи омогућава да се листа кубова свих бројева између 1 и 50 дефинише са:

[n*n*n|n<-[1..50]]

Горњи израз се може прочитати као: листа свих n*n*n тако да је n у рангу од 1 до 50. У овом случају квалификатор има форму генератора и он генерише бројеве од 1 до 50. У осталим случајевима, квалификатори су у облику Буловских израза и у тим случајевима се они називају тестовима.

Ова нотација се може искористити за описивање алгоритама који раде разне ствари, као што су налажење пермутација листе и сортирање листи.

На примјер, сљедећа функција factors за дато n враћа листу свих његових дјелилаца (фактора).

factors n = [i| i<-[1..n `div` 2], n `mod` i == 0]

Листа којом је задата функција креира листу бројева који су у рангу од 1 до n/2 и такви да дијеле n.

Ово је веома егзактна и кратка дефиниција дјелилаца датог броја.

Апострофи који окружују операторе div и mod су искоришћени да се нагласи инфиксна употреба ових оператора. Када се они позивају у функцијској нотацији, као у: div n 2, онда се апострофи не користе.

Концизна дефиниција алгоритма квиксорт (quicksort) у Хаскелу дата је са:

quicksort [] = []
quicksort (h:t) = quicksort [b| b<-t, b<=h]
				++ [h] ++
				quicksort [b| b<-t, b>h]

У овој функцији, скуп елемената листе који су мањи или једнаки од главе листе је сортиран и на њега је надовезана глава листе, а затим је скуп елемената који су већи од главе листе соритан и надовезан на претходни резултат. Ова дефиниција квиксорт алгоритама је значајно краћа и једноставнија од кода истог алгоритма у неком императивном језику.

Модел израчунљивости

Хаскел програм састоји се од једног израза, а тај израз може садржати разне подизразе. Питање је, у ком ће редосљеду це они бити израчунати? Хаскел је нестриктан језик, тако да, ниједан од израза не би требало да буде израчунат, прије него што његов резултат не буде неопходан. Интуитивно, требало би прво извршити редукцију најлијевљег израза, све док је функција, замјењивати аргументе у тијело функције, али не израчунавајући их, и онда извршити редукцију резултујућег израза.

Овакав поредак израчунавања назива се нормални поредак.

(if n>=0 then factorial else error) (factorial (factorial n))

У примјеру изнад, if then else наредба користи n да би се одлучило коју функцију, factorial или error примијенити на аргумент (factorial (factorial n)). Нема смисла израчунавати аргумент све док се не евалуира if then else наредба. Кад се она евалуира, може се замијенити (factorial (factorial n)) у тијело factorial или error функције и наставити са израчунавањем.

Дакле, прецизније, уколико се израз замисли као стабло, Хаскел прво израчунава, тј.редукује најлијевљи израз, све док се не дође до конструктора или функције. Ако се дошло до конструктора израчунавање је завршено. Било који преостали подизрази остају неизрачунати. Ако се дошло до функције која није примијењена ни на какве аргументе, онда је израчунавање завшено. Иначе, редукцијама се дошло до функције и она је примијењена на аргументе. Тада се функција примијени на први аргумент, који се при том не израчунава, већ се само замјењује у тијело функције и наставља се са израчунавањима.

Уграђене функције као што су сабирање и упаривање шаблона захтијевају да њихови аргументи буду евалуирани прије него што се почне са евалирањем тих функција. За декларативне програме, овакав начин израчунавања, када се увијек редукује најлијевљи израз назива се нормални поредек, и има особину да се увијек завршава, ако се израчунавање може завршити.

Лијено израчунавање

Како аргументи функција нису аутоматски евалуирани прије позива фунцкије, функције у Хаскелу називамо нестриктним. Иако није командовано Хаскелл језиком, многе имплементације Хаскела подржавају лијено израчунавање, чиме се осигурава да се изрази израчунавају највише једном. Оптимизација Хаскел компајлера врши се примјеном анализе која се назива [[анализа стриктности]] strictness analysis да би се одлучило када лијено израчунавање није неопходно за терминирање или контролу ресурса. Функције којима није потребно лијено израчунавање се компајлирају као стриктне функције, што је много ефикасније.

Нестриктни језици имају неколико предности у односу на стриктне програмске језике. Прво, генерално су ефикаснији, јер се нека израчунавања избјегавају. Друго, неки интерестантни концепти су могући са нестриктним језицима који нису могући са стриктним. Међу њима су бесконачне листе. Како се изрази израчунавају само уколико су њихове вриједности неопходне, то има за посљедицу могућност дефинисања бесконачних структура података. На примјер:

positives = [0..]
evens = [2,4..]
squares = [n*n | n <- [0..]]

Наравно, не постоји рачунар који ће стварно репрезентовати све елементе ових листи, али то не спрјечава њихово коришћење, ако је подржано лијено израчунавање.

На примјер, уколико се жели провјера да ли је одређени број квадрат неког броја, провјерила би се листу squares са функцијом припадања листи. Уз претпоставку да постоји предикатска функцију која се назива member и која одређује да ли је дати елемент садржан у датој листи, ово би се могло искористити са:

member 16 squares

и овај израз би вратио вриједност True. Елементи листе squares би се израчунавали све док број 16 не буде пронађен. Међутим, функција member би морала бити пажљиво дефинисана.

member b [] = False
member b (a:x)=(a==b) || member b x

Друга линија дефиниције раздвоји листу на њену главу и реп и враћа вриједност True ако је или глава једнака елементу који се тражи (б) или ако рекурзивни позив за реп листе врати вриједност True.

Ова дефиниција member функције би радила исправно само ако би дати број заиста био квадрат неког броја.

Ако то није случај, елеменати листе squares би се генерисали заувијек, или док се не би прекорачило неко меморијско ограничење. Наредна функције обезбјеђује провјеру да ли дати елемент припада соританој листи, прекидајући претрагу и враћајући False ако се са претрагом дошло до броја који је већи од броја који се тражи.

member2 n (m:x)
	| m < n = member2 n x
	| m == n = True
	| otherwise = False

Currying

Из правила редукције у ламбда рачуну (lambda calculus) може се уочити да се примјена функција која очекује више аргумената, на примјер n аргумената, израчунава тако што се примијени на свој први аргумент, а као повратна вриједност добија се функција са n-1-им аргументом. Овај процес се назива currying. Може се написати функција која дуплира сваки елемет листе позивајући функцију map са само једним аргументом:

doubleList = map (\x -> 2*x)

Нотација \x -> 2*x је Хаскелова нотација за анонимне функције, које су ламбда изрази. Примјена функције doubleList изгледала би: doubleList [1,2,3,4] => map (\x -> 2*x) [1,2,3,4] => [2,4,6,8]

Полиморфни типови

У Хаскелу се изрази статички типизирају. Међутим, програмери нису ограничени на Хаскелове предефинисане типове.

У програм се могу укључити потпуно нови типови. На примјер, може се укључити нови тип BinTree за бинарна стабла:

data BinTree a = Empty | Node a (BinTree a) (BinTree a)

BinTree је или Empty, што преставља празно стабло, или Node, тј.чвор који садржи један елемент и два подстабла. Empty и Node се називају конструктори и они креирају структуру података типа BinTree. У дефиницији, а је типска промјенљива, и представља тип елемената који се налазе у стаблу. BinTree Integer је тада тип бинарних стабала која садрже цијеле бројеве. Елемент у чвору Node и елементи у подстаблима су ограничени на исте типове. Сљедећа функција враћа број елемената у бинарном стаблу.

size:: BinTree a -> Integer
size Empty = 0
size (Node val lt rt) = 1 + (size lt) + (size rt)

Прва линија је потпис фунцкије. Може се прочитити као: "За све типове а, сизе узима један аргумент типа BinTree и враћа један Integer". Пошто size ради за стабла која садрже елеменате произвољног типа, ова фунцкија назива се полиморфна фунцкија.

Код функције састоји се од двије линије од којих прва упарује празна стабла, и њихова величина је 0, а друга упарује непразна стабла и њихова величина је збир величина лијевог и десног подстабла увећан за један.

Сљедећа функција је lookup функција која налази (ако постоји) елемент у бинарном стаблу претраге. Стабло садржи елементе типа tuple(у овом случају уређени пар, у опшем случају уређена n-торка) који имају цијели број који је кључ и string који је вриједност, тј.тип ових стабала је: BinTree (Integer, String). Функција lookup враћа вриједност типа Maybe String,а та вриједност је Nothing,ако кључ не постоји у стаблу, или Just val, ако је уређени пар облика (k, val) у стаблу. Тип Maybe a је уграђени, полиморфни тип.

lookup :: Integer -> BinTree (Integer,String) -> Maybe String
lookup k Empty = Nothing
lookup k (Node (nk,nv) lt rt) | k == nk = Just nv
lookup k (Node (nk,nv) lt rt) | k < nk = lookup k lt
lookup k (Node (nk,nv) lt rt) | k > nk = lookup k rt

На први поглед, потпис функције може дјеловати необично, због знака -> између Integer и BinTree аргумента. Међутим, то је због правила currying.

Када се lookup примијени на кључ који је типа Integer, као повратна вриједност добије се нова функција која кад се примијени на бинарно стабло увијек тражи исти кључ.

Класе типова

Недостатак горње дефиниције функције лоокуп је што је дати тип веома рестриктиван. Да ли се ова функција може учинити полиморфном као функција сизе? Тада би се исти код могао искористити за претрагу стабала која садрже скоро па произвољан тип података, тачније, тип који омогућава примјену оператора ==, < и >. Да би се ово омогућило Хаскел има типове класа који дају има групи функција. Ако тип омогућава примјену тих функција, онда за тај тип кажемо да припада тој класи типова. У Хаскелу постоји уградјени касни тип Ord који подржава ==, < и >. Наредни потпис специфицира да тип кључа у стаблу мора бити тип класе Ord.

lookup :: (Ord a) => a -> BinTree (a,b) -> Maybe b

Класе типова омогућавају да имена функција буду преоптерећена(overloaded).

Оператор < за Integer није исти као оператор < за String. Међутим, како Хаскел компајлер зна типове свих израза, може замијенити одговарајући оператор. Програмери могу додавати сопствене типове и класе типова. На примјер, тип BinTree би се могао додати у Ord, обезбјеђивањем одговарајућих дефиниција за операторе поређења. Такође, уколико би се креирао тип комплексних бројева, он би се могао додати класи нумеричких типова која се назива Num, а наравно при томе би се морали обезбиједити сви оператори из те класе и над комплексним бројевима. Најопштија декларација функције factorial је:

factorial :: (Num a, Ord a) => a -> a

На тај начин, обезбијеђено је да се функција factorial може примијенити на аргуменат било ког типа који подржава аритметичке операторе и операторе поређења, враћајући при томе вриједност истог типа.

Имплементације

Haskell 2010

GHC

ГХЦ је оптимизовани компајлер за Хаскел који обезбјеђује многе језичке екстензије. Сам компајлер написан је у програмском језику Хаскел (плус екстензије) и његова величина и комплексност имају за посљедицу да има слабију портабилност од Hugs-a, да је спорији и захтијева више меморије. Ипак, програми написани у њему се много брже извршавају.

Такође, постоји интерактивно окружење GHCi, слично Hugs-u, али подржава интерактивно учитавање компајлираног кода. GHC подржава конкурентно и паралелно програмирање. Доступан је на свим већим платформама, укључујући Wиндоwс, Мац ОС X, као и неке варијатне Unixa (Linux, *BSD, Solaris).

GHC тим препоручује инсталирање Хаскел платформе за GHC. Још једна повољна опција за Windows кориснике је MinGHC.

UHC

UHC (Utrecht Haskell Compiler) је имплементација Хаскела од стане унверзитета Utrecht. UHC подржава скоро све карактеристике Haskell 98 и Haskell 2010 као и додатне, експерименталне екстензије.

Компајлер ради на платформама Mac OS X, Windows (Cygwin) и разним Unix платформама.

UHC је имплементиран користећи атрибутивну граматику и погодан је за експериментисање са језичким екстензијама. 18. априла 2009. UHC је најављен на петом Хаскел Хакатону у Утрехту.

Haskell 98

Jhc

Jhc је експериментални компајлер са циљем тестирања нових метода оптимизација и истраживања дизајна простора имплементација Хаскела.

Helium

Helium је функционални програмски језик и компајлер дизајниран специјално за учење Хаскела.

Квалитет error poruka је главни проблем при избору особина језика, као и у имплементацији компајлера. Овај језик је подскуп Хаскела. Највећа разлика међу њима огледа се у непостојању преоптерећивања. Језик прати бројне информације о програму ради давања добрих информативних порука.

Неодржаване

Наредне имплементације нису више активно одржаване.

Hugs

Hugs је мали, бајткод интерпретатор написан у програмском језику C који може да се покрене са скоро сваке платформе.

Најбоља употреба је при развоју Хаскел програма. Предност је јако брза интерпретација изворног кода, као и погодност интерактивног интерпретатора (у којем је могуће кретање између модула ради тестирања одвојених делова програма).

Ипак, како је то интерпретатор, не може се ни поредити са брзином извршавања програма при компајлирању, коришћењем GHC-а и других Хаскел компајлера. Hugs 98 је погодан за верзију Haskell 98.

Доступан је на свим Униx платформама укључујући и Linux, као и ДОС, Windows 3.x, Win 32 i Macintosh. Постоји доста богата библиотека, укључуући Win32 библиотеке, а Wиндоwс верзија користи графички кориснички интерфејс WinHugs.

nhc98

nhc98 је још један бајткод компајлер. Фокусира се на минимизовању меморијског простора.

Примјене

Darcs је систем за управљање изворним кодом написан у Хаскелу, са појединим иновативним карактеристикама. Cabal је алат за прављење и пакетирање Хаскел библиотека и програмирање. GHC је често коришћен за тестирање напредних особина функционалног програмирања и оптимизације других програмских језика.

Индустрија

• Facebook имплементира своје anti-spam програме у Хаскелу, као open-source софтвер.
• Cryptol језик и ланац за развој и верификацију криптографских алгоритама је имплементиран у Хаскелу.

Веб

Постоје Хаскел оквири веб прилога попут:

• Yesod
• Happstack
• Snap

Литература

• Syme, Don; Granicz, Adam; Cisternino, Antonio (2007). Expert F#. Apress. str. 2. »F# also draws from Haskell particularly with regard to two advanced language features called sequence expressions and workflows.« 
• http://smbidoki.ir/courses/66_Concepts%20of%20Programming%20Languages%2010th-Sebesta.PDF
• https://web.archive.org/web/20130516174246/http://www.epsa.org/forms/uploadFiles/3B6300000000.filename.booksingle.pdf

Спољашње везе

• Званични веб-сајт
• Haskell Wiki
• Planet Haskell an aggregator of Haskell related blogs and other Haskell-related news sites
• Hackage – central package archive
• Hoogle – API search engine

Tutorials

• Try Haskell! – in-browser interactive tutorial
• School of Haskell Архивирано на сајту Wayback Machine (25. децембар 2015) – online tutorials
• Functors, Applicatives, And Monads In Pictures
• Real World Haskell - free to read online

Ostalo

• The Monad.Reader – quarterly magazine on Haskell topics
• The Evolution of a Haskell Programmer – slightly humorous overview of different programming styles in Haskell