Haskell

Haskell

Տեսակ	purely functional programming language?, non-strict programming language?, modular programming language?, ծրագրավորման ինտերպրետացվող լեզու, off-side rule language?, ծրագրավորման կոմպիլյացվող լեզու և ծրագրավորման լեզու
Առաջացել է	1990
Ստեղծող	Paul Hudak?[1], Lennart Augustsson?[2], John Hughes?[3], Simon Peyton Jones?[4], Erik Meijer?[4] և Philip Wadler?[4]
Նախագծող	Lennart Augustsson?, Warren Burton?, Kevin Hammond?, Paul Hudak?, John Hughes?, Thomas Johnsson?, Simon Peyton Jones?, John Launchbury?, Erik Meijer?, Alastair Reid? և Philip Wadler?
Ընդլայնումներ	.hs և .lhs
ՕՀ	Windows և յունիքսանման օպերացիոն համակարգ
Ընթացիկ տարբերակ	Haskell 2010 (հուլիս 2010)[5]
Ներշնչվել է	Լիսպ, ML, Miranda?[4], Orwell?[4], Lazy ML?[4] և Clean?[4]
Անվանված է	Հասկել Կարրի[4]
Կայք	haskell.org​(անգլ.)
Haskell Վիքիպահեստում

Haskell ստանդարտացված, ընդհանուր նշանակության մաքուր ֆունկցիոնալ ծրագրավորման լեզու: Տիպի համակարգը ամբողջական է, ստատիկ, ավտոմատ տիպի որոշմամբ, հիմնված Հինդլի-Միլներ տիպի համակարգի վրա: Քանի որ լեզուն ֆունկցիոնալ է, կառավարման հիմնական կառուցվածքը ֆունկցիան է:

Լեզվի տարբերակիչ առանձնահատկությունն այն է, որ նա լուրջ վերաբերմունք ունի տիպավորման նկատմամբ։ Հիմնականում դրա շնորհիվ է, որ լեզուն անվանվել է տիպի տեսաբան և կոմբինատորային տրամաբանության գյուտարար Հասքել Քարիի անունով:

Այս լեզուն ունի հնարավորություն ծրագրավորման այլ լեզուների կոդի հետ փոխազդելու միջոցներ։ Ներկառուցված է բազմաֆունկցիոնալ և զուգահեռ ծրագրավորման աջակցություն, մշակված գործիքներ (ավտոմատ թեստավորում, վրիպազերծման և պրոֆիլավորման գործիքներ, այդ թվում՝ զուգահեռ ծրագրերի համար), կան մի քանի հազար բաց կոդով գրադարաններ:

