##### Views

(Difference between revisions)
+
- collects all kinds of extensions proposed for the language, libraries and specific implementations. +
[[:Category:Proposals|Proposals]] +
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 [http://www.haskell.org/haskellwiki/Category:Proposals 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.) +
+ +
+ [http://www.haskell.org/mailman/listinfo/libraries The libraries mailing list] + +
Discusses, amongst others, extensions to libraries. +
+ +
This old hawiki page contains all kinds of extensions proposed for the language, libraries and specific implementations, before the new wiki came online.
+
Line 38: Line 45: Below we present some of the various extensions that have Below we present some of the various extensions that have been implemented or proposed. been implemented or proposed. - See also the [[Haskell mailing lists]]. + See also the Haskell [[mailing lists]].
• Views allow multiple logical' constructors to match
• Views allow multiple logical' constructors to match - against real constructors in patterns. A [http://haskell.org/views.html views proposal] has been submitted for consideration in + against real constructors in patterns. - future Haskell reports. Implemented in hbc (?). +
+
• A [http://www.haskell.org/development/views.html views proposal] has been submitted for consideration in + future Haskell reports. Implemented in hbc (?)
• +
• [[Dependent type]]s provide a way for not-forgetful views: views who cannot lie. +
• Pattern Guards by Simon Peyton-Jones is a proposal
• Pattern Guards by Simon Peyton-Jones is a proposal to generalize guards used in function definitions. See the to generalize guards used in function definitions. See the [http://research.microsoft.com/Users/simonpj/Haskell/guards.html proposal] for [http://research.microsoft.com/Users/simonpj/Haskell/guards.html proposal] for further details. Implemented in GHC, proposed for Haskell 2. further details. Implemented in GHC, proposed for Haskell 2. -
• [ftp://ftp.botik.ru/pub/local/Mechveliani/basAlgPropos/ Basic algebra proposal.] In particular: Reformulating numeric classes, +
• [[Mathematical prelude discussion#Basic Algebra Library (BAL)|Basic algebra proposal.]] In particular: Reformulating numeric classes, instance ruled type and domain conversion. instance ruled type and domain conversion.
• Mark Shields and Simon Peyton Jones: [http://research.microsoft.com/Users/simonpj/Papers/first-class-modules/ First-class Modules for Haskell] discusses a lot of extension proposals integrated in a coherent design. See also [[First-class module]] page. +
• [[Extensible record]] page: problems where extensible records are useful, proposals, implementations etc. +
• 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.
Line 62: Line 77: The user can impose conditions on overloaded identifiers via CHRs. The user can impose conditions on overloaded identifiers via CHRs. -
[http://www.cse.ogi.edu/~mpj/goferarc/index.html Gofer] +
[http://web.cecs.pdx.edu/~mpj/goferarc/index.html Gofer]
Gofer is a small interpreter by Mark Jones supporting a language based on the Haskell report version 1.2. Gofer is a small interpreter by Mark Jones supporting a language based on the Haskell report version 1.2. Line 86: Line 101: hbc. hbc. -
[http://www.score.is.tsukuba.ac.jp/~chak/goffin/ Goffin]
+
[http://www.cse.unsw.edu.au/~chak/papers/ Goffin]
A Haskell extension for parallel and distributed A Haskell extension for parallel and distributed - programming. + programming. Browse [http://www.cse.unsw.edu.au/~chak/ Manuel M T Chakravarty's] page for newer work on parallel extensions to GHC. - + - + -
[http://www.mondrian-script.org/ Mondrian]
+ - + - Mondrian is evolving from "just" an internet scripting language to a "functional language for OO environments". Mondrian is a non-strict + - functional language with threads, exceptions and interlanguage + - working - a Haskell "light" with extras. + - +
[http://www.cs.chalmers.se/~patrikj/poly/polyp/ PolyP - a polytypic programming language]
[http://www.cs.chalmers.se/~patrikj/poly/polyp/ PolyP - a polytypic programming language]
Line 109: Line 116: derivative of Hugs 1.3b. derivative of Hugs 1.3b. -
[http://www.mathematik.uni-marburg.de/inf/eden Eden]
Eden +
[http://www.mathematik.uni-marburg.de/~eden/ Eden]
Eden is a parallel functional language that provides a new perspective on is a parallel functional language that provides a new perspective on parallel programming. It gives programmers enough control to implement parallel programming. It gives programmers enough control to implement Line 133: Line 140: fields. fields. -
Template Haskell is an extension to Haskell 98 that allows you to do
Template Haskell is an extension to Haskell 98 that allows you to do type-safe compile-time meta-programming, with Haskell both as the type-safe compile-time meta-programming, with Haskell both as the manipulating language and the language being manipulated. manipulating language and the language being manipulated. -
Dependent types
+
[http://disciple.ouroborus.net Disciple] +
+ 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. + +
[[Dependent types]]
- [http://www.e-pig.org/ Epigram] is a full dependently typed programming language (see [http://www.e-pig.org/downloads/epigram-notes.pdf Epigram Tutorial] by Conor McBride and [http://www.e-pig.org/downloads/ydtm.pdf Why dependent types matter] by Thorsten Altenkirch, Conor McBride and James McKinna). Dependent types (of this language) also provide a powerful generalization of '''views''' (already mentioned here in the Haskell Future Page). + * concept of dependent types, its usefulness in the world of programming; + * dependently typed languages, possiblity of not-forgetful views; + * simulating dependent types in Haskell, and extending Haskell to have them. - John Hughes: [http://www.coverproject.org/TalksUntilSpring2004/DependentTypesInHaskell.pdf Dependent Types in Haskell (some ideas)]. - To see how Illative Combinatory Logic deals with dependent types, see combinator '''G''' described in [http://citeseer.ist.psu.edu/246934.html Systems of Illative Combinatory Logic complete for first-order propositional and predicate calculus] by Henk Barendregt, Martin Bunder, Wil Dekkers. - It seems to me that the dependent type construct - $\forall x : S \Rightarrow T$ - of Epigram corresponds to - $\mathbf G\;S\;(\lambda x . T)$ - in Illative Combinatory Logic. E.g. the followings should correspond to each other: - * $\mathrm{realNullvector} :\;\;\;\forall n: \mathrm{Nat} \Rightarrow \mathrm{RealVector}\;n$ - * $\mathbf G\;\,\mathrm{Nat}\;\,\mathrm{RealVector}\;\,\mathrm{realNullvector}$ -
[[Category:Proposals| ]] [[Category:Proposals| ]] + [[Category:Language| ]]

## 1 Haskell' is the next official version

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).

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.

Proposals

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.)

</DD>

The libraries mailing list
Discusses, amongst others, extensions to libraries. </DD>

HaskellTwo on the old wiki (in the web archive)
This old hawiki page contains all kinds of extensions proposed for the language, libraries and specific implementations, before the new wiki came online.</DD>

Below we present some of the various extensions that have been implemented or proposed. See also the Haskell mailing lists.

• Views allow multiple `logical' constructors to match against real constructors in patterns.
• A views proposal has been submitted for consideration in future Haskell reports. Implemented in hbc (?)
• Dependent types provide a way for not-forgetful views: views who cannot lie.
• Pattern Guards by Simon Peyton-Jones is a proposal to generalize guards used in function definitions. See the proposal for further details. Implemented in GHC, proposed for Haskell 2.
• Basic algebra proposal. In particular: Reformulating numeric classes, instance ruled type and domain conversion.
• Haskell Proposal: Syntactic Sugar for Arrows
• Mark Shields and Simon Peyton Jones: First-class Modules for Haskell discusses a lot of extension proposals integrated in a coherent design. See also First-class module page.
• Extensible record page: problems where extensible records are useful, proposals, implementations etc.
• 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.

Chameleon
Chameleon is a Haskell-style language which provides a flexible overloading mechanism based on Constraint Handling Rules (CHRs). The user can impose conditions on overloaded identifiers via CHRs.

Gofer
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.

Goffin
A Haskell extension for parallel and distributed programming. Browse Manuel M T Chakravarty's page for newer work on parallel extensions to GHC.

PolyP - a polytypic programming language
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
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.

Curry
Curry combines in a seamless way features from functional programming (nested expressions, higher-order functions, lazy evaluation), logic programming (logical variables, partial data structures, built-in search), and concurrent programming (concurrent evaluation of expressions with synchronization on logical variables). Many Haskell programs are also valid Curry programs.

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.

Template Haskell is an extension to Haskell 98 that allows you to do type-safe compile-time meta-programming, with Haskell both as the manipulating language and the language being manipulated.

Disciple
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.

Dependent types

• concept of dependent types, its usefulness in the world of programming;
• dependently typed languages, possiblity of not-forgetful views;
• simulating dependent types in Haskell, and extending Haskell to have them.