Haskell'ssemantics are historically based on those of theMiranda programming language, which served to focus the efforts of the initial Haskell working group.[28] The last formal specification of the language was made in July 2010, while the development of GHC continues to expand Haskell via language extensions.
Haskell is used in academia and industry.[29][30][31] As of May 2021[update], Haskell was the 28th most popular programming language byGoogle searches for tutorials,[32] and made up less than 1% of active users on theGitHub source code repository.[33]
After the release ofMiranda by Research Software Ltd. in 1985, interest in lazy functional languages grew. By 1987, more than a dozen non-strict, purely functional programming languages existed. Miranda was the most widely used, but it wasproprietary software. At the conference onFunctional Programming Languages and Computer Architecture (FPCA '87) inPortland, Oregon, there was a strong consensus that a committee be formed to define anopen standard for such languages. The committee's purpose was to consolidate existingfunctional languages into a common one to serve as a basis for future research in functional-language design.[34]
In early versions of Haskell up until and including version 1.2, user interaction andinput/output (IO) were handled by both streams based and continuation based mechanisms which were widely considered unsatisfactory.[36] In version 1.3,monadic IO was introduced, along with the generalisation of type classes to higher kinds (type constructors). Along with "do notation", which provides syntactic sugar for the Monad type class, this gave Haskell an effect system that maintained referential transparency and was convenient.
Other notable changes in early versions were the approach to the 'seq' function, which creates a data dependency between values, and is used in lazy languages to avoid excessive memory consumption; with it moving from a type class to a standard function to make refactoring more practical.
The first version of Haskell ("Haskell 1.0") was defined in 1990.[1] The committee's efforts resulted in a series of language definitions (1.0, 1.1, 1.2, 1.3, 1.4).
Hierarchy oftype classes in the Haskell prelude as of GHC 7.10. The inclusion of Foldable and Traversable (with corresponding changes to the type signatures of some functions), and of Applicative as intermediate between Functor and Monad, are deviations from the Haskell 2010 standard.
In late 1997, the series culminated inHaskell 98, intended to specify a stable, minimal, portable version of the language and an accompanying standardlibrary for teaching, and as a base for future extensions. The committee expressly welcomed creating extensions and variants of Haskell 98 via adding and incorporating experimental features.[34]
In February 1999, the Haskell 98 language standard was originally published asThe Haskell 98 Report.[34] In January 2003, a revised version was published asHaskell 98 Language and Libraries: The Revised Report.[27] The language continues to evolve rapidly, with theGlasgow Haskell Compiler (GHC) implementation representing the currentde facto standard.[37]
In early 2006, the process of defining a successor to the Haskell 98 standard, informally namedHaskell Prime, began.[38] This was intended to be an ongoing incremental process to revise the language definition, producing a new revision up to once per year. The first revision, namedHaskell 2010, was announced in November 2009[2] and published in July 2010.
Haskell 2010 is an incremental update to the language, mostly incorporating several well-used and uncontroversial features previously enabled via compiler-specific flags.
Hierarchical module names. Module names are allowed to consist of dot-separated sequences of capitalized identifiers, rather than only one such identifier. This lets modules be named in a hierarchical manner (e.g.,Data.List instead ofList), although technically modules are still in a single monolithic namespace. This extension was specified in an addendum to Haskell 98 and was in practice universally used.
Theforeign function interface (FFI) allows bindings to other programming languages. Only bindings toC are specified in the Report, but the design allows for other language bindings. To support this, data type declarations were permitted to contain no constructors, enabling robust nonce types for foreign data that could not be constructed in Haskell. This extension was also previously specified in an Addendum to the Haskell 98 Report and widely used.
So-calledn+k patterns (definitions of the formfact (n+1) = (n+1) * fact n) were no longer allowed. Thissyntactic sugar had misleading semantics, in which the code looked like it used the(+) operator, but in fact desugared to code using(-) and(>=).
The rules oftype inference were relaxed to allow more programs to type check.
Somesyntax issues (changes in the formal grammar) were fixed:pattern guards were added, allowing pattern matching within guards; resolution ofoperator fixity was specified in a simpler way that reflected actual practice; an edge case in the interaction of the language'slexical syntax of operators and comments was addressed, and the interaction of do-notation and if-then-else was tweaked to eliminate unexpected syntax errors.
TheLANGUAGEpragma was specified. By 2010, dozens of extensions to the language were in wide use, and GHC (among other compilers) provided theLANGUAGE pragma to specify individual extensions with a list of identifiers. Haskell 2010 compilers are required to support theHaskell2010 extension and are encouraged to support several others, which correspond to extensions added in Haskell 2010.
The next formal specification had been planned for 2020.[3] On 29 October 2021, with GHC version 9.2.1, the GHC2021 extension was released. While this is not a formal language spec, it combines several stable, widely-used GHC extensions to Haskell 2010.[39][40]
Haskell has astrong,static type system based onHindley–Milner type inference. Its principal innovation in this area is type classes, originally conceived as a principled way to addoverloading to the language,[41] but since finding many more uses.[42]
The construct that represents side effects is an example of amonad: a general framework which can model various computations such as error handling,nondeterminism,parsing andsoftware transactional memory. They are defined as ordinary datatypes, but Haskell provides somesyntactic sugar for their use.
An active, growing community exists around the language, and more than 5,400 third-party open-source libraries and tools are available in the online package repositoryHackage.[44]
moduleMain(main)where-- not needed in interpreter, is the default in a module filemain::IO()-- the compiler can infer this type definitionmain=putStrLn"Hello, World!"
Thefactorial function in Haskell, defined in a few different ways (the first line is thetype annotation, which is optional and is the same for each implementation):
factorial::(Integrala)=>a->a-- Using recursion (with the "ifthenelse" expression)factorialn=ifn<2then1elsen*factorial(n-1)-- Using recursion (with pattern matching)factorial0=1factorialn=n*factorial(n-1)-- Using recursion (with guards)factorialn|n<2=1|otherwise=n*factorial(n-1)-- Using a list and the "product" functionfactorialn=product[1..n]-- Using fold (implements "product")factorialn=foldl(*)1[1..n]-- Point-free stylefactorial=foldr(*)1.enumFromTo1
Using Haskell'sFixed-point combinator allows this function to be written without any explicit recursion.
As theInteger type hasarbitrary-precision, this code will compute values such asfactorial 100000 (a 456,574-digit number), with no loss of precision.
An implementation of an algorithm similar toquick sort over lists, where the first element is taken as the pivot:
-- Type annotation (optional, same for each implementation)quickSort::Orda=>[a]->[a]-- Using list comprehensionsquickSort[]=[]-- The empty list is already sortedquickSort(x:xs)=quickSort[a|a<-xs,a<x]-- Sort the left part of the list++[x]++-- Insert pivot between two sorted partsquickSort[a|a<-xs,a>=x]-- Sort the right part of the list-- Using filterquickSort[]=[]quickSort(x:xs)=quickSort(filter(<x)xs)++[x]++quickSort(filter(>=x)xs)
Implementations that fully or nearly comply with the Haskell 98 standard include:
TheGlasgow Haskell Compiler (GHC) compiles to native code on many different processor architectures, and toANSI C, via one of twointermediate languages:C--, or in more recent versions,LLVM (formerly Low Level Virtual Machine) bitcode.[46][47] GHC has become thede facto standard Haskell dialect.[48] There are libraries (e.g., bindings toOpenGL) that work only with GHC. GHC was also distributed with theHaskell platform. GHC features an asynchronous runtime that also schedules threads across multiple CPU cores similar tothe Go runtime.
Jhc, a Haskell compiler written by John Meacham, emphasizes speed and efficiency of generated programs and exploring new program transformations.
Ajhc is a fork of Jhc.
The Utrecht Haskell Compiler (UHC) is a Haskell implementation fromUtrecht University.[49] It supports almost all Haskell 98 features plus many experimental extensions. It is implemented usingattribute grammars and is primarily used for research on generated type systems and language extensions.
Implementations no longer actively maintained include:
The Haskell User's Gofer System (Hugs) is abytecode interpreter. It was once one of the implementations used most widely, alongside the GHC compiler,[50] but has now been mostly replaced by GHCi. It also comes with a graphics library.
HBC is an early implementation supporting Haskell 1.4. It was implemented byLennart Augustsson in, and based on,Lazy ML. It has not been actively developed for some time.
nhc98 is a bytecode compiler focusing on minimizing memory use.
The York Haskell Compiler (Yhc) was a fork of nhc98, with the goals of being simpler, more portable and efficient, and integrating support for Hat, the Haskell tracer. It also had aJavaScript backend, allowing users to run Haskell programs inweb browsers.
Implementations not fully Haskell 98 compliant, and using a variant Haskell language, include:
Gofer is an educational dialect of Haskell, with a feature calledconstructor classes, developed by Mark Jones. It is supplanted by Haskell User's Gofer System (Hugs).
Helium, a newer dialect of Haskell. The focus is on making learning easier via clearer error messages by disabling type classes as a default.
Cabal is a tool forbuilding and packaging Haskell libraries and programs.[52]
Darcs is arevision control system written in Haskell, with several innovative features, such as more precise control of patches to apply.
Glasgow Haskell Compiler (GHC) is also often a testbed for advanced functional programming features and optimizations in other programming languages.
Git-annex is a tool to manage (big) data files underGit version control. It also provides a distributed file synchronization system (git-annex assistant).
Linspire Linux chose Haskell for system tools development.[53]
Pandoc is a tool to convert one markup format into another.
GarganText[56] is a collaborative tool to map through semantic analysis texts on anyweb browser, written fully in Haskell andPureScript, which is used for instance in the research community to draw up state-of-the-art reports and roadmaps.[57]
GitHub implementedSemantic, an open-source library for analysis, diffing, and interpretation of untrusted source code, in Haskell.[61]
Standard Chartered's financial modelling language Mu is syntactic Haskell running on a strict runtime.[62]
seL4, the firstformally verifiedmicrokernel,[63] used Haskell as a prototyping language for the OS developer.[63]: p.2 At the same time, the Haskell code defined an executable specification with which to reason, for automatic translation by the theorem-proving tool.[63]: p.3 The Haskell code thus served as an intermediate prototype before finalC refinement.[63]: p.3
Target stores' supply chain optimization software is written in Haskell.[64]
Jan-Willem Maessen, in 2002, andSimon Peyton Jones, in 2003, discussed problems associated with lazy evaluation while also acknowledging the theoretical motives for it.[68][69] In addition to purely practical considerations such as improved performance,[70] they note that lazy evaluation makes it more difficult for programmers to reason about the performance of their code (particularly its space use).
Bastiaan Heeren, Daan Leijen, and Arjan van IJzendoorn in 2003 also observed some stumbling blocks for Haskell learners: "The subtle syntax and sophisticated type system of Haskell are a double edged sword—highly appreciated by experienced programmers but also a source of frustration among beginners, since the generality of Haskell often leads to cryptic error messages."[71] To address the error messages researchers from Utrecht University developed an advanced interpreter calledHelium, which improved the user-friendliness of error messages by limiting the generality of some Haskell features. In particular it disables type classes by default.[72]
Ben Lippmeier designed Disciple[73] as astrict-by-default (lazy by explicit annotation) dialect of Haskell with a type-and-effect system, to address Haskell's difficulties in reasoning about lazy evaluation and in using traditional data structures such as mutable arrays.[74] He argues (p. 20) that "destructive update furnishes the programmer with two important and powerful tools ... a set of efficient array-like data structures for managing collections of objects, and ... the ability to broadcast a new value to all parts of a program with minimal burden on the programmer."
Robert Harper, one of the authors of Standard ML, has given his reasons for not using Haskell to teach introductory programming. Among these are the difficulty of reasoning about resource use with non-strict evaluation, that lazy evaluation complicates the definition of datatypes and inductive reasoning,[75] and the "inferiority" of Haskell's (old) class system compared to ML's module system.[76]
Haskell's build tool,Cabal, has historically been criticized for poorly handling multiple versions of the same library, a problem known as "Cabal hell". The Stackage server andStack build tool were made in response to these criticisms.[77] Cabal itself has since addressed this problem by borrowing ideas fromNix,[78] with the new approach becoming the default in 2019.
Clean is a close, slightly older relative of Haskell. Its biggest deviation from Haskell is in the use ofuniqueness types instead of monads forinput/output (I/O) and side effects.
A series of languages inspired by Haskell, but with different type systems, have been developed, including:
Hume, a strict functional language forembedded systems based on processes as stateless automata over a sort of tuples of one element mailbox channels where the state is kept by feedback into the mailboxes, and a mapping description from outputs to channels as box wiring, with a Haskell-like expression language and syntax.
^abMeijer, Erik (2006). "Confessions of a Used Programming Language Salesman: Getting the Masses Hooked on Haskell".Oopsla 2007.CiteSeerX10.1.1.72.868.
^Syme, Don; Granicz, Adam; Cisternino, Antonio (2007).Expert F#.Apress. p. 2.F# also draws from Haskell particularly with regard to two advanced language features calledsequence expressions andworkflows.
^Lattner, Chris (3 June 2014)."Chris Lattner's Homepage". Chris Lattner. Retrieved3 June 2014.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.
^Wadler, P.; Blott, S. (1989). "How to make ad-hoc polymorphism less ad hoc".Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '89.ACM. pp. 60–76.doi:10.1145/75277.75283.ISBN978-0-89791-294-5.S2CID15327197.
^abcdA formal proof of functional correctness was completed in 2009.Klein, Gerwin; Elphinstone, Kevin;Heiser, Gernot; Andronick, June; Cock, David; Derrin, Philip; Elkaduwe, Dhammika; Engelhardt, Kai; Kolanski, Rafal; Norrish, Michael; Sewell, Thomas; Tuch, Harvey; Winwood, Simon (October 2009)."seL4: Formal verification of an OS kernel"(PDF).22nd ACM Symposium on Operating System Principles. Big Sky, Montana, USA.
^Jan-Willem Maessen.Eager Haskell: Resource-bounded execution yields efficient iteration. Proceedings of the 2002Association for Computing Machinery (ACM) SIGPLAN workshop on Haskell.
Learn You a Haskell for Great Good! - A community version (learnyouahaskell.github.io). An up-to-date community maintained version of the renowned "Learn You a Haskell" (LYAH) guide.
Book
Category:Family
