system
Răspunde în limba română, în stilul Wikipedia, cat mai corect gramatical.
user
Care sunt informațiile importante despre Haskell?
assistant
Haskell este un limbaj de programare funcțională. Poartă numele lui Curry Haskell.

Haskell se bazează pe semantica, dar nu pe sintaxa, a limbajului de programare Miranda, care a servit la concentrarea eforturilor grupului de lucru inițial Haskell . Haskell este utilizat pe scară largă în mediul academic și în industrie. Ultimul standard al lui Haskell este Haskell 2010. Începând din mai 2016, un grup, lucrează la următorul standard, Haskell 2020.

Istorie 
După lansarea lui Miranda de către Research Software Ltd. în 1985, interesul pentru limbile funcționale leneș a crescut. Până în 1987, au existat mai mult de o duzină de limbi de programare pur strict funcționale. Miranda a fost cea mai utilizată, dar a fost software proprietar. La conferința privind limbile de programare funcțională și arhitectura informatică (FPCA '87) din Portland, Oregon, a existat un consens puternic cu privire la crearea unui comitet care să definească un standard deschis pentru astfel de limbi. Scopul comitetului a fost acela de a consolida programarea funcțională existente într-o limbă comună, care să servească drept bază pentru cercetarea viitoare în designul în limba funcțională.

Haskell de la 1.0 la 1.4 
Prima versiune a lui Haskell ("Haskell 1.0") a fost definită în 1990. Eforturile comitetului au dus la o serie de definiții lingvistice (1.0, 1.1, 1.2, 1.3, 1.4).

Haskell 98 
La sfârșitul anului 1997, seria a culminat cu Haskell 98, menită să specifice o versiune stabilă, minimală și portabilă a limbii și o bibliotecă standard de însoțire pentru predare și ca bază pentru viitoarele extensii. Comitetul a salutat în mod expres crearea de extensii și variante ale lui Haskell 98 prin adăugarea și încorporarea caracteristicilor experimentale.

În februarie 1999, standardul de limbă Haskell 98 a fost inițial publicat ca Raportul Haskell 98. În ianuarie 2003, o versiune revizuită a fost publicată ca Haskell 98 Language and Libraries: Raportul revizuit. Limba continuă să evolueze rapid, implementarea Glasgow Haskell Compiler (GHC) reprezentând standardul de facto actual.

Haskell 2010 
La începutul anului 2006, a început procesul de definire a unui succesor al standardului Haskell 98, denumit informal Haskell Prime. Acest obiectiv a fost intenționat a fi un proces incremental continuu de revizuire a definiției limbajului, generând o nouă revizie o dată pe an. Prima revizuire, numită Haskell 2010, a fost anunțată în noiembrie 2009 și publicată în iulie 2010.

Haskell 2010 este o actualizare incrementală a limbii, care cuprinde mai multe caracteristici bine utilizate și necontroversate activate anterior prin intermediul unor steaguri specifice compilatorului.

Caracteristici ale limbajului funcțional Haskell 

Spre deosebire de limbajele imperative care manipulează practic date sub formă de numere întregi sau valori codate prin numere întregi (caractere, stringuri, pointeri), limbajele funcționale manipulează funcții codate prin "expresii lambda". Dacă limbajul funcțional e compilat sunt codate prin combinatori. Cum mulțimea functiilor este mai bogată decât cea a numerelor întregi (are un cardinal mai mare), asemenea limbaje sunt mult mai expresive.

La nivel pragmatic, orice limbaj functional poate fi văzut ca un manipulator de algoritmi, exprimați cel mai adesea ca la orele de matematică elementară.

Teoria matematică a calculului lambda se studiază în cadrul cursului de Programare funcțională.

Alte informații despre limbajul Haskell 
 în Haskell puteți scrie programe sigure, funcțiile din limbajul funcțional nefiind afectate de efecte externe, cum ar fi schimbări de variabile globale.
 în Haskell puteți manipula algoritmi sub formă de funcții. Se deschide astfel ușa către o serie de domenii incluzând printre ele "Algoritmii genetici" unele optimizari, "Șabloane de programare", "Inteligența artificială", "Sisteme adaptive" și alte domenii
 putem modela procese, care se combină între ele, deoarece avem la dispoziție compunerea de funcții.
 putem face verificări ale datelor folosind parsere modulare ale căror efecte / verificări asupra intrărilor se compun 
 putem scrie algoritmi generici urmând ca funcția/prelucrarea care lipsește să fie furnizată ca parametru ulterior
 putem demonstra matematic corectitudinea funcțiilor scrise, dacă se cere așa ceva
 avem la dispoziție funcții anonime, funcții de unică întrebuințare.
 deoarece aplicarea funcțiilor asociază la dreapta iar în cursul calculelor regulile de reducere se pot aplica în mai multe locuri din formulă, evaluarea unei formule se poate face pe mai multe procesoare conlucrând! Acest lucru califică limbajele funcționale (bazate pe combinatori și/sau lambda calcul) printre limbajele din deceniul procesării dual-core și/sau quad-core.
 în Haskell, limbaj funcțional pur, fără efecte laterale, funcțiile dau întotdeauna același rezultat (da, chiar și funcțiile pentru I/O - vedeți monada de I/O) ceea ce permite garantarea calității software-ului. Permite de asemenea și demonstrarea calității lui.
 puteți încapsula șabloane de programare în funcții de ordin superior
 puteți lucra în stiluri cum sunt generic programming și monadic programming (cel puțin în Haskell și ceva mai greu în alte limbaje funcționale cum sunt LISP și Scheme)
 daca limbajul admite clase (Haskell admite, iar Lisp-ul nu) puteți defini clase în care datele manipulate sunt de fapt funcții.
 în Haskell, limbaj funcțional pur, 'acțiunile de I/O' se pot folosi și ca instrucțiuni, și ca date. Pot fi plasate pe liste, pe arbori sau pe alte structuri, puteti parcurge cum doriți lista sau arborele și construi dinamic, din mers, o acțiune de I/O compusă. Această acțiune numită main este executată când rulați programul.

Exemple de coduri 
Un Program Hello, world! în Haskell (doar ultima linie este strict necesară):
module Main (main) where          -- not needed in interpreter, is the default in a module file

main :: IO ()                       -- the compiler can infer this type definition
main = putStrLn "Hello, World!"

Funcția factorială în Haskell, definită în câteva moduri diferite:
-- Type annotation (optional, same for each implementation)
factorial :: (Integral a) => a -> a

-- Using recursion (with the "ifthenelse" expression)
factorial n = if n < 2
              then 1
              else n * factorial (n - 1)

-- Using recursion (with pattern matching)
factorial 0 = 1
factorial n = n * factorial (n - 1)

-- Using recursion (with guards)
factorial n
   | n < 2     = 1
   | otherwise = n * factorial (n - 1)

-- Using a list and the "product" function
factorial n = product [1..n]

-- Using fold (implements "product")
factorial n = foldl (*) 1 [1..n]

-- Point-free style
factorial = foldr (*) 1 . enumFromTo 1

Deoarece tipul Integer are o precizie arbitrară, acest cod va calcula valori cum ar fi factorial 100000 (un număr de 456,574 de cifre), fără pierderi de precizie.

O implementare a unui algoritm similar listei de quicksort, unde primul element este luat ca pivot:
-- Type annotation (optional, same for each implementation)
quickSort :: Ord a => [a] -> [a]

-- Using list comprehensions
quickSort []     = []                               -- The empty list is already sorted
quickSort (x:xs) = quickSort [a | a <- xs, a < x]   -- Sort the left part of the list
                   ++ [x] ++                        -- Insert pivot between two sorted parts
                   quickSort [a | a <- xs, a >= x]  -- Sort the right part of the list

-- Using filter
quickSort []     = []
quickSort (x:xs) = quickSort (filter (<x) xs)
                   ++ [x] ++
                   quickSort (filter (>=x) xs)

Sigla Haskell din partea de sus a acestei pagini a fost generată de codul Haskell.

Note

Vezi și 
 Listă alfabetică de limbaje de programare

Legături externe 
  Pagina engleză a comunității de Haskell
  Pagina comunității de Haskell din România

Haskell