Haskell

Haskell logo

Haskell is a standardized purely functional programming language with non-strict semantics, named after the logician Haskell Curry. It was created by a committee formed in the 1987 for the express purpose of defining such a language. The latest semi-official language standard is Haskell 98, intended to specify a minimal, portable version of the language for teaching and as a base for future extensions. The language continues to evolve rapidly, with Hugs and GHC (see below) representing the current de facto standard.

Characterizing syntax features in Haskell include pattern matching, currying, list comprehensions, guard statements, and definable operators. The language also supports recursive functions and datatypes. Unique concepts include monads, and type classes. 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.

Although Haskell has a comparetively small user community, its strengths have been well applied to a few projects. Autrijus Tang's Pugs is an interpreter and compiler for the Perl 6 language, completed in a few months. DARCS is a revision control system, with several innovative features.

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.

Examples

The "Hello World" of functional languages is the factorial function. Expressed as pure Haskell:

 fac 0 = 1
 fac n = n * fac (n-1)

This is similar to how a math textbook defines factorials, as is much Haskell dealing with math. Notably, parameters of a function are not in parentheses but simply separated by spaces.

The "Prelude" is a number of small functions analogous to C's standard library. Using the prelude and writing in the "point free" (insert classic Haskell joke here) style of unspecified arguments, it becomes:

fac = product . enumFromTo 1

The '.' in the above is the '.' from Lambda calculus, a core part of functional programming. Note also that the '=' is the '=' of $f(x)=x^{2}$.

A simple RPN calculator:

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 :: Float):xs

A function which returns a stream of the Fibonacci numbers in linear time:

fibs@(_:rest) = 0 : 1 : (zipWith (+) fibs rest)

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
              | x<y  = x : xs#yys
              | x>y  = y : xxs#ys

Implementations

The following all comply fully, or very nearly, with the Haskell 98 standard, and are distributed under open source licences. There are currently no commercial Haskell implementations.

• Hugs ([1]) 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.
• Glasgow Haskell Compiler ([2]). The Glasgow Haskell Compiler compiles to native code on a number of different architectures, and can also compile to C. GHC is probably the most popular Haskell compiler, and there are quite a few useful libraries (e.g. bindings to OpenGL) that will only work with GHC.
• nhc98 ([3]) is another bytecode compiler, but the bytecode runs significantly faster than with Hugs. Nhc98 focuses on minimising memory usage, and is a particularly good choice for older, slower machines.
• Gofer An educational version of Haskell, Gopher was developed by Mark Jones. It was supplanted by HUGS.
• HBC ([4]) is another native-code Haskell compiler. It hasn't been actively developed for some time, but is still usable.
• Helium ([5]) is a newer dialect of Haskell. The focus is on making it easy to learn. It currently lacks typeclasses, making it incompatible with many Haskell programs.

Extensions

• O'Haskell is an extension of Haskell adding object-orientation and concurrent programming support.

External links

• The Haskell Home Page
• The Haskell Wiki
• A Gentle Introduction to Haskell 98 (pdf format)
• Haskell vs. Ada vs. C++ vs. Awk vs. ... An Experiment in Software Prototyping Productivity
• The Evolution of a Haskell Programmer - a slightly humorous overview of different programming styles available in Haskell
• An Online Bibliography of Haskell Research
• Haskell Humor
• Wearing the hair shirt: a retrospective on Haskell. Simon Peyton Jones, invited talk at POPL 2003.