Դիտել Haskell էջի վիքիկոդը

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

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

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

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

1990 թվականին առաջարկվեց լեզվի առաջին տարբերակը՝ Haskell 1.0։ Հետագայում հանձնաժողովի աշխատանքները շարունակվեցին, և 1999 թվականին լույս տեսավ «Haskell 98 զեկույցը» <ref>[http://www.haskell.org/onlinereport/ The Haskell 98 Language Report] {{Webarchive|url=https://web.archive.org/web/20100308015222/http://www.haskell.org/onlinereport/ |date=2010-03-08 }} — получено 05.02.2010</ref>, որը երկար տարիներ դարձավ լեզվի կայուն չափանիշ։ Լեզուն, այնուամենայնիվ, շարունակեց արագ զարգանալ, քանի որ GHC [[կոմպիլյատոր]]ը դե ֆակտո ստանդարտ էր նոր հնարավորությունների համար:

Լեզվի նոր տարբերակների մշակումը բաց է, այս գործընթացը կոչվում է Haskell' <ref>{{Cite web |title=Haskell Prime |url=http://hackage.haskell.org/trac/haskell-prime/ |archive-url=https://web.archive.org/web/20081219040836/http://hackage.haskell.org/trac/haskell-prime/ |archive-date=2008-12-19 |access-date=2010-02-05}}</ref> (Haskell Prime [ˈhæskəl praɪm])։ Յուրաքանչյուր ոք կարող է իր առաջարկները ներկայացնել քննարկման, առաջարկները քննարկվում են ամբողջ տարվա ընթացքում, հանձնաժողովն ընտրում և հայտարարում է այն առաջարկները, որոնք պատրաստ են ընդունելու, ձևավորվում է նոր հանձնաժողով և մինչև տարեվերջ պատրաստվում է լեզվի նոր տարբերակը։ Այսպիսով, լեզվի նոր տարբերակներ այժմ կարող են հայտնվել ամեն տարի: Ծրագրով նախատեսվում է որոշ վերանայումներ հայտարարել «կարևոր» և պահպանել նման վերանայումները երկարատև  ժամանակի ընթացքում:

Haskell 2010 լեզվի տարբերակը հայտարարվել է 2009 թվականի վերջին <ref>{{Cite web |title=Simon Marlow, Announcing Haskell 2010 |url=http://www.haskell.org/pipermail/haskell/2009-November/021750.html |archive-url=https://web.archive.org/web/20150213025809/https://www.haskell.org/pipermail/haskell/2009-November/021750.html |archive-date=2015-02-13 |access-date=2009-12-26}}</ref>, սակայն վերջին «նշանակալի» տարբերակը (ստանդարտ) մնում է Haskell 98-ը։

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

* կողմնակի ազդեցությունների անթույլատրելիությունը ( լեզվի մաքրություն )։ Կողմնակի էֆեկտներով ծրագրեր գրելու ունակություն, առանց խախտելու [[Ֆունկցիոնալ ծրագրավորում|ֆունկցիոնալ ծրագրավորման]] [[պարադիգմ]]ը՝ օգտագործելով մոնադներ .
* [[Ստատիկ տիպավորում|ստատիկ]] ուժեղ ամբողջական տիպավորում ավտոմատ տիպի որոշմամբ՝ հիմնված Հինդլի-Միլներ տիպավորման վրա;
* ավելի բարձր կարգի գործառույթներ, ներառյալ [[Լամբդա արտահայտություն|լամբդա արտահայթությունները]] ;
* մասնակի կիրառում ;
* նմուշների համապատասխանություն ({{Lang-en|pattern matching}}), ֆունկցիոնալ նմուշներ, որոնք պահպանում են արտահայտությունները
* հանրահաշվական տվյալների տեսակները, ներառյալ կեղծ անսահմանները
* ցուցակի ընդգրկում;
* Արտաքին գործառույթների ինտերֆեյսի միջոցով <ref>{{Cite web |title=The Haskell 98 Foreign Function Interface 1.0: An Addendum to the Haskell 98 Report |url=http://www.cse.unsw.edu.au/~chak/haskell/ffi/ |archive-url=https://web.archive.org/web/20041010152241/http://www.cse.unsw.edu.au/~chak/haskell/ffi/ |archive-date=2004-10-10 |access-date=2004-10-16}}</ref> իմպերատիվ ծրագրավորման լեզուներով իրականացվող ծրագրերի հետ ինտեգրվելու հնարավորություն:

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

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

== Լեզվի իրականացումը ==
Haskell լեզվի մի քանի իրականացում կա <ref>{{Cite web |title=Реализации языка Haskell (англ.) |url=http://www.haskell.org/haskellwiki/Implementations |archive-url=https://web.archive.org/web/20100317121943/http://haskell.org/haskellwiki/Implementations |archive-date=2010-03-17 |access-date=2010-02-24}}</ref>: Որոշ իրականացումներ կենտրոնացած են գործնական կիրառությունների վրա, մինչդեռ մյուսները հիմնականում ակադեմիական հետաքրքրություն են ներկայացնում:

=== Կոմպիլյատորներ և ինտերպրետատորներ ===
Գործնականում ամենատարածվածը <ref>{{Cite news |title=2017 state of Haskell survey results |url=https://taylor.fausak.me/2017/11/15/2017-state-of-haskell-survey-results/#question-14 |archive-url=https://web.archive.org/web/20181108034002/http://taylor.fausak.me/2017/11/15/2017-state-of-haskell-survey-results/#question-14 |archive-date=2018-11-08 |access-date=2018-11-12 |work=taylor.fausak.me |language=en}}</ref> օպտիմիզացնող GHC կոմպիլյատորն է, որը ստեղծում է արագ կոդ և թույլ է տալիս օգտագործել բազմաթիվ լեզուների ընդլայնումներ։ GHC-ն կարող է օպտիմիզացնել ծրագրերի և՛ արագությունը, և՛ կոմպակտությունը, ինչպես նաև կարող է ստեղծել բազմաֆունկցիոնալ և զուգահեռացված կոդ:  GHC-ն աշխատում է [[Windows]], [[Մաք ՕԷս|MacOS X]] և [[UNIX|Unix]]-ի նման մի քանի հարթակներում ([[Լինուքս|Linux]], *BSD, [[Սոլարիս|Solaris]]): GHC-ն Haskell պլատֆորմի ստանդարտ կոմպիլյատորն է, և դրա վրա է, որ առաջին անգամ փորձարկվում են բոլոր նոր գրադարանները <ref>[https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/aos.pdf The Glasgow Haskell Compiler. The Architecture of Open Source Applications, Volume 2] {{Wayback}}, 2012{{En icon}}</ref>:

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

Այլ հայտնի իրականացումներ <ref>{{Cite web |title=A history of Haskell: being lazy with class — SIGPLAN, 2007 |url=http://www.sc.ehu.es/jiwlucap/history.pdf |archive-url=https://web.archive.org/web/20170909185749/http://www.sc.ehu.es/jiwlucap/history.pdf |archive-date=2017-09-09 |access-date=2017-09-09}}</ref>

* 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]] ծրագրավորման լեզվով :

=== Haskell Platform ===
2009 թվականին ձևավորվեց Haskell պլատֆորմի <ref>{{Cite web |title=The Haskell Platform |url=http://hackage.haskell.org/platform/ |archive-url=https://web.archive.org/web/20100227052926/http://hackage.haskell.org/platform/ |archive-date=2010-02-27 |access-date=2010-02-24}}</ref> հայեցակարգը՝ լեզվի ստանդարտ բաշխում, որը ներառում է, բացի կոմպիլյատորից (GHC), նաև լրացուցիչ գործիքներ (Cabal փաթեթի կառուցման և տեղակայման համակարգ) և մի շարք հանրաճանաչ գրադարաններ։

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

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

* Ընդհանուր լեզու Runtime (.Net):
** MSIL կոդերի գեներատորի նախատիպ <ref>{{Cite web |title=Running Haskell on the CLR (using UHC) |url=http://tom.lokhorst.eu/ehc/clr/ |archive-url=https://web.archive.org/web/20210809094458/https://fonts.googleapis.com/css?family=Merriweather%3A400%2C700%2C900%2C400italic%2C700italic%2C900italic%7CMontserrat%3A400%2C700%7CInconsolata%3A400&subset=latin%2Clatin-ext |archive-date=2021-08-09 |access-date=2010-02-24}}</ref> EHT/UHT կոմպիլյատորի համար
** CLR-ին աջակցելու որոշ ծրագրեր նշված են GHC FAQ-ում <ref>{{Cite web |title=1.5.1 Why isn’t GHC available for .NET or on the JVM? |url=http://www.haskell.org/haskellwiki/GHC:FAQ#Why_isn.27t_GHC_available_for_.NET_or_on_the_JVM.3F |archive-url=https://web.archive.org/web/20100329073510/http://www.haskell.org/haskellwiki/GHC:FAQ#Why_isn.27t_GHC_available_for_.NET_or_on_the_JVM.3F |archive-date=2010-03-29 |access-date=2010-02-24}}</ref>, որոնց կարգավիճակը 2010 թվականի սկզբին պարզ չէ:
* JavaScript:
** JavaScript կոդերի գեներատոր GHC-ի համար <ref>{{Cite web |title=кодогенератор JavaScript для GHC |url=http://vir.mskhug.ru/ |archive-url=https://web.archive.org/web/20100313172045/http://vir.mskhug.ru/ |archive-date=2010-03-13 |access-date=2010-02-24}}</ref> - GHC-ի համար, որը թույլ է տալիս ծրագրերը կազմել JavaScript կոդի մեջ:
** Ycr2Js <ref>{{Cite web |title=Yhc/Javascript, YCR2JS, a Converter of Yhc Core to Javascript |url=http://haskell.org/haskellwiki/Yhc/Javascript |archive-url=https://web.archive.org/web/20100603072155/http://haskell.org/haskellwiki/Yhc/Javascript |archive-date=2010-06-03 |access-date=2010-02-24}}</ref> - YHC կոմպիլյատոր բայթկոդի փոխարկիչ JavaScript-ին
** Fay-ը Haskell-ի JavaScript-ի կոմպիլյատոր է
** Ճարտարապետության նկարագրության լեզուներ (Verilog/VHDL).
*** Clash <ref>{{Cite web |title=CλaSH — From Haskell to Hardware |url=http://www.clash-lang.org/ |archive-url=https://web.archive.org/web/20180615032500/http://www.clash-lang.org/ |archive-date=2018-06-15 |access-date=2018-06-16}}</ref>-ը ASIC-ների մշակման և FPGA-ների ծրագրավորման այլընտրանքային միջոց է

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

=== Լեզուների ընդլայնումներ ===
* մակրո ընդլայնում տիպի ստուգմամբ
* [[Օբյեկտ կողմնորոշված ծրագրավորում|օբյեկտ-կողմնորոշված ծրագրավորում]] (O'Haskell, Haskell++ և Mondrian)

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

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

== Օրինակներ ==

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

<source lang="haskell">
 fac :: Integer -> Integer
 fac 0 = 1
 fac n | n > 0 = n * fac (n - 1)
</source>

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

<source lang="haskell">fac n = product [1..n]</source>

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

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

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

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

=== Հաշվիչ ===
Հակադարձ լեհական նշումով արտահայտությունները հաշվարկելու ամենապարզ [[Հաշվիչ-վճռող սարք|հաշվիչը]] կարելի է սահմանել Haskell-ում՝ օգտագործելով մեկ ֆունկցիա
<source lang="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
</source>

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

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

<source lang="haskell">
*Main> calc "1 2 3 + 4 * - ABS"
19.0
</source>

=== Ֆիբոնաչիի թվեր ===
Մեկ այլ օրինակ ցույց է տալիս [[Ֆիբոնաչիի թվեր]]ի անվերջ ցուցակը գծային ժամանակում հաշվարկելու եղանակ
<source lang="haskell">fibs = 0 : 1 : zipWith (+) fibs (tail fibs)</source>

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

Այս սահմանումը ծույլ գնահատման մեխանիզմի օրինակ է, որը 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 : ...

Նույնը կարելի է գրել նաև ցուցակի սպեցիֆիկատորներ օգտագործելիս,
<source lang="haskell">
 fibs = 0 : 1 : [a + b | (a,b) <- zip fibs (tail fibs)]
</source>

կամ GHC կոմպիլյատորում ներդրված Haskell լեզվի ընդլայնում (զուգահեռ ցանկի սահմանիչներ,{{Lang-en|parallel list comprehensions}} ):
<source lang="haskell">
 fibs = 0 : 1 : [a + b | a <- fibs       
                       | b <- tail fibs] 
</source>

կամ օգտագործելով ուղղակիորեն ինքնահղում գեներացնող ֆունկցիա .
<source lang="haskell">
 fibs = 0 : 1 : next fibs
   where
     next (a: t@(b:_)) = (a+b) : next t
</source>

=== Պարզ թվեր ===
Այս օրինակները ցույց են տալիս, թե ինչպես կարող են օգտագործվել ցուցակի արտահայտությունները ( ցուցակի գեներատորներ ): Բոլոր [[Պարզ թիվ|պարզ թվերը]] սովորական եղանակով գտնելու իրականացում ( յուրաքանչյուր թվի պարզության ստուգում ).
<source lang="haskell">
 -- ընդհանուր սահմանում (բոլոր բնական թվերը > 1, որոնք պարզ են)
 primeNums = 2 : [n | n <- [3..], isPrime n]
 
 -- Թիվն պարզ է, եթե չունի (պարզ) գործակից
 isPrime n = foldr (\p r-> p*p>n || (rem n p /= 0 && r)) True primeNums
</source>
կամ օգտագործելով [[Էրատոսթենեսի մաղ]]ը, իր նախատիպային, անարդյունավետ տարբերակով,
<source lang="haskell">
 primes = (map head . scanl minus [2..] . map (\p -> [p, p+p..])) primes
</source>

կամ արդյունավետ՝ կոմպոզիտային թվերի հոսքերի նախնական կասկադային համադրմամբ
<source lang="haskell">
 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
</source>
կամ հատված առ հատված, զանգվածներով,
<source lang="haskell">
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]] )]
</source>
օգտագործելով կանոնական ֆունկցիաները <code>minus</code>, <code>union</code> <ref>Функции из модуля [http://hackage.haskell.org/packages/archive/data-ordlist/0.4.4/doc/html/Data-List-Ordered.html Data.List.Ordered] {{Wayback}}</ref> ):
<source lang="haskell">
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
</source>

=== Թվային ինտեգրում ===
Թվային ինտեգրում <math>\int\limits_0^{2\pi}x\sin x\,{\rm d}x = -2\pi</math> սեղանի մեթոդով:<source lang="haskell">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
</source>

=== Պալինդրոմի ստուգում ===
Ստորև բերված օրինակը ցույց է տալիս,ինչպես աշխատել [[Յունիկոդ|Unicode]] տողերի հետ:
<source lang="haskell">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</source>

== Հավելվածներ, գրված Haskell ծրագրավորման լեզվով ==

=== Կոմերցիոն ծրագրեր ===
Լեզուն որոշակի տարածում ձեռք է բերել առևտրային միջավայրում <ref>{{En icon}}[http://www.haskell.org/haskellwiki/Haskell_in_industry Коммерческие применения языка Haskell] {{Wayback}}</ref>, ինչին, մասնավորապես, նպաստել է համայնքի ավանդույթը՝  արտոնագրերով գրադարաններ թողարկելու համար (ազատ հասանելի գրադարանների ավելի քան 70%-ը բաշխվում է BSD-ի, MIT-ի լիցենզիաների պայմաններով կամ գտնվում են հանրային սեփականություն):

Haskell-ում իրականացվող առևտրային նախագծերից են Bluespec SystemVerilog (կիսահաղորդչային սխեմաների նախագծման և ստուգման համար նախատեսված, Haskell լեզվի ընդլայնում) <ref>{{Cite web |title=Bluespec |url=http://homepages.inf.ed.ac.uk/wadler/realworld/bluespec.html |archive-url=https://web.archive.org/web/20100206121914/http://homepages.inf.ed.ac.uk/wadler/realworld/bluespec.html |archive-date=2010-02-06 |access-date=2010-02-06}}</ref>, Cryptol (գաղտնագրման ալգորիթմների մշակման և ստուգման լեզու, իրականացված Haskell ծրագրավորման լեզվով): Առաջին պաշտոնապես հաստատված seL4 միկրոմիջուկը գրվել է նաև Haskell–ի միջոցով:

Haskell-ը ակտիվորեն օգտագործվում է ֆինանսական ծրագրավորման, ռիսկերի վերլուծության և որոշումների աջակցման համակարգերի ոլորտում: Haskell-ը օգտագործվում է քաղաքի լանդշաֆտային գեներատորի մշակողների կողմից խաղերի և Gamr7  սիմուլյացիաների համար <ref>{{Cite web |title=Gamr7: UrbanPAD. The Software for 3D city & buildings creation. |url=http://gamr7.com/ |archive-url=https://web.archive.org/web/20100216202725/http://www.gamr7.com/ |archive-date=2010-02-16 |access-date=2010-02-18}}</ref> : Առևտրային կազմակերպություններում (ներառյալ ԱՊՀ երկրներում) մասնավոր տեղեկատվական համակարգերի զարգացման համար ևս օգտագործվել է Haskell ծրագրավորման լեզուն <ref>{{Հոդված}}</ref> :

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

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

== Ծանոթագրություններ ==
{{примечания|2}}

== Գրականություն ==
* ''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 с., ил.
 |серия         =
 |isbn          = 5-94074-335-8
 |тираж         = 1500
}}

* ''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.

== Արտաքին հղումներ ==
* {{url|haskell.org}} — հիմնական կայք,պարունակում է տարբեր տեղեկատու նյութեր, Haskell թարգմանիչների և կոմպիլյատորների ցանկ (ներկայումս բոլոր թարգմանիչները և կոմպիլյատորները անվճար են): Բացի այդ, կա ֆունկցիոնալ ծրագրավորման տեսության և այլ լեզուների վերաբերյալ ռեսուրսների հղումների ընդարձակ ցանկ ([[Standard ML]])։
* Կայք–գիրք [http://learnyouahaskell.com/ «Learn You a Haskell for Great Good!»].
* .Ռոման Դուշկին [https://web.archive.org/web/20041216080831/http://www.roman-dushkin.narod.ru/fp.html Курс лекций по функциональному программированию] 
* Արտյոմ Գավրիչենկով,Ֆեոդոր Սախարով  [https://web.archive.org/web/20131029203821/http://haskell.secsem.ru/2010/Lectures Спецкурс «Теория функционального программирования. Язык Haskell»] 
* {{cite web |url=http://www.rsdn.ru/article/haskell/haskell_part1.xml |title=Мягкое введение в Haskell, часть 1 |author=Պոլ Հյուդակ, Ջոն Պետերսոն, Ջոզեֆ Ֆասել |date=2007-03-03 |work=[[RSDN]] |publisher= |accessdate=2014-04-13 |language=ru}}; {{cite web
 |url         = http://rsdn.ru/article/haskell/haskell_part2.xml
 |title       = часть 2}}
* {{Cite web |url=https://github.com/denisshevchenko/ohaskell.guide |title=О Haskell по-человечески |author=Դենիս Շեվչենկո |work= |date= |publisher=[[github]]}}

[[Կատեգորիա:Ծրագրավորում]]