Haskell-ը պատկանում է ML լեզուների ընտանիքին։ Նրա վրա ուղղակիորեն ազդել է Միրանդա լեզուն, որը մշակվել է 1985 թվականին Դեյվիդ Թերները: Միրանդան առաջին մաքուր ֆունկցիոնալ լեզուն էր, որն ուներ կոմերցիոն աջակցություն և համեմատաբար տարածված էր 1980-ականներին, բայց մնաց սեփական ծրագրային ապահովման վրա: Սա դժվարացրեց զարգացնել և ուսումնասիրել ֆունկցիոնալ ծրագրավորման հնարավորությունները, ուստի ընդամենը մի քանի տարվա ընթացքում հայտնվեցին ավելի քան մեկ տասնյակ նմանատիպ լեզուներ: Տարբեր մշակողների ջանքերը միավորելու համար 1987 թվականին Օրեգոնի ֆունկցիոնալ ծրագրավորման լեզուների և համակարգչային ճարտարապետության կոնֆերանսում (FPCA'87), որոշվեց ստեղծել հանձնաժողով՝ բաց ստանդարտով մշակելու համար:

1990 թվականին առաջարկվեց լեզվի առաջին տարբերակը՝ Haskell 1.0։ Հետագայում հանձնաժողովի աշխատանքները շարունակվեցին, և 1999 թվականին լույս տեսավ «Haskell 98 զեկույցը»^[6], որը երկար տարիներ դարձավ լեզվի կայուն չափանիշ։ Լեզուն, այնուամենայնիվ, շարունակեց արագ զարգանալ, քանի որ GHC կոմպիլյատորը դե ֆակտո ստանդարտ էր նոր հնարավորությունների համար:

Լեզվի նոր տարբերակների մշակումը բաց է, այս գործընթացը կոչվում է Haskell'^[7] (Haskell Prime [ˈhæskəl praɪm])։ Յուրաքանչյուր ոք կարող է իր առաջարկները ներկայացնել քննարկման, առաջարկները քննարկվում են ամբողջ տարվա ընթացքում, հանձնաժողովն ընտրում և հայտարարում է այն առաջարկները, որոնք պատրաստ են ընդունելու, ձևավորվում է նոր հանձնաժողով և մինչև տարեվերջ պատրաստվում է լեզվի նոր տարբերակը։ Այսպիսով, լեզվի նոր տարբերակներ այժմ կարող են հայտնվել ամեն տարի: Ծրագրով նախատեսվում է որոշ վերանայումներ հայտարարել «կարևոր» և պահպանել նման վերանայումները երկարատև ժամանակի ընթացքում:

Haskell 2010 լեզվի տարբերակը հայտարարվել է 2009 թվականի վերջին^[8], սակայն վերջին «նշանակալի» տարբերակը (ստանդարտ) մնում է Haskell 98-ը։

Haskell լեզվի հիմնական բնութագրերը հետևյալն են

• կողմնակի ազդեցությունների անթույլատրելիությունը ( լեզվի մաքրություն )։ Կողմնակի էֆեկտներով ծրագրեր գրելու ունակություն, առանց խախտելու ֆունկցիոնալ ծրագրավորման պարադիգմը՝ օգտագործելով մոնադներ .
• ստատիկ ուժեղ ամբողջական տիպավորում ավտոմատ տիպի որոշմամբ՝ հիմնված Հինդլի-Միլներ տիպավորման վրա;
• ավելի բարձր կարգի գործառույթներ, ներառյալ լամբդա արտահայթությունները ;
• մասնակի կիրառում ;
• նմուշների համապատասխանություն (անգլ.՝ pattern matching), ֆունկցիոնալ նմուշներ, որոնք պահպանում են արտահայտությունները
• հանրահաշվական տվյալների տեսակները, ներառյալ կեղծ անսահմանները
• ցուցակի ընդգրկում;
• Արտաքին գործառույթների ինտերֆեյսի միջոցով^[9] իմպերատիվ ծրագրավորման լեզուներով իրականացվող ծրագրերի հետ ինտեգրվելու հնարավորություն:

Վերջին լեզվական ստանդարտի (Haskell'98) ընդունումից ի վեր, առաջատար լեզվական իրականացումները (ghc և hugs) լրացվել են բազմաթիվ լրացուցիչ հնարավորություններով։

• Ավելի բարձր աստիճանի պարամետրային պոլիմորֆիզմ տիպի փոփոխականների քանակականացման պատճառով - բնականաբար, բացառելով տիպի եզրակացությունը .
• ֆունկցիոնալ կախվածություններ.

Haskell լեզվի մի քանի իրականացում կա^[10]: Որոշ իրականացումներ կենտրոնացած են գործնական կիրառությունների վրա, մինչդեռ մյուսները հիմնականում ակադեմիական հետաքրքրություն են ներկայացնում:

Գործնականում ամենատարածվածը^[11] օպտիմիզացնող GHC կոմպիլյատորն է, որը ստեղծում է արագ կոդ և թույլ է տալիս օգտագործել բազմաթիվ լեզուների ընդլայնումներ։ GHC-ն կարող է օպտիմիզացնել ծրագրերի և՛ արագությունը, և՛ կոմպակտությունը, ինչպես նաև կարող է ստեղծել բազմաֆունկցիոնալ և զուգահեռացված կոդ: GHC-ն աշխատում է Windows, MacOS X և Unix-ի նման մի քանի հարթակներում (Linux, *BSD, Solaris): GHC-ն Haskell պլատֆորմի ստանդարտ կոմպիլյատորն է, և դրա վրա է, որ առաջին անգամ փորձարկվում են բոլոր նոր գրադարանները^[12]:

Լեզվի մեկ այլ հայտնի իրականացում HUGS թարգմանիչն է: Այն գրված է C- ով, ունի փոքր բաշխման չափ և աշխատում է գրեթե բոլոր հարթակներում։ HUGS-ն ապահովում է ինտերակտիվ ծրագրավորման միջավայր, բայց կարող է նաև գործարկել Haskell ծրագրերը սկրիպտային լեզուների ոճով: Windows-ի օգտվողները կարող են օգտվել WinHugs գրաֆիկական ինտերակտիվ միջավայրից: Քանի որ HUGS-ը թարգմանիչ է, դրանում աշխատող ծրագրերն ավելի դանդաղ են աշխատում, քան Haskell կոմպիլյատորների մեծամասնության կողմից արտադրված կոդը: HUGS-ը հաճախ առաջարկվում է որպես լեզվի ուսուցման միջավայր: HUGS-ը լիովին աջակցում է Haskell 98 լեզվի ստանդարտը, ինչպես նաև լեզվի ամենատարածված ընդլայնումներից մի քանիսը:

Այլ հայտնի իրականացումներ^[13]

• nhc98-ը արագ կոմպիլյատոր է, որն աջակցում է Haskell 98 ստանդարտին, որը գրված է Haskell 98–ով; հասանելի է բոլոր Unix-ի նման հարթակների համար, ներառյալ MacOS X-ը և Windows/cygwin-ը;
• YHC (York Haskell Compiler) - որի նպատակն է լինել ավելի շարժական և արդյունավետ, աջակցում է Hat debugger-ին, առաջացնում է միջանկյալ բայթկոդ, որը կարող է օգտագործվել ծրագրավորման այլ լեզուներով կոդ ստեղծելու համար.
• UHC (Utrecht Haskell Compiler) - կոմպիլյատոր, որը գրեթե ամբողջությամբ աջակցում է Haskell 98-ին, ինչպես նաև որոշ ընդլայնումներ, աջակցում է գլոբալ ծրագրերի վերլուծություն, ունի մի քանի կոդերի գեներատորներ, այդ թվում՝ գրեթե լիովին ֆունկցիոնալ JVM կոդերի գեներատոր, LLVM-ի կոդերի գեներատորներ և մշակման փուլում գտնվող CLR, աշխատում է Unix-ի նման համակարգերի վրա (ներառյալ MacOS X և Windows/cygwin);
• HBI և HBC - թարգմանիչ և կազմող, որոնք աջակցում են Haskell 98 ստանդարտին որոշ ընդլայնումներում, աշխատում է հենց Linux-ով
• LHC (The Luxurious LHC Haskell Optimization System) այլընտրանքային կոդերի գեներատոր է GHC-ի համար, որն աջակցում է ծրագրի գլոբալ ցածր մակարդակի օպտիմիզացում։
• jhc-ն փորձարարական կոմպիլյատոր է՝ գլոբալ ծրագրերի օպտիմալացման հնարավորությունները ուսումնասիրելու համար.
• Yale Haskell-ը ում Haskell լեզվի վաղ իրականացումն է Lisp ծրագրավորման լեզվով :

2009 թվականին ձևավորվեց Haskell պլատֆորմի^[14] հայեցակարգը՝ լեզվի ստանդարտ բաշխում, որը ներառում է, բացի կոմպիլյատորից (GHC), նաև լրացուցիչ գործիքներ (Cabal փաթեթի կառուցման և տեղակայման համակարգ) և մի շարք հանրաճանաչ գրադարաններ։

2022 թվականի դրությամբ Haskell Platform-ը համարվում է Haskell-ը տեղադրելու հնացած միջոց:

Haskell կոմպիլյատորների մեծամասնությունը ուղղակիորեն արտադրում է մեքենայական կոդ այն պլատֆորմի համար, որն օգտագործում եք, բայց կան մի քանի նախագծեր, որոնք թույլ են տալիս կոդ արտադրել վիրտուալ մեքենաների համար կամ ստեղծել կոդ այլ ծրագրավորման լեզուներով: Նման նախագծերի հասունությունը և աջակցության մակարդակը տարբերվում են:

• Ընդհանուր լեզու Runtime (.Net):
  • MSIL կոդերի գեներատորի նախատիպ^[15] EHT/UHT կոմպիլյատորի համար
  • CLR-ին աջակցելու որոշ ծրագրեր նշված են GHC FAQ-ում^[16], որոնց կարգավիճակը 2010 թվականի սկզբին պարզ չէ:
• JavaScript:
  • JavaScript կոդերի գեներատոր GHC-ի համար^[17] - GHC-ի համար, որը թույլ է տալիս ծրագրերը կազմել JavaScript կոդի մեջ:
  • Ycr2Js^[18] - YHC կոմպիլյատոր բայթկոդի փոխարկիչ JavaScript-ին
  • Fay-ը Haskell-ի JavaScript-ի կոմպիլյատոր է
  • Ճարտարապետության նկարագրության լեզուներ (Verilog/VHDL).
    • Clash^[19]-ը ASIC-ների մշակման և FPGA-ների ծրագրավորման այլընտրանքային միջոց է

YHC կոմպիլյատորի միջոցով հասանելի են մի քանի հետաքրքիր թիրախային հարթակներ, մասնավորապես՝ Python-ում YHC բայթկոդի թարգմանիչը և YHC բայթկոդը Erlang Core փոխարկիչում, բայց դրանք դեռ փորձնական են: Կան նաև լեզվի ենթաբազմությունների ներդրում տարբեր թիրախային հարթակներում։

• մակրո ընդլայնում տիպի ստուգմամբ
• օբյեկտ-կողմնորոշված ծրագրավորում (O'Haskell, Haskell++ և Mondrian)

Լեզվի իրականացման ընդլայնումներ(կիրառվում է GHC-ի համար).

• տիպային համակարգի մշակում;
• բազմահոսքային;
• զուգահեռ հաշվարկներ;
• բաշխված հաշվարկ

Հետևյալ օրինակը ցույց է տալիս Haskell-ի միջոցով ֆակտորիալը հաշվարկելու ֆունկցիան։

 fac :: Integer -> Integer
 fac 0 = 1
 fac n | n > 0 = n * fac (n - 1)

Այս սահմանումը նկարագրում է ֆակտորիալ հաշվարկման գործընթացը որպես ռեկուրսիվ ֆունկցիա : Այս սահմանումը նման է համակարգչային գիտության դասագրքերում առկա սահմանմանը։ Վերը նշված օրինակը կարող է վերաշարադրվել հետևյալ ձևով

fac n = product [1..n]

որը համապատասխանում է ֆակտորիայի մաթեմատիկական սահմանմանը։

Վերոնշյալ կոդի առաջին տողը պարտադիր չէ և որը համարվում է ֆունկցիոնալ տիպի հայտարարում, այսինքն՝ սահմանում է արգումենտի տեսակները (նշված վերջին « -> »-ից առաջ) և վերադարձի տեսակը (նշված է վերջին « -> »-ից հետո): Այս տողը կարելի է կարդալ հետևյալ կերպ. fac ֆունկցիան ունի ( :: ) տեսակ՝ ամբողջ թվից ամբողջ թիվ ( Integer -> Integer ): Սա նշանակում է, որ այն ստանում է մեկ ամբողջ թիվ որպես մուտքագրում (գրված է «->»-ի ձախ կողմում) և վերադարձնում է արդյունք, որը նույնպես ամբողջական տիպի է (գրված է «->»-ի աջ կողմում): Եթե ծրագրավորողը հստակորեն չի նշել տեսակները, ապա կոմպիլյատորը կամ թարգմանիչը կարող է ինքնաբերաբար որոշել դրանք:

Երկրորդ և երրորդ տողերը կազմում են ֆունկցիայի մարմնի սահմանումը: Սահմանումը բաղկացած է նախադասություններից: Յուրաքանչյուր նախադասություն նմուշ-արտահայտություն զույգ է: Կոմպիլյատորը կամ թարգմանիչը օգտագործում է նմուշների համապատասխանության մեխանիզմ՝ արտահայտություններից մեկն ընտրելու համար: Այս դեպքում սահմանման երկրորդ տողը կընտրվի, երբ fac ֆունկցիան կանչելիս իրական պարամետրը հավասար է զրոյի:

Երրորդ տողում, ի լրումն նմուծների համապատասխանության մեխանիզմի, օգտագործվում է լրացուցիչ արտահայտություն՝ n > 0։ Այն ապահովում է, որ ֆունկցիան չի աշխատի բացասական թվերի համար, որոնց համար ֆակտորիալը սահմանված չէ: Եթե բացասական թիվ փոխանցվի որպես փաստացի պարամետր fac ֆունկցիային, ծրագիրը կդադարեցվի սխալի հաղորդագրությամբ:

Հակադարձ լեհական նշումով արտահայտությունները հաշվարկելու ամենապարզ հաշվիչը կարելի է սահմանել Haskell-ում՝ օգտագործելով մեկ ֆունկցիա

 calc :: String -> Float
 calc = head . foldl f [] . words
   where 
     f :: [Float] -> String -> [Float]
     f (x:y:zs) "+"    = (y + x):zs
     f (x:y:zs) "-"    = (y - x):zs
     f (x:y:zs) "*"    = (y * x):zs
     f (x:y:zs) "/"    = (y / x):zs
     f (x:y:zs) "FLIP" = y:x:zs
     f (x:zs)   "ABS"  = (abs x):zs
     f xs       y      = read y : xs

Մուտքային արտահայտությամբ սկզբնական տողը այնուհետև բաժանվում է words ստանդարտ ֆունկցիայի միջոցով բառերի ցանկի` տողերի միջև բացատ նիշերի միջև, որը մշակվում է ձախից foldl ֆունկցիայի միջոցով, ձախից աջ foldl մեկ բառով, օգտագործելով f ֆունկցիան, որը պահպանում է ընթերցված թվերի և միջանկյալ արժեքների աշխատանքային ցուցակը (առաջին [] - դատարկ ցուցակ) և յուրաքանչյուր մուտքային բառ մեկնաբանում է որպես թվաբանական ֆունկցիայի նշանակում կամ որպես թիվ, երբ գնահատում է արտահայտության վերջնական արժեքը ( որը կլինի աշխատանքային ցուցակում առաջին մնացած արժեքը՝ մուտքագրված արտահայտության բառացանկը մշակելուց հետո, որպեսզի այն հնարավոր լինի այնտեղից ստանալ՝ օգտագործելով head ստանդարտ գործառույթները):

Այստեղ (.) ֆունկցիաների կոմպոզիցիայի օպերատորն է, (f . g) x = f (gx) . Օրինակ՝

*Main> calc "1 2 3 + 4 * - ABS"
19.0

Մեկ այլ օրինակ ցույց է տալիս Ֆիբոնաչիի թվերի անվերջ ցուցակը գծային ժամանակում հաշվարկելու եղանակ

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

Այստեղ անսահման ցուցակի հետագա արժեքները նշված են նախորդների հիման վրա՝ սկզբնական 0 ով և 1 ՝ որպես ցուցակի առաջին երկու տարրեր, և գեներատոր արտահայտություն՝ zipWith (+) fibs (tail fibs) գնահատելով բոլոր տարրերը՝ սկսած երրորդից՝ հիմնվելով նախորդ երկուսի վրա՝ zipWith (+) ստանդարտ ֆունկցիայի միջոցով, որը գումարում է իր երկու մուտքային ցուցակների տարրերը զույգերով։

Այս սահմանումը ծույլ գնահատման մեխանիզմի օրինակ է, որը Haskell լեզվի կարևոր մասն է: Հասկանալու համար, թե ինչպես է գործում այս սահմանումը, կարող եք հաշվի առնել առաջին յոթ Ֆիբոնաչիի թվերը՝ օգտագործելով այն.

fibs         = 0 : 1 : 1 : 2 : 3 : 5 : 8 : ...
               +   +   +   +   +   +
tail fibs    = 1 : 1 : 2 : 3 : 5 : 8 : ...
               =   =   =   =   =   =
zipWith (+)  = 1 : 2 : 3 : 5 : 8 : ...
fibs = 0 : 1 : 1 : 2 : 3 : 5 : 8 : ...

Նույնը կարելի է գրել նաև ցուցակի սպեցիֆիկատորներ օգտագործելիս,

 fibs = 0 : 1 : [a + b | (a,b) <- zip fibs (tail fibs)]

կամ GHC կոմպիլյատորում ներդրված Haskell լեզվի ընդլայնում (զուգահեռ ցանկի սահմանիչներ,անգլ.՝ parallel list comprehensions ):

 fibs = 0 : 1 : [a + b | a <- fibs       
                       | b <- tail fibs]

կամ օգտագործելով ուղղակիորեն ինքնահղում գեներացնող ֆունկցիա .

 fibs = 0 : 1 : next fibs
   where
     next (a: t@(b:_)) = (a+b) : next t

Այս օրինակները ցույց են տալիս, թե ինչպես կարող են օգտագործվել ցուցակի արտահայտությունները ( ցուցակի գեներատորներ ): Բոլոր պարզ թվերը սովորական եղանակով գտնելու իրականացում ( յուրաքանչյուր թվի պարզության ստուգում ).

 -- ընդհանուր սահմանում (բոլոր բնական թվերը > 1, որոնք պարզ են)
 primeNums = 2 : [n | n <- [3..], isPrime n]
 
 -- Թիվն պարզ է, եթե չունի (պարզ) գործակից
 isPrime n = foldr (\p r-> p*p>n || (rem n p /= 0 && r)) True primeNums

կամ օգտագործելով Էրատոսթենեսի մաղը, իր նախատիպային, անարդյունավետ տարբերակով,

 primes = (map head . scanl minus [2..] . map (\p -> [p, p+p..])) primes

կամ արդյունավետ՝ կոմպոզիտային թվերի հոսքերի նախնական կասկադային համադրմամբ

 primes = 2 : _Y ((3:) . minus [5,7..] . unionAll . map (\p -> [p*p, p*p+2*p..]))
   where 
     _Y g = g (_Y g)
     unionAll ((x:xs):t) = x : union xs (unionAll (pairs t))
     pairs ((x:xs):ys:t) = (x : union xs ys) : pairs t

կամ հատված առ հատված, զանգվածներով,

import Data.Array
import Data.List (tails, inits)

ps = 2 : [n | (r:q:_, px) <- (zip . tails . (2:) . map (^2)) ps (inits ps),
              (n,True)    <- assocs (
                                accumArray (\_ _ -> False) True (r+1,q-1)
                     [(m,()) | p <- px, 
                               let s = div (r+p) p * p,  m <- [s,s+p..q-1]] )]

օգտագործելով կանոնական ֆունկցիաները minus, union^[20] ):

union (x:xs) (y:ys) = case compare x y of
         LT -> x : union  xs (y:ys)
         EQ -> x : union  xs    ys
         GT -> y : union (x:xs) ys
union a b = a ++ b
minus (x:xs) (y:ys) = case compare x y of
         LT -> x : minus  xs (y:ys)
         EQ ->     minus  xs    ys
         GT ->     minus (x:xs) ys
minus a b = a

Թվային ինտեգրում ${\displaystyle \int \limits _{0}^{2\pi }x\sin x\,{\rm {d}}x=-2\pi }$ սեղանի մեթոդով:

trapezeIntegrate f a b n =
    ((sum $ map f [a + h, a + 2*h .. b - h]) + t) * h
    where
        t = (f a + f b)/2
        h = (b - a) / n

main = do
    print $ trapezeIntegrate (\x -> x*sin x) 0 (2*pi) 100

-- Արդյունք: -6.281118086046067

Ստորև բերված օրինակը ցույց է տալիս,ինչպես աշխատել Unicode տողերի հետ:

import Data.Char (toLower, isAlpha)

palindrom :: [Char] -> Bool
palindrom s =
    norm == reverse norm
    where norm = map toLower $ filter isAlpha $ s

test :: [Char] -> IO ()
test s =
    putStrLn $ s ++ ": " ++ show (palindrom s)

main = do
    test "А в Енисее — синева"
    test "А роза упала на лапу Азора"
    test "Не роза упала на лапу Азора"
    test "Мир как Рим"
    test "Мир не Рим"
    test "I prefer Pi"
    test "حوت فمه مفتوح"
    test "Ne mateno, bone tamen"

-- Вывод:
-- А в Енисее — синева: True
-- А роза упала на лапу Азора: True
-- Не роза упала на лапу Азора: False
-- Мир как Рим: True
-- Мир не Рим: False
-- I prefer Pi: True
-- حوت فمه مفتوح: True
-- Ne mateno, bone tamen: True

Լեզուն որոշակի տարածում ձեռք է բերել առևտրային միջավայրում^[21], ինչին, մասնավորապես, նպաստել է համայնքի ավանդույթը՝ արտոնագրերով գրադարաններ թողարկելու համար (ազատ հասանելի գրադարանների ավելի քան 70%-ը բաշխվում է BSD-ի, MIT-ի լիցենզիաների պայմաններով կամ գտնվում են հանրային սեփականություն):

Haskell-ում իրականացվող առևտրային նախագծերից են Bluespec SystemVerilog (կիսահաղորդչային սխեմաների նախագծման և ստուգման համար նախատեսված, Haskell լեզվի ընդլայնում)^[22], Cryptol (գաղտնագրման ալգորիթմների մշակման և ստուգման լեզու, իրականացված Haskell ծրագրավորման լեզվով): Առաջին պաշտոնապես հաստատված seL4 միկրոմիջուկը գրվել է նաև Haskell–ի միջոցով:

Haskell-ը ակտիվորեն օգտագործվում է ֆինանսական ծրագրավորման, ռիսկերի վերլուծության և որոշումների աջակցման համակարգերի ոլորտում: Haskell-ը օգտագործվում է քաղաքի լանդշաֆտային գեներատորի մշակողների կողմից խաղերի և Gamr7 սիմուլյացիաների համար^[23] : Առևտրային կազմակերպություններում (ներառյալ ԱՊՀ երկրներում) մասնավոր տեղեկատվական համակարգերի զարգացման համար ևս օգտագործվել է Haskell ծրագրավորման լեզուն^[24] :

Բաց կոդով գրադարանների և Haskell-ով գրված հավելվածների զգալի մասը հասանելի է Hackage-ի արխիվում: Դրանք ներառում են համընդհանուր նշագրման փոխարկիչ Pandoc, emacs-ի նմանվող տեքստային խմբագրիչ Yi և ինտեգրված զարգացման միջավայր Leksah : Համակարգի զարգացումներից են բաշխված տարբերակների կառավարման համակարգը Darcs-ը, House օպերացիոն համակարգը և խճանկարային պատուհանների կառավարիչ Xmonad-ը :

GHC կոմպիլյատորը հաճախ ծառայում է որպես փորձնական հարթակ՝ ֆունկցիոնալ ծրագրավորման և օպտիմալացման նոր հնարավորությունների փորձարկման համար: Միևնույն ժամանակ, Agda, Curry, լեզուների կազմողները, ինչպես նաև Perl 6 Pugs լեզվի առաջին կոմպիլյատորն ու թարգմանիչը (ստեղծվել է ընդամենը մեկ ամսում), գրվել են Haskell-ով։

• Bryan O’Sullivan, John Goerzen, Don Stewart. Real World Haskell — O’Reilly, 2008—710 °C. ISBN 0-596-51498-0. ISBN 978-0-596-51498-3
• Душкин Роман Викторович. Функциональное программирование на языке Haskell / Гл. ред. Д. А. Мовчан;. — М.: ДМК Пресс,, 2008. — 544 с., ил. с. — 1500 экз. — ISBN 5-94074-335-8

• Graham Hutton. «Programming in Haskell». Cambrige University Press. ISBN 978-0-521-87172-3. ISBN 978-0-521-69269-4
• Kees Doets, Jan van Eijck. «The Haskell Road to Logic, Maths and Programming». ISBN 0-9543006-9-6.

• haskell.org — հիմնական կայք,պարունակում է տարբեր տեղեկատու նյութեր, Haskell թարգմանիչների և կոմպիլյատորների ցանկ (ներկայումս բոլոր թարգմանիչները և կոմպիլյատորները անվճար են): Բացի այդ, կա ֆունկցիոնալ ծրագրավորման տեսության և այլ լեզուների վերաբերյալ ռեսուրսների հղումների ընդարձակ ցանկ (Standard ML)։
• Կայք–գիրք «Learn You a Haskell for Great Good!» Արխիվացված 2021-01-12 Wayback Machine.
• .Ռոման Դուշկին Курс лекций по функциональному программированию
• Արտյոմ Գավրիչենկով,Ֆեոդոր Սախարով Спецкурс «Теория функционального программирования. Язык Haskell»
• Պոլ Հյուդակ, Ջոն Պետերսոն, Ջոզեֆ Ֆասել (2007 թ․ մարտի 3). «Мягкое введение в Haskell, часть 1». RSDN (ռուսերեն). Վերցված է 2014 թ․ ապրիլի 13-ին.{{cite web}}: CS1 սպաս․ բազմաթիվ անուններ: authors list (link); «часть 2».
• Դենիս Շեվչենկո. «О Haskell по-человечески». github.