Haskell ( ) is a standardized, generalpurpose
purely functional programming language, with
nonstrict semantics and
strong
static typing. It
is named after
logician Haskell Curry.
History
Following the release of
Miranda by Research Software
Ltd, in 1985, interest in
lazy
functional languages grew. By 1987, more than a dozen
nonstrict,
purely
functional programming languages existed. Of these, Miranda was
the most widely used, but was not in the public domain.
At the
conference on Functional Programming Languages and Computer
Architecture (FPCA '87) in Portland, Oregon, a meeting was held during which participants
formed a strong consensus that a committee should be formed to
define an open standard for such
languages. The committee's purpose was to consolidate the
existing
functional languages
into a common one that would serve as a basis for future research
in functionallanguage design. The first version of Haskell
("Haskell 1.0") was defined in 1990. The committee's efforts
resulted in a series of language definitions. In late 1997, the
series culminated in
Haskell 98, intended to
specify a stable, minimal, portable version of the language and an
accompanying standard
library for teaching, and as a
base for future extensions. The committee expressly welcomed the
creation of extensions and variants of Haskell 98 via adding and
incorporating experimental features.
In February 1999, the Haskell 98 language standard was originally
published as "The Haskell 98 Report". In January 2003, a revised
version was published as "Haskell 98 Language and Libraries: The
Revised Report". The language continues to evolve rapidly, with the
GHC implementation
representing the current
de facto standard. In early 2006,
the process of defining a successor to the Haskell 98 standard,
informally named
Haskell′ ("Haskell Prime"), was
begun. This process is intended to produce a minor revision of
Haskell 98, which has been named Haskell 2010.
Language features
Haskell is a large, complex language, with several standardised
versions, and many nonstandard extensions. It shares many features
with imperative languages, and other functional languages, as well
as having a number of unique language features. The primary
characteristics are:
In addition, the main implementation of Haskell,
GHC, supports a number of
extensions.
Syntactic extensions
A number of syntactic extensions to Haskell 98 have been
implemented:
Type system extensions
GHC, in particular, has a significantly richer type system based on
System Fc, and supports
Parallelism and concurrency
Haskell implementations provide support for parallelism and
concurrency, via,
Haskell variants
Haskell has served as a testbed for many new ideas in language
design. There have been a wide number of Haskell variants produced,
exploring new language ideas, including:
Relatives of Haskell
Concurrent Clean is a
close relative of Haskell, whose biggest deviation from Haskell is
in the use of
uniqueness types for
input instead of
monads.
A series of languages inspired by Haskell, but with different type
systems, have been developed, including:
 Epigram, a
functional programming language with dependent types suitable for
proving properties of programs
 Agda, a functional
programming language with dependent types
Applications
Haskell is increasingly being used in commercial situations.
Audrey Tang's
Pugs
is an implementation for the longforthcoming
Perl 6 language with an interpreter and compilers
that proved useful after just a few months of its writing;
similarly, GHC is often a testbed for advanced functional
programming features and optimizations.
Darcs
is a revision control system written in Haskell, with several
innovative features.
Linspire GNU/Linux
chose Haskell for system tools development.
Xmonad is a
window
manager for the
X Window System,
written entirely in Haskell. Bluespec SystemVerilog is a language
for semiconductor design that is an extension of Haskell.
Additionally,
Bluespec, Inc.'s tools
are implemented in Haskell.
Cryptol, a
language and toolchain for developing and verifying cryptographic
algorithms, is implemented in Haskell.
Examples
Factorial
A simple example that is often used to demonstrate the syntax of
functional languages is the
factorial function for nonnegative
integers, shown in Haskell:
factorial :: Integer > Integerfactorial 0 = 1factorial n  n
> 0 = n * factorial (n1)
Or in one line:
factorial n = if n > 0 then n * factorial (n1) else 1
This describes the factorial as a recursive function, with one
terminating base case. It is similar to the descriptions of
factorials found in mathematics textbooks. Much of Haskell code is
similar to standard mathematical notation in facility and
syntax.
The first line of the factorial function describes the
type of this function; while it is optional, it is
considered to be good style to include it. It can be read as
the function factorial (
factorial)
has
type (
::)
from integer to integer
(
Integer > Integer). That is, it takes an integer as
an argument, and returns another integer. The type of a definition
is inferred automatically if the programmer didn't supply a type
annotation.
The second line relies on
pattern
matching, an important feature of Haskell. Note that parameters
of a function are not in parentheses but separated by spaces. When
the function's argument is 0 (zero) it will return the integer 1
(one). For all other cases the third line is tried. This is the
recursion, and executes the function again
until the base case is reached.
A
guard protects the third line
from negative numbers for which a factorial is undefined. Without
the guard this function would, if called with a negative number,
recurse through all negative numbers without ever reaching the base
case of 0. As it is, the pattern matching is not complete: if a
negative integer is passed to the factorial function as an
argument, the program will fail with a runtime error. A final case
could check for this error condition and print an appropriate error
message instead.
Using the
product function from the Prelude, a number of
small functions analogous to
C's
standard library, and using the Haskell
syntax for arithmetic sequences, the factorial function can be
expressed in Haskell as follows:
factorial n = product [1..n]
Here
[1..n] denotes the arithmetic sequence {{nowrap1, 2,
…, ''n''}} in list form. Using the Prelude function
enumFromTo, the expression
[1..n] can be written
as
enumFromTo 1 n, allowing the factorial function to be
expressed as
factorial n = product (enumFromTo 1 n)
which, using the
function
composition operator (expressed as a dot in Haskell) to compose
the product function with the
curried
enumeration function can be rewritten in
pointfree style:
factorial = product . enumFromTo 1
In the Hugs interpreter, you often need to define the function and
use it on the same line separated by a
where or
let..
in, meaning you need to enter this to test
the above examples and see the output
120:
let { factorial 0 = 1; factorial n  n > 0 = n * factorial (n1)
} in factorial 5
or
factorial 5 where factorial = product . enumFromTo 1
The GHCi interpreter doesn't have this restriction and function
definitions can be entered on one line and referenced later.
More complex examples
A simple
Reverse Polish
Notation calculator expressed with the
higherorder function foldl
whose argument
f is defined in a
where clause using
pattern
matching and the
type class
Read:
calc :: String > [Float]calc = foldl f [] . words
where
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 xs y = read y : xs
The empty list is the initial state, and
f interpret one word at a time, either
matching two numbers from the head of the list and pushing the
result back in, or parsing the word as a
floatingpoint number and prepending
it to the list.
The following definition produces the list of
Fibonacci numbers in linear time:
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
The infinite list is produced by
corecursion — the latter values of the list are
computed on demand starting from the initial two items 0 and 1.
This kind of a definition relies on
lazy
evaluation, an important feature of Haskell programming. For an
example of how the evaluation evolves, the following illustrates
the values of
fibs and
tail fibs after the
computation of six items and shows how
zipWith (+) has
produced four items and proceeds to produce the next item:
fibs = 0 : 1 : 1 : 2 : 3 : 5 : ...
+ + + + + +
tail fibs = 1 : 1 : 2 : 3 : 5 : ...
= = = = = =
zipWith ... = 1 : 2 : 3 : 5 : 8 : ...
fibs = 0 : 1 : 1 : 2 : 3 : 5 : 8 : ...
The same function, written using GHC's
parallel list comprehension
syntax (GHC extensions must be enabled using a special commandline
flag 'fglasgowexts'; see GHC's manual for more):
fibs = 0 : 1 : [ a+b  a < fibs="" ="" b="" <="" tail=""
]=""></>
The factorial we saw previously can be written as a sequence of
functions:
factorial n = (foldl (.) id [\x > x*k  k < [1..n]])=""
1=""></>
A remarkably concise function that returns the list of
Hamming numbers in order:
hamming = 1 : map (2*) hamming `merge` map (3*) hamming `merge` map
(5*) hamming
where merge (x:xs) (y:ys)
 x y = x : xs `merge` (y:ys)
 x > y = y : (x:xs) `merge` ys
 otherwise = x : xs `merge` ys
Like the various
fibs
solutions displayed above, this
uses corecursion to produce a list of numbers on demand,starting
from the base case of 1 and building new items based on the
preceding part of the list.
In this case the producer
merge
is defined in a
where
clause and used as an operator by enclosing it
in backquotes.
The branches of the guards define how
merge
merges two
ascending lists into one ascending list without duplicate
items.
Monads and input/output
As Haskell is a pure functional language, functions cannot have
side effects. Being nonstrict, it also does not have a
welldefined evaluation order. This is a challenge for real
programs, which among other things need to interact with an
environment. Haskell solves this with
monadic types that
leverages the type system to ensure the proper sequencing of
imperative constructs. The typical example is I/O, but monads are
useful for many other purposes, including mutable state,
concurrency and transactional memory, exception handling, and error
propagation.
Haskell provides a special syntax for monadic expressions, so that
sideeffecting programs can be written in a style similar to
current imperative programming languages; no knowledge of the
mathematics behind monadic
I/O is required for this. The following program reads a name
from the command line and outputs a greeting message:
main = do putStrLn "What's your name?"
name < getLine=""></>
putStr ("Hello, " ++ name ++ "!\n")
The donotation eases working with monads. This doexpression is
equivalent to, but (arguably) easier to write and understand than,
the
desugared version employing the
monadic operators directly:
main = putStrLn "What's your name?" >>
getLine >>= \ name >
putStr ("Hello, " ++ name ++ "!\n")
 See also wikibooks:Transwiki:List
of hello world programs#Haskell for another example that prints
text.
Criticism
JanWillem Maessen, in 2002, and
Simon Peyton Jones, in 2003, discussed
problems associated with lazy evaluation while also acknowledging
the theoretical motivation for it, in addition to purely practical
considerations such as improved performance. They note that, in
addition to adding some performance overhead, laziness makes it
more difficult for programmers to reason about the performance of
their code (specifically with regard to memory usage).
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." To address these,
they developed an advanced interpreter called
Helium which improved the userfriendliness
of error messages by limiting the generality of some Haskell
features, and in particular removing support for type
classes.
Implementations
The following all comply fully, or very nearly, with the Haskell 98
standard, and are distributed under
open
source licenses. There are currently no proprietary Haskell
implementations.
 The Glasgow Haskell
Compiler (GHC) compiles to native code on a number of
different architectures—as well as to ANSI
C—using C as an intermediate language. GHC is probably
the most popular Haskell compiler, and there are quite a few useful
libraries (e.g. bindings to OpenGL) that will
work only with GHC.
 Gofer was an
educational dialect of Haskell, with a feature called "constructor
classes", developed by Mark Jones. It was supplanted by Hugs (see
below).
 HBC is another nativecode Haskell compiler.
It has not been actively developed for some time but is still
usable.
 Helium is a
newer dialect of Haskell. The focus is on making it easy to learn
by providing clearer error messages. It currently lacks full
support for type classes, rendering it incompatible with many
Haskell programs.
 The Utrecht Haskell Compiler (UHC) is a Haskell
implementation from Utrecht
University. UHC supports almost all Haskell 98 features plus
many experimental extensions. It is implemented using attribute grammars and is currently mainly
used for research into generated type systems and language
extensions.
 Hugs, the Haskell
User's Gofer System, is a bytecode
interpreter. It offers fast compilation of programs and reasonable
execution speed. It also comes with a simple graphics library. Hugs
is good for people learning the basics of Haskell, but is by no
means a "toy" implementation. It is the most portable and
lightweight of the Haskell implementations.
 Jhc is a Haskell compiler written by John Meacham emphasising speed and efficiency
of generated programs as well as exploration of new program
transformations. LHC, is a
recent fork of Jhc.
 nhc98 is another bytecode compiler, but the
bytecode runs significantly faster than with Hugs. Nhc98 focuses on
minimizing memory usage, and is a particularly good choice for
older, slower machines.
 Yhc, the York
Haskell Compiler is a fork of nhc98, with the goals of
being simpler, more portable and more efficient, and integrating
support for Hat, the Haskell tracer. It also features a JavaScript backend allowing users to run Haskell programs in a web browser.
Haskell conferences and workshops
The Haskell community meets regularly for research and development
activities. The primary events are:
Since 2007 there has been a series of organized "hackathons"  the
Hac series  aimed at improving the programming
language tools and libraries:
 Oxford, UK, 2007
 Freiburg, Germany, 2007
 Gothenburg, Sweden, 2008
 Utrecht, The Netherlands, 2009
 Philadelphia, USA, 2009
 Edinburgh, UK, 2009
Since 2005, a growing number of
Haskell User Groups has been formed, in the USA,
Canada, Australia, South America, Europe and Asia.
Libraries
Since January 2007, libraries and applications written in Haskell
have been collected on "
Hackage", an online database of open source
Haskell software using
Cabal
packaging tool. By October 2009 there were some
1600 packages available.
Hackage provides a central point for the distribution of Haskell
software, via Cabal, and has become a hub for new Haskell
development activity. Installing new Haskell software via Hackage
is possible via the cabalinstall tool:
$ cabal install xmonad
which recursively installs required dependencies if they are
available on Hackage. This makes installation of Haskell code
easier than had been possible previously.
The Haskell Platform
To cope with the growing number of libraries, the
Haskell
Platform was launched in September 2008 to provide a standard,
qualityassured suite of Haskell libraries, available on every
machine. The library standardisation project is modelled on GNOME's
release process.
The first release of the Haskell Platform was in May 2009.
Related projects
 Leksah [1712] —
an IDE developed in Haskell, mainly for Haskell. Integrates
sourcebrowsing/intellisense, debugging and package building.
 O'Haskell — an extension of Haskell
adding objectorientation and concurrent programming support.
 Pugs — a compiler and interpreter for the
Perl 6 programming language
 LOLITA and Darcs —
large applications written in Haskell
 Xmonad — a window manager written in
Haskell (under 1200 lines)
 Jaskell [1713] — a
functional scripting programming language that runs in Java VM
 Curry — a language
based on Haskell
 House — an operating
system written using Haskell
 WinHugs [1714] — Haskell interpreter for Windows
References

http://www.haskell.org/pipermail/haskellcafe/2008January/038756.html

http://www.haskell.org/pipermail/haskellcafe/2008January/038758.html
 Simon Marlow, Tue Nov 24 05:50:49 EST 2009: "[Haskell]
Announcing Haskell 2010"
 See Industrial Haskell Group for collaborative
development, Commercial Users of Functional Programming for
specific projects and Haskell in industry for a list of companies using
Haskell commercially
 HaskellWiki: Type signatures as good style
 HaskellWiki: Pointfree
 JanWillem Maessen. Eager Haskell: Resourcebounded
execution yields efficient iteration. Proceedings of the 2002
ACM SIGPLAN workshop on
Haskell.
 Simon Peyton Jones. Wearing the hair shirt: a retrospective on
Haskell. Invited talk at POPL 2003.
 Lazy evaluation can lead to excellent performance, such as in
The Computer Language Benchmarks Game[1]
 Bastiaan Heeren, Daan Leijen, Arjan van IJzendoorn. Helium, for learning Haskell. Proceedings of
the 2003 ACM SIGPLAN workshop on Haskell.
External links
Tutorials