Haskell programming language

Interesting Haskell features include support for recursive functions and datatypes, pattern matching, list comprehensions and guard statements.
The combination of such features can make functions which would be difficult to write in a procedural programming language almost trivial to implement in Haskell.
The language is, as of 2002, the functional language on which the most research is being performed. Several variants have been developed: parallelizable versions from MIT and Glasgow, both called Parallel Haskell, more parallel and distributed versions called Distributed Haskell (formerly Goffin) and Eden, a speculatively evaluating version called Eager Haskell and several object oriented versions: Haskell++, O'Haskell and Mondrian.

There is also a Haskell-like language that offers a new method of support for GUI development called Concurrent Clean. Its biggest deviation from Haskell is in the use of uniqueness types for input as opposed to monads.

An educational version of Haskell called Gofer was developed by Mark Jones.
It was supplanted by HUGS, the Haskell User's Gofer System (see the implementations section of this article).

For more comprehensive information, see the haskell.org website, linked at the end of this article.

Examples

fac 0 = 1 fac n = n * fac (n - 1) The cute definition of the factorial function (using a built-in Haskell list notation and the standard product function):

fac n = product [1..n] A naïve implementation of a function which returns the nth number in the Fibonacci sequence:

fib 0 = 0 fib 1 = 1 fib n = fib (n - 2) + fib (n - 1) A function which returns a list of the Fibonacci numbers in linear time:

fibs@(_:rest) = 0 : 1 : (zipWith (+) fibs rest) The previous function creates an infinite list, which is possible because of lazy evaluation.
One could implement fib as:

fib n = fibs !! n (!! is an operator which gets the nth element of a list).

The Quicksort algorithm can be elegantly expressed in Haskell with the help of list comprehensions:

qsort [] = [] qsort (pivot:tail) = qsort left ++ [pivot] ++ qsort right where left = [y | y <- tail, y < pivot] right = [y | y <- tail, y >= pivot] (Note that because of excessive copying and concatenation of lists this code can be rather slow, depending on the implementation.)

A remarkably concise function that returns the list of Hamming numbers in order:

hamming = 1 : map (*2) hamming # map (*3) hamming # map (*5) hamming where xxs@(x:xs) # yys@(y:ys) | x==y = x : xs#ys | xy = y : xxs#ys

Implementations