Latest revision as of 18:09, 25 December 2012

The Haskell 2010 report was published in July 2010, and is the current definition of the Haskell language. Compilers will also continue to support the previous version of Haskell, Haskell 98 (via a special flag).

A new standard will be defined each year. All
information about this is on

The language evolves and numerous extensions have been proposed and many of them have been implemented in some Haskell systems; for example
pattern guards (which is adopted in the Haskell 2010 standard), scoped type variables, multi-parameter type classes, local universal and existential quantification.
The Haskell mailing lists
are a forum for discussing new language features.
People proposing an additional language feature should implement the new feature or convince the developers of one of the Haskell systems to do so.
Then many people can test the practical usefulness of the extension.
Finally, the people seriously interested in the new feature should define the new feature with respect to the current Haskell standard in a document (a new mailing list can be set up for this purpose). This kind of addendum to the Haskell report clarifies the details and can be used for adding the feature to other Haskell systems. The definition of the foreign function interface (FFI) for Haskell is a good example for this process.

On a rather longer time schedule, a committee led by John Launchbury
may develop Haskell II. Obviously well-tested and well-described extension
proposals will have a higher chance of being adopted.

Collects all kinds of extensions proposed for the language, libraries and specific implementations. Note that the above page is automatically generated, so to add a new proposal you can instead type the title for your page into the address bar of your browser using underscores instead of spaces, then the wiki generates a new page (assuming there is not already a page with the same title) that you can edit. If you put

[[Category:Proposals]]

at the top of your page, it will be automatically linked to by the Proposals page above. (Sometimes the convention of ending the title of a proposal with the word proposal is followed, so that people browsing the wiki can clearly see that the page describes something different that is not yet part of the current Haskell language.)

An Accessible layout proposal which would allow you to make more use of the layout rule to eliminate many commas and parentheses (particularly interesting if you don't like manually deleting then re-inserting that comma that always ends up in the wrong place when you are re-ordering a list of things by cut and paste).

A Class system extension proposal page, to collect ideas for making the class system more powerful, some of which have been implemented in other languages similar to Haskell.

Gofer is a small interpreter by Mark Jones supporting a language based on the Haskell report version 1.2.
Gofer is intended as an experimental language, particularly where type classes
are involved. Although Haskell has adopted a number of ideas from Gofer, the Gofer type class system is still more flexible than the Haskell one.
Available for all Unix platforms including Linux, DOS, and Macs.
Hugs is the successor to Gofer and Gofer is no longer supported.Html-version of the Gofer manual

is an extension of Haskell for parallel programming. It
adds just two new primitives to the language, namely, a form of
parallel composition par, and sequential composition seq. With
judicious use of par and seq it is possible to express how a program
should be evaluated in parallel.

The pH language is is a parallel, eagerly-evaluated variant of Haskell with syntactic provisions for
loops, barriers, and I- and M- structure storage. The eager evaluation model of pH is similar to
that of Id; the current version of the pH compiler shares a back end with the Id compiler, producing
code for the Monsoon dataflow machine. The front end of the pH compiler is a modification of
hbc.

PolyP extends a functional language (a subset of Haskell) with a construct for writing polytypic functions. A polytypic function is a function that is defined by induction on the structure of user-defined datatypes.

O'Haskell is an object-oriented extension to Haskell developed at
Chalmers. O'Haskell conservatively adds two major features to the
Haskell core: a monad of concurrent, state-encapsulating reactive
objects, and a type system with subtyping between records as well
as datatypes. An implementation is available, O'Hugs, which is a
derivative of Hugs 1.3b.

Eden
is a parallel functional language that provides a new perspective on
parallel programming. It gives programmers enough control to implement
their parallel algorithms efficiently (including granularity issues)
and at the same time frees them from the low level details of process
management. Eden is explicit about processes and their incoming and
outgoing data, but abstracts from the transfer of these data between
processes and the necessary synchronisation.
Eden extends the Haskell but overrules lazy evaluation whenever it is
necessary to support parallelism.

Data Field Haskell implements an instance of Data Fields, a generalization
of arrays. The purpose is to support generic array- and data parallel
programming on a very high level, for rapid prototyping of parallel
algorithms. The most important language extension to Haskell is the
forall-construct, which allows convenient definitions of data
fields.

Disciple is a dialect of Haskell that uses strict evaluation as the default and supports destructive update of arbitrary data structures. Disciple includes region, effect and closure typing, and this extra information provides a handle on the operational behaviour of code that isn't available in other languages. Programs can be written in either a pure/functional or effecful/imperative style, and one of our goals is to provide both styles coherently in the same language.