Haskell

De la Wikipedia, enciclopedia liberă
Jump to navigation Jump to search
Haskell
Haskell-Logo.svg
Extensii fișiere.hs, .lhs
ParadigmăFunctional
Apărut în 1990; 29 ani în urmă (1990)[1]
Dezvoltat deLennart Augustsson, Dave Barton, Brian Boutel, Warren Burton, Joseph Fasel, Kevin Hammond, Ralf Hinze, Paul Hudak, John Hughes, Thomas Johnsson, Mark Jones, Simon Peyton Jones, John Launchbury, Erik Meijer, John Peterson, Alastair Reid, Colin Runciman, Philip Wadler
Tipul de tipărireInferred, static, strong
Implementări majoreGHC, Hugs, NHC, JHC, Yhc, UHC
DialecteHelium, Gofer
Influențat deClean,[2] FP,[2] Gofer,[2] Hope and Hope+,[2] Id,[2] ISWIM,[2] KRC,[2] LISP,[2] Miranda,[2] ML and Standard ML,[2] Orwell, SASL,[2] Scheme,[2] SISAL[2]
InfluențeAgda,[3] Bluespec,[4] C++11/Concepts,[5] C#/LINQ,[6][7][8][9] CAL,[necesită citare] Cayenne,[6] Clean,[6] Clojure,[10] CoffeeScript,[11] Curry,[6] Elm, Epigram,[necesită citare] Escher,[12] F#,[13] Frege,[14] Hack,[15] Idris,[16] Isabelle,[6] Java/Generics,[6] LiveScript,[17] Mercury,[6] Ωmega,[necesită citare] Perl 6,[18] PureScript,[19] Python,[6][20] Rust,[21] Scala,[6][22] Swift,[23] Timber,[24] Visual Basic 9.0[6][7]
Sistem de operareCross-platform
Websitewww.haskell.org

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 [25]. Haskell este utilizat pe scară largă în mediul academic[26][27] și în industrie[28]. Ultimul standard al lui Haskell este Haskell 2010. Începând din mai 2016, un grup, lucrează la următorul standard, Haskell 2020[29].

Istorie[modificare | modificare sursă]

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ă[30].

Haskell de la 1.0 la 1.4[modificare | modificare sursă]

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

Haskell 98[modificare | modificare sursă]

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[30].

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

Haskell 2010[modificare | modificare sursă]

La începutul anului 2006, a început procesul de definire a unui succesor al standardului Haskell 98, denumit informal Haskell Prime[33]. 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[34] ș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[modificare | modificare sursă]

Haskell prezintă o evaluare leneșă a expresiilor, adică "apel prin nevoi"

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ă.

Haskell acceptă atât tipurile de sume, cât și tipurile de produse

Alte informații despre limbajul Haskell[modificare | modificare sursă]

  • î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[modificare | modificare sursă]

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[35].

Note[modificare | modificare sursă]

  1. ^ a b Hudak et al. 2007.
  2. ^ a b c d e f g h i j k l m Peyton Jones 2003, p. xi
  3. ^ Norell, Ulf (). „Dependently Typed Programming in Agda” (PDF). Gothenburg: Chalmers University. Accesat în . 
  4. ^ Hudak et al. 2007, p. 12-38,43.
  5. ^ Stroustrup, Bjarne; Sutton, Andrew (). „Design of Concept Libraries for C++” (PDF). Arhivat din original (PDF) la . 
  6. ^ a b c d e f g h i j Hudak et al. 2007, pp. 12-45–46.
  7. ^ a b Meijer, Erik (). „Confessions of a Used Programming Language Salesman: Getting the Masses Hooked on Haskell”. Oopsla 2007. CiteSeerX 10.1.1.72.868Accesibil gratuit. 
  8. ^ Meijer, Erik (). „C9 Lectures: Dr. Erik Meijer – Functional Programming Fundamentals, Chapter 1 of 13”. Channel 9. Microsoft. Accesat în . 
  9. ^ Drobi, Sadek (). „Erik Meijer on LINQ”. InfoQ. QCon SF 2008: C4Media Inc. Accesat în . 
  10. ^ Hickey, Rich. „Clojure Bookshelf”. Listmania!. Arhivat din original la . Accesat în . 
  11. ^ Heller, Martin (). „Turn up your nose at Dart and smell the CoffeeScript”. JavaWorld. InfoWorld. Accesat în . 
  12. ^ „Declarative programming in Escher” (PDF). Accesat în . 
  13. ^ Syme, Don; Granicz, Adam; Cisternino, Antonio (). Expert F#. Apress. p. 2. F# also draws from Haskell particularly with regard to two advanced language features called sequence expressions and workflows. 
  14. ^ Wechsung, Ingo. „The Frege Programming Language” (PDF). Accesat în . 
  15. ^ „Facebook Introduces 'Hack,' the Programming Language of the Future”. WIRED. . 
  16. ^ „Idris, a dependently typed language”. Accesat în . 
  17. ^ „LiveScript Inspiration”. Accesat în . 
  18. ^ „Glossary of Terms and Jargon”. Perl Foundation Perl 6 Wiki. The Perl Foundation. Arhivat din original la . Accesat în .  Parametru necunoscut |df= ignorat (ajutor)
  19. ^ Freeman, Phil (). „PureScript by Example”. Leanpub. Accesat în . 
  20. ^ Kuchling, A. M. „Functional Programming HOWTO”. Python v2.7.2 documentation. Python Software Foundation. Accesat în . 
  21. ^ „The Rust Reference: Appendix: Influences”. Accesat în . 
  22. ^ Fogus, Michael (). „MartinOdersky take(5) toList”. Send More Paramedics. Accesat în . 
  23. ^ Lattner, Chris (). „Chris Lattner's Homepage”. Chris Lattner. Accesat în . The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list. 
  24. ^ „Timber/History”. Accesat în . 
  25. ^ Edward Kmett, Edward Kmett - Type Classes vs. the World
  26. ^ „Haskell in education”. Accesat în . 
  27. ^ „Haskell in research”. Accesat în . 
  28. ^ „Haskell in industry”. Accesat în . 
  29. ^ https://mail.haskell.org/pipermail/haskell-prime/2016-April/004050.html
  30. ^ a b c Peyton Jones 2003, Preface.
  31. ^ Peyton Jones 2003.
  32. ^ „Haskell Wiki: Implementations”. Accesat în . 
  33. ^ „Welcome to Haskell'. The Haskell' Wiki. 
  34. ^ Marlow, Simon (). „Announcing Haskell 2010”. Haskell (Mailing list). Accesat în . 
  35. ^ Haskell.org, Thompson-Wheeler logo in Haskell. (2010) The public domain Haskell script which generates .svg of this logo. The logo is a monad bind (>>=) overlaid by a lambda (λ).

Vezi și[modificare | modificare sursă]

Legături externe[modificare | modificare sursă]