https://wiki.haskell.org/api.php?action=feedcontributions&user=Oubiwann&feedformat=atomHaskellWiki - User contributions [en]2022-05-19T22:56:35ZUser contributionsMediaWiki 1.31.7https://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=64079Haskell Lisp2021-03-23T16:55:21Z<p>Oubiwann: /* Lisps in Haskell */ Updated links, notes about maintained state, etc.</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these)<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/carp-lang/Carp Carp] - Carp is a statically typed Lisp designed to work well for for real-time, interactive applications and performance-sensitive use cases like games, sound synthesis and visualizations.<br />
* [https://lexi-lambda.github.io/hackett/ Hackett] - Hackett is an attempt to implement a Haskell-like language with support for Racketâ€™s macro system, built using the techniques described in the paper [http://www.ccs.neu.edu/home/stchang/pubs/ckg-popl2017.pdf Type Systems as Macros]. It is currently extremely work-in-progress. [https://github.com/lexi-lambda/hackett Github project]<br />
* [https://github.com/justinethier/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://axellang.github.io/ Axel] - Haskell's semantics, plus Lisp's macros; a purely functional, extensible, and powerful programming language. [https://github.com/axellang/axel Github project].<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
* AST-Related<br />
** [[Template Haskell]]<br />
** [https://hackage.haskell.org/package/haskell-src-exts haskell-src-exts]<br />
* [[Applications and libraries/Compiler tools]]<br />
** [[GHC API]]<br />
** [https://github.com/mvdan/hint hint] (Runtime Haskell Interpreter)<br />
** [https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/HscMain HscMain (commentary)]<br />
* Interpreters<br />
** [http://okmij.org/ftp/Computation/free-monad.html Free and Freer Monads: Putting Monads Back into Closet]<br />
** [http://dlaing.org/cofun/posts/free_and_cofree.html Free for DSLs, cofree for interpreters]<br />
** [https://wiki.haskell.org/wikiupload/c/c6/ICMI45-paper-en.pdf How to Build a Monadic Interpreter in One Day]<br />
* S-Expressions<br />
** [https://github.com/aisamanra/s-cargot s-cargot]<br />
** [https://hackage.haskell.org/package/atto-lisp atto-lisp]<br />
** [http://oubiwann.blogspot.com/2014/01/prefix-operators-in-haskell.html Prefix operators in Haskell]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=64078Haskell Lisp2021-03-23T16:29:51Z<p>Oubiwann: /* Lisps in Haskell */ Added links to Hackett</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these)<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/carp-lang/Carp Carp] - Carp is a statically typed Lisp designed to work well for for real-time, interactive applications and performance-sensitive use cases like games, sound synthesis and visualizations.<br />
* [https://lexi-lambda.github.io/hackett/ Hackett] - Hackett is an attempt to implement a Haskell-like language with support for Racketâ€™s macro system, built using the techniques described in the paper [http://www.ccs.neu.edu/home/stchang/pubs/ckg-popl2017.pdf Type Systems as Macros]. It is currently extremely work-in-progress. [https://github.com/lexi-lambda/hackett Github project]<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://axellang.github.io/ Axel] - Haskell's semantics, plus Lisp's macros; a purely functional, extensible, and powerful programming language. [https://github.com/axellang/axel Github project].<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
* AST-Related<br />
** [[Template Haskell]]<br />
** [https://hackage.haskell.org/package/haskell-src-exts haskell-src-exts]<br />
* [[Applications and libraries/Compiler tools]]<br />
** [[GHC API]]<br />
** [https://github.com/mvdan/hint hint] (Runtime Haskell Interpreter)<br />
** [https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/HscMain HscMain (commentary)]<br />
* Interpreters<br />
** [http://okmij.org/ftp/Computation/free-monad.html Free and Freer Monads: Putting Monads Back into Closet]<br />
** [http://dlaing.org/cofun/posts/free_and_cofree.html Free for DSLs, cofree for interpreters]<br />
** [https://wiki.haskell.org/wikiupload/c/c6/ICMI45-paper-en.pdf How to Build a Monadic Interpreter in One Day]<br />
* S-Expressions<br />
** [https://github.com/aisamanra/s-cargot s-cargot]<br />
** [https://hackage.haskell.org/package/atto-lisp atto-lisp]<br />
** [http://oubiwann.blogspot.com/2014/01/prefix-operators-in-haskell.html Prefix operators in Haskell]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=64077Haskell Lisp2021-03-23T16:19:43Z<p>Oubiwann: Added link for Axel</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these)<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/carp-lang/Carp Carp] - Carp is a statically typed Lisp designed to work well for for real-time, interactive applications and performance-sensitive use cases like games, sound synthesis and visualizations.<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://axellang.github.io/ Axel] - Haskell's semantics, plus Lisp's macros; a purely functional, extensible, and powerful programming language. [https://github.com/axellang/axel Github project].<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
* AST-Related<br />
** [[Template Haskell]]<br />
** [https://hackage.haskell.org/package/haskell-src-exts haskell-src-exts]<br />
* [[Applications and libraries/Compiler tools]]<br />
** [[GHC API]]<br />
** [https://github.com/mvdan/hint hint] (Runtime Haskell Interpreter)<br />
** [https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/HscMain HscMain (commentary)]<br />
* Interpreters<br />
** [http://okmij.org/ftp/Computation/free-monad.html Free and Freer Monads: Putting Monads Back into Closet]<br />
** [http://dlaing.org/cofun/posts/free_and_cofree.html Free for DSLs, cofree for interpreters]<br />
** [https://wiki.haskell.org/wikiupload/c/c6/ICMI45-paper-en.pdf How to Build a Monadic Interpreter in One Day]<br />
* S-Expressions<br />
** [https://github.com/aisamanra/s-cargot s-cargot]<br />
** [https://hackage.haskell.org/package/atto-lisp atto-lisp]<br />
** [http://oubiwann.blogspot.com/2014/01/prefix-operators-in-haskell.html Prefix operators in Haskell]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=63979Haskell Lisp2021-02-16T21:21:50Z<p>Oubiwann: Added Carp</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these)<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/carp-lang/Carp Carp] - Carp is a statically typed Lisp designed to work well for for real-time, interactive applications and performance-sensitive use cases like games, sound synthesis and visualizations.<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
* AST-Related<br />
** [[Template Haskell]]<br />
** [https://hackage.haskell.org/package/haskell-src-exts haskell-src-exts]<br />
* [[Applications and libraries/Compiler tools]]<br />
** [[GHC API]]<br />
** [https://github.com/mvdan/hint hint] (Runtime Haskell Interpreter)<br />
** [https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/HscMain HscMain (commentary)]<br />
* Interpreters<br />
** [http://okmij.org/ftp/Computation/free-monad.html Free and Freer Monads: Putting Monads Back into Closet]<br />
** [http://dlaing.org/cofun/posts/free_and_cofree.html Free for DSLs, cofree for interpreters]<br />
** [https://wiki.haskell.org/wikiupload/c/c6/ICMI45-paper-en.pdf How to Build a Monadic Interpreter in One Day]<br />
* S-Expressions<br />
** [https://github.com/aisamanra/s-cargot s-cargot]<br />
** [https://hackage.haskell.org/package/atto-lisp atto-lisp]<br />
** [http://oubiwann.blogspot.com/2014/01/prefix-operators-in-haskell.html Prefix operators in Haskell]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=61270Haskell Lisp2016-11-06T03:36:07Z<p>Oubiwann: /* Background */ Removed hanging "and" at end of bullet</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these)<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
* AST-Related<br />
** [[Template Haskell]]<br />
** [https://hackage.haskell.org/package/haskell-src-exts haskell-src-exts]<br />
* [[Applications and libraries/Compiler tools]]<br />
** [[GHC API]]<br />
** [https://github.com/mvdan/hint hint] (Runtime Haskell Interpreter)<br />
** [https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/HscMain HscMain (commentary)]<br />
* Interpreters<br />
** [http://okmij.org/ftp/Computation/free-monad.html Free and Freer Monads: Putting Monads Back into Closet]<br />
** [http://dlaing.org/cofun/posts/free_and_cofree.html Free for DSLs, cofree for interpreters]<br />
** [https://wiki.haskell.org/wikiupload/c/c6/ICMI45-paper-en.pdf How to Build a Monadic Interpreter in One Day]<br />
* S-Expressions<br />
** [https://github.com/aisamanra/s-cargot s-cargot]<br />
** [https://hackage.haskell.org/package/atto-lisp atto-lisp]<br />
** [http://oubiwann.blogspot.com/2014/01/prefix-operators-in-haskell.html Prefix operators in Haskell]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60904Haskell Lisp2016-07-13T23:50:29Z<p>Oubiwann: /* A Haskell-Lisp Toolbox */ Added interpreter section</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
* AST-Related<br />
** [[Template Haskell]]<br />
** [https://hackage.haskell.org/package/haskell-src-exts haskell-src-exts]<br />
* [[Applications and libraries/Compiler tools]]<br />
** [[GHC API]]<br />
** [https://github.com/mvdan/hint hint] (Runtime Haskell Interpreter)<br />
** [https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/HscMain HscMain (commentary)]<br />
* Interpreters<br />
** [http://okmij.org/ftp/Computation/free-monad.html Free and Freer Monads: Putting Monads Back into Closet]<br />
** [http://dlaing.org/cofun/posts/free_and_cofree.html Free for DSLs, cofree for interpreters]<br />
** [https://wiki.haskell.org/wikiupload/c/c6/ICMI45-paper-en.pdf How to Build a Monadic Interpreter in One Day]<br />
* S-Expressions<br />
** [https://github.com/aisamanra/s-cargot s-cargot]<br />
** [https://hackage.haskell.org/package/atto-lisp atto-lisp]<br />
** [http://oubiwann.blogspot.com/2014/01/prefix-operators-in-haskell.html Prefix operators in Haskell]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60903Haskell Lisp2016-07-13T23:01:19Z<p>Oubiwann: /* A Haskell-Lisp Toolbox */ Added hint project and re-org'ed links</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
* AST-Related<br />
** [[Template Haskell]]<br />
** [https://hackage.haskell.org/package/haskell-src-exts haskell-src-exts]<br />
* [[Applications and libraries/Compiler tools]]<br />
** [[GHC API]]<br />
** [https://github.com/mvdan/hint hint] (Runtime Haskell Interpreter)<br />
** [https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/HscMain HscMain (commentary)]<br />
* S-Expressions<br />
** [https://github.com/aisamanra/s-cargot s-cargot]<br />
** [https://hackage.haskell.org/package/atto-lisp atto-lisp]<br />
** [http://oubiwann.blogspot.com/2014/01/prefix-operators-in-haskell.html Prefix operators in Haskell]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60902Haskell Lisp2016-07-13T17:48:06Z<p>Oubiwann: /* A Haskell-Lisp Toolbox */ Added a list of links</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
* [[Template Haskell]]<br />
* [https://hackage.haskell.org/package/haskell-src-exts haskell-src-exts]<br />
* [[GHC API]] and other [[Applications and libraries/Compiler tools]]<br />
* [https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/HscMain HscMain (commentary)]<br />
* [https://github.com/aisamanra/s-cargot s-cargot]<br />
* [https://hackage.haskell.org/package/atto-lisp atto-lisp]<br />
* [http://oubiwann.blogspot.com/2014/01/prefix-operators-in-haskell.html Prefix operators in Haskell]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60901Haskell Lisp2016-07-13T17:29:24Z<p>Oubiwann: Added section for tools/libs/etc</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
= A Haskell-Lisp Toolbox =<br />
<br />
TBD</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60900Haskell Lisp2016-07-13T13:15:23Z<p>Oubiwann: /* Lisps in Haskell */ Time has passed ... no longer "recently" :-)</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006, updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60899Haskell Lisp2016-07-13T13:13:28Z<p>Oubiwann: /* Lisps in Haskell */ Added missing space.</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler. Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60898Haskell Lisp2016-07-13T13:13:02Z<p>Oubiwann: /* Lisps in Haskell */ Added Shentong (Shen)</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/mthom/shentong Shentong] - The [http://www.shenlanguage.org/ Shen programming language] is a Lisp that offers pattern matching, lambda calculus consistency, macros, optional lazy evaluation, static type checking, one of the most powerful systems for typing in functional programming, portability over many languages, an integrated fully functional Prolog, and an inbuilt compiler-compiler.Shentong is an implementation of Shen written in Haskell.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60897Haskell Lisp2016-07-13T13:07:39Z<p>Oubiwann: /* Lisps in Haskell */ Added Egison</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://www.egison.org/ Egison] - Written in Haskell, Egison is a Lisp that realizes non-linear pattern-matching against non-free data types, directly representing pattern-matching against a wide range of data types such as lists, multisets, sets, trees and graphs.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60878Haskell Lisp2016-07-05T18:47:59Z<p>Oubiwann: Updated the taxonomy</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)<br />
<br />
= Haskell with Lisp Syntax =<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60877Haskell Lisp2016-07-05T18:46:41Z<p>Oubiwann: /* Background */ Added another division to the taxonomy</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are three areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
# Haskell with Lisp Syntax (Lisp-flavoured Haskells)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
Lisp Syntax for Haskell:<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=60876Haskell Lisp2016-07-05T18:44:32Z<p>Oubiwann: /* Background */</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (and perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are two areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
Lisp Syntax for Haskell:<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=57484Haskell Lisp2014-01-24T15:58:14Z<p>Oubiwann: fixed typo</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (an perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are two areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
Lisp Syntax for Haskell:<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written as part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=57415Haskell Lisp2014-01-17T17:51:35Z<p>Oubiwann: /* Haskell Lisp */ Formatting changes</p>
<hr />
<div>= Background =<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (an perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are two areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
= Haskells in Lisp =<br />
<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
= Lisps in Haskell =<br />
<br />
Lisp Syntax for Haskell:<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written are part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=57414Haskell Lisp2014-01-17T17:50:12Z<p>Oubiwann: /* Haskells in Lisp */ typo</p>
<hr />
<div>= Haskell Lisp =<br />
<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (an perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are two areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
== Haskells in Lisp ==<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was made available at the Haskell level.<br />
<br />
== Lisps in Haskell ==<br />
<br />
Lisp Syntax for Haskell:<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written are part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=57413Haskell Lisp2014-01-17T17:49:48Z<p>Oubiwann: /* Haskells in Lisp */ Added more details about Yale Haskell</p>
<hr />
<div>= Haskell Lisp =<br />
<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (an perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are two areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
== Haskells in Lisp ==<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, Harlequin LispWorks, Kyoto Common Lisp. The last did suffer from performance problems, though. Compiled binaries were available for Sparc systems running SunOS 4.1.2 and Sparc 10's (sun4m) running 4.1.3. In the last release, the full functionality of X windows was been made available at the Haskell level.<br />
<br />
== Lisps in Haskell ==<br />
<br />
Lisp Syntax for Haskell:<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written are part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Implementations&diff=57412Implementations2014-01-17T17:41:16Z<p>Oubiwann: /* Yale Haskell */ Added a link to the Haskell Lisp page where there is more information</p>
<hr />
<div>Below you find a list of all Haskell implementations. The recommend way to install Haskell on your computer is through the the [http://hackage.haskell.org/platform/ Haskell Platform].<br />
<br />
<br />
== Haskell 2010 == <br />
<br />
=== Glasgow Haskell Compiler (GHC) ===<br />
[[GHC]] is an optimising compiler for Haskell, providing many language extensions. GHC is the de facto standard compiler if you want fast code. GHC is written in Haskell (plus extensions), and its size and complexity mean that it is less portable than Hugs, it runs more slowly, and it needs more memory. However, the programs it produces run ''much'' faster.<br />
<br />
There is also an interactive environment, GHCi, which is like Hugs but supports interactive loading of compiled code. GHC provides profiling for time and space, and supports concurrent and parallel programming. It is available for most common platforms, including Windows, Mac OS X, and several Unix variants (Linux, *BSD, Solaris).<br />
<br />
The GHC team recommends installing the [http://hackage.haskell.org/platform/ Haskell Platform] to get GHC.<br />
<br />
<br />
== Haskell 98 ==<br />
<br />
=== Utrecht Haskell Compiler (UHC) ===<br />
[http://www.cs.uu.nl/wiki/UHC UHC] is a Haskell implementation from Utrecht University. UHC supports almost all Haskell98 features plus many experimental extensions. The compiler runs on Mac OS X, Windows (cygwin), and various Unix flavors.<br />
<br />
Features include: Multiple backends, including a bytecode interpreter backend and a whole-program analysis backend based on GRIN. Experimental language extensions, some of which have not been implemented before.<br />
<br />
UHC is implemented using [[Attribute grammar|attribute grammars]], and due to an aspect-oriented internal organisation is ideally suited for experimenting with language extensions.<br />
<br />
On April 18, 2009 UHC was [http://www.cs.uu.nl/wiki/UHC/Announce announced] at the 5th Haskell Hackathon in Utrecht.<br />
<br />
=== Jhc Haskell Compiler ===<br />
[http://repetae.net/computer/jhc/ Jhc] is an experimental compiler with a goal of testing new optimization methods and exploring the design space of Haskell implementations.<br />
<br />
<br />
== Haskell Dialects ==<br />
<br />
=== Disciple ===<br />
[http://disciple.ouroborus.net 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 effectful/imperative style, and one of our goals is to provide both styles coherently in the same language. Our compiler is still in the "research prototype" stage, but will compile programs if you are nice to it.<br />
<br />
<br />
== Unmaintained ==<br />
<br />
=== LHC ===<br />
[http://lhc.seize.it/ LHC] initially started off as a fork of JHC, but changed toward being an alternative GHC backend, performing aggressive whole-program analysis on GHC's external core language.<br />
<br />
=== Hugs ===<br />
[[Hugs]] is a small, portable Haskell interpreter written in C runs on almost any machine. Hugs is best used as a Haskell program development system: it boasts extremely fast source code interpretation, supports incremental interpretation, and has the convenience of an interactive interpreter (within which one can move from module to module to test different portions of a program). However, being an interpreter, it does not nearly match the run-time performance of, for example, GHC, nhc98, or HBC. Hugs 98 is conformant with Haskell 98. Available for all Unix platforms including Linux, DOS, Windows 3.x, and Win 32 (Windows 95, Win32s, NT) and Macintoshes. It has many libraries including Win32 libraries, a foreign interface mechanism to facilitate interoperability with C, and the Windows version has a graphical user interface called [[WinHugs]]. Explanations of some common Hugs error messages and their causes can be found on [http://www.cs.ukc.ac.uk/people/staff/sjt/craft2e/errors.html Simon Thompson's page].<br />
<br />
=== nhc98 ===<br />
[http://www.haskell.org/nhc98/ nhc98] is a small, easy to install, standards-compliant Haskell 98 compiler. It works only on 32-bit machines. It provides some advanced kinds of heap profiles not found in any other Haskell compiler. It produces medium-fast code, and compilation is itself quite fast. The compiler stresses the saving of space, that is, it produces small programs requiring comparatively little space at runtime (and it is itself much smaller than the other compilers). It is available for all Unix-like platforms (including Mac OS X, Cygwin/Windows, Linux, Solaris, *BSD, AIX, HP-UX, Ultrix, IRIX, etc.). It is written in Haskell 98, but can be quickly and easily bootstrapped from C sources.<br />
<br />
=== York Haskell Compiler (YHC) ===<br />
[[Yhc]] is a fork of [http://www.haskell.org/nhc98/ nhc98], with the goals of being simpler, more portable, more efficient and integrating [[Hat]] support.<br />
<br />
=== [http://www.cs.chalmers.se/~augustss/hbc/hbc.html '''HBI''' and '''HBC'''], Chalmers' Haskell Interpreter and Compiler ===<br />
The Chalmers Haskell-B compiler 0.9999.5c implements Haskell 98, as well as some extensions. It is written by Lennart Augustsson, and based on the classic LML compiler by Augustsson and Johnsson. The interpreter can also load code compiled with HBC. There has been no official release for the last few years and the support level is pretty low, but the compiler exists and can be used. Unfortunately the web-pages and the documentation has not been updated the last few years! You can download an unofficial [http://haskell.org/hbc/hbc-2004-06-29.src.tar.gz snapshot of the sources] and the corresponding [http://haskell.org/hbc/hbc-2004-06-29.bin-i386-linux.tar.gz x86 Linux binaries] (based on [http://www.cs.chalmers.se/pub/users/hallgren/Alfa/Haskell/ snapshots] from Thomas Hallgren and Magnus Carlsson).<br />
<br />
=== Helium ===<br />
[http://www.cs.uu.nl/wiki/Helium Helium] is a functional programming language and a compiler designed especially for teaching Haskell. Quality of the error messages has been the main concern both in the choice of the language features and in the implementation of the compiler. The language is a subset of the Haskell language. The most notable difference with Haskell is the absence of overloading. The compiler keeps track of a lot of information to produce informative messages.<br />
<br />
=== Yale Haskell ===<br />
[http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/code/syntax/haskell/0.html Yale Haskell 2.05], an early implementation of Haskell in Lisp. See an early [http://groups.google.com/group/comp.lang.functional/msg/5b929ac0223a6212?dmode=source&hl=en release announcement]. More information is available on the [[Haskell Lisp]] page.<br />
<br />
=== The Brisk compiler ===<br />
A product of the [http://www.cs.bris.ac.uk/Research/LanguagesArchitecture/brisk.html BRISK project] at the University of Bristol investigating the further use of functional programming in systems-level software development. Version [http://www.cs.bris.ac.uk/~ian/Functional/brisk.tgz 0.08] partially implements an early version of Haskell.<br />
<br />
== Comparison of Implementations ==<br />
* Comparison of [http://mirror.seize.it/report.html speed and memory usage] of several Haskell implementations (February 2011). This page also shows how many samples compile/run correctly.<br />
<br />
* A [http://stackoverflow.com/questions/4084790/compilers-for-haskell stackoverflow discussion] of several implementations.<br />
<br />
<br />
[[Category:Implementations| ]]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=57411Haskell Lisp2014-01-17T17:38:47Z<p>Oubiwann: /* Lisps in Haskell */ Added info about Lisps written in Haskell</p>
<hr />
<div>= Haskell Lisp =<br />
<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (an perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are two areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
== Haskells in Lisp ==<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, or Harlequin LispWorks<br />
<br />
== Lisps in Haskell ==<br />
<br />
Lisp Syntax for Haskell:<br />
<br />
* [https://github.com/haskell-lisp/liskell Liskell] - From the ILC 2007 paper: "Liskell uses an extremely minimalistic parse tree and shifts syntactic classification of parse tree parts to a later compiler stage to give parse tree transformers the opportunity to rewrite the parse trees being compiled. These transformers can be user supplied and loaded dynamically into the compiler to extend the language." Has not received attention for a while, though the author has stated that he continues to think about it and has future plans for it.<br />
* [https://github.com/haskell-lisp/historic-lisk Lisk] - Inspired by Liskell, but with the intent of making different design choices. Uses the [http://hackage.haskell.org/package/haskell-src-exts haskell-src-exts] AST and pretty printer to convert Lisk code to Haskell. 100% abandoned; interested parties are actively (and nicely!) discouraged by the original author. The name is being bandied about for a potential new Haskell+Lisp effort (blessed by the original author).<br />
<br />
The following Lisps are not wrappers around Haskell, but rather their own languages. Some may offer interop with FFI calls.<br />
<br />
* [https://github.com/haskell-lisp/husk-scheme Husk Scheme] - Implements a superset of the R5RS standard and a large portion of the R7RS-small language. Advanced features are provided including continuations, hygienic macros, libraries, and a full numeric tower. Actively maintained.<br />
* [https://github.com/haskell-lisp/leesp Leesp] - Like Husk, this was written are part of the popular Scheme/Haskell tutorial. Actively maintained.<br />
* [https://github.com/haskell-lisp/blaise Blaise] - Slava Akhmechet's Lisp from 2006. Recently updated by community members to run on the lastest version of GHC. The original author likely disavows any interest :-)</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=57410Haskell Lisp2014-01-17T17:18:01Z<p>Oubiwann: /* Haskells in Lisp */ Added notes about Yale Haskell</p>
<hr />
<div>= Haskell Lisp =<br />
<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (an perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are two areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
== Haskells in Lisp ==<br />
* [https://github.com/haskell-lisp/yale-haskell Yale Haskell] - written between 1991 and 1993; was built from sources using CMU Common Lisp, Lucid Common Lisp, Allegro Common Lisp, or Harlequin LispWorks<br />
<br />
== Lisps in Haskell ==<br />
* TBD</div>Oubiwannhttps://wiki.haskell.org/index.php?title=IRC_channel&diff=57409IRC channel2014-01-17T17:11:54Z<p>Oubiwann: /* Related channels */ Added #haskell-lisp</p>
<hr />
<div>Internet Relay Chat is a worldwide text chat service with many thousands<br />
of users among various irc networks.<br />
<br />
The Freenode IRC network hosts the very large #haskell channel, and we've had<br />
up to 1046<br />
concurrent users, making the channel consistently<br />
[http://irc.netsplit.de/channels/details.php?room=%23haskell&net=freenode one of the most popular]<br />
of the thousands of channels on freenode. One famous<br />
resident is [[Lambdabot]], another is [http://hpaste.org hpaste] (see<br />
the [[#Bots|Bots]] section below).<br />
<br />
The IRC channel can be an excellent place to learn more about Haskell,<br />
and to just keep in the loop on new things in the Haskell world. Many<br />
new developments in the Haskell world first appear on the irc channel.<br />
<br />
Since 2009, the Haskell channel has grown large enough that we've split it in two parts:<br />
<br />
* #haskell, for all the usual things<br />
* #haskell-in-depth , for those seeking in depth, or more theoretical discussion<br />
<br />
As always, #haskell remains the primary place for new user questions.<br />
<br />
{| border="0" align="right"<br />
|+ '''#haskell visualized'''<br />
|-<br />
| [[Image:Haskell-current.png|thumb|The social graph, Jan 2008]]<br />
| [[Image:Irc-raw.png|thumb|Daily traffic since 2004]]<br />
|-<br />
| [[Image:Nick-activity.png|thumb|Growth]]<br />
| [[Image:Haskell-wordle-irc.png|thumb|Noun map]]<br />
|}<br />
<br />
== Getting there ==<br />
<br />
If you point your irc client to [irc://chat.freenode.net/haskell chat.freenode.net] and then join the #haskell channel, you'll be there. Alternately, you can try http://java.freenode.net/ or http://webchat.freenode.net/ which connects inside the browser.<br />
<br />
Example, using [http://www.irssi.org/ irssi]:<br />
<br />
$ irssi -c chat.freenode.net -n myname -w mypassword<br />
/join #haskell<br />
<br />
Tip, if you're using Emacs to edit your Haskell sources then why not use it to chat about Haskell? Check out [http://www.emacswiki.org/cgi-bin/wiki/EmacsIRCClient ERC], The Emacs IRC client. Invoke it like this and follow the commands:<br />
<br />
M-x erc-select<br />
...<br />
/join #haskell<br />
<br />
[[Image:Irc--haskell-screenshot.png|frame|A screenshot of an irssi session in #haskell]]<br />
<br />
== Principles ==<br />
<br />
The #haskell channel is a very friendly, welcoming place to hang out,<br />
teach and learn. The goal of #haskell is to encourage learning and<br />
discussion of Haskell, functional programming, and programming in<br />
general. As part of this we welcome newbies, and encourage teaching of<br />
the language.<br />
<br />
Part of the #haskell success comes from the fact that the community<br />
is quite tight knit &mdash; we know each other &mdash; it's not just a homework<br />
channel. As a result, many collaborative projects have arisen between<br />
Haskell irc channel citizens.<br />
<br />
To maintain the friendly, open culture, the following is required:<br />
<br />
* Low to zero tolerance for ridiculing questions. Insulting new users is unacceptable. New Haskell users should feel entirely comfortable asking questions.<br />
<br />
* Helpful answers should be encouraged with <code>name++</code> karma points, in public, as a reward for providing a good answer.<br />
<br />
* Avoid getting frustrated by negative comments and ambiguous questions. Approach them by asking for details (i.e. [http://en.wikipedia.org/wiki/Socratic_method Socratic questioning]), rather than challenging the competence of the writer (ad hominem). As the channel grows, we see a diverse range of people with different programming backgrounds getting accustomed to Haskell. Be patient and take satisfaction from spreading knowledge.<br />
<br />
== History ==<br />
<br />
The #haskell channel appeared in the late 90s, and really got going<br />
in early 2001, with the help of Shae Erisson (aka shapr).<br />
<br />
A fairly extensive analysis of the traffic on #haskell over the years is<br />
[http://www.cse.unsw.edu.au/~dons/irc/ kept here]<br />
<br />
== Related channels ==<br />
<br />
In addition to the main Haskell channel there are also:<br />
<br />
{| border="1" cellspacing="0" cellpadding="5" align="center"<br />
! Channel<br />
! Purpose<br />
|-<br />
| #haskell-br<br />
| Brazilian Portuguese (pt_BR) speakers<br />
|-<br />
| #haskell.cz<br />
| Czech speakers (UTF-8)<br />
|- <br />
| #haskell.de<br />
| German speakers<br />
|-<br />
| #haskell.dut<br />
| Dutch speakers<br />
|-<br />
| #haskell.es<br />
| Spanish speakers<br />
|-<br />
| #haskell.fi<br />
| Finnish speakers<br />
|-<br />
| #haskell-fr (note the hyphen!)<br />
| French speakers <br />
|-<br />
| #haskell.hr<br />
| Croatian speakers<br />
|-<br />
| #haskell.it <br />
| Italian speakers<br />
|-<br />
| #haskell.jp <br />
| Japanese speakers<br />
|-<br />
| #haskell.no <br />
| Norwegian speakers<br />
|-<br />
| #haskell.pt<br />
| Portuguese speakers<br />
|-<br />
| #haskell-pl<br />
| Polish speakers<br />
|-<br />
| #haskell.ru <br />
| Russian speakers. Seems that most of them migrated to Jabber conference (haskell@conference.jabber.ru).<br />
|-<br />
| #haskell_ru <br />
| Russian speakers again, in UTF-8. For those, who prefer good ol' IRC channel with a lambdabot.<br />
|-<br />
| #haskell.se <br />
| Swedish speakers<br />
|-<br />
| #haskell.tw<br />
| Chinese speakers (mainly in Taiwan)<br />
|-<br />
| #haskell-blah <br />
| Haskell people talking about anything except Haskell itself<br />
|-<br />
| #haskell-game<br />
| The hub for Haskell-based [[Game Development|game development]]<br />
|-<br />
| #haskell-in-depth<br />
| slower paced discussion of use, theory, implementation etc with no monad tutorials!<br />
|-<br />
| #haskell-iphone<br />
| Haskell-based [[iPhone]] development<br />
|-<br />
| #haskell-apple<br />
| projects that target iOS or OS X using Haskell. <br />
|-<br />
| #haskell-lisp<br />
| [[Haskell Lisp]] - projects that are creating Lisps written in Haskell, or Haskell implementations written in Lisps. <br />
|-<br />
| #haskell-llvm<br />
| For projects using Haskell and LLVM<br />
|-<br />
| #haskell-overflow<br />
| Overflow conversations<br />
|-<br />
| #haskell-web<br />
| Friendly, practical discussion of haskell web app/framework/server development<br />
|-<br />
| '''Platform-specific:'''<br />
|<br />
|-<br />
| #arch-haskell <br />
| [[Arch Linux]]/ specific Haskell conversations<br />
|-<br />
| #fedora-haskell<br />
| [[Fedora]] Haskell SIG<br />
|-<br />
| #gentoo-haskell <br />
| [[Gentoo]]/Linux specific Haskell conversations<br />
|-<br />
| '''Projects using haskell:'''<br />
|<br />
|-<br />
| #darcs <br />
| [[Darcs]] revision control system<br />
|-<br />
| #diagrams<br />
| [[Diagrams]] EDSL<br />
|-<br />
| #hackage<br />
| Haskell's software distribution infrastructure<br />
|-<br />
| #haskell-lens<br />
| [[Lens]] discussions<br />
|-<br />
| #happs<br />
| [http://happstack.com Happstack] web framework<br />
|-<br />
| #hledger<br />
| [http://hledger.org hledger] accounting tools and library<br />
|-<br />
| #leksah<br />
| [http://leksah.org Leksah] IDE for Haskell development<br />
|-<br />
| #perl6 <br />
| [http://www.pugscode.org Perl 6] development (plenty of Haskell chat there too)<br />
|-<br />
| #snapframework<br />
| [http://snapframework.com/ Snap] web framework<br />
|-<br />
| #xmonad<br />
| [http://xmonad.org Xmonad] tiling window manager<br />
|-<br />
| #yesod<br />
| [http://yesodweb.com Yesod] web framework<br />
|-<br />
| #chicagohaskell<br />
| [http://chicagohaskell.com Chicago Haskell] programmers group<br />
|}<br />
<br />
== Logs ==<br />
<br />
'''Logs''' are kept at http://tunes.org/~nef/logs/haskell/ and can be searched at http://ircbrowse.net/browse/haskell<br />
<br />
<!-- anywhere else? ircbrowse.com is a goner, apparently --><br />
<br />
== Bots ==<br />
<br />
There are various bots on the channel. Their names and usage are described here.<br />
<br />
=== lambdabot ===<br />
<br />
[[Lambdabot]] is both the name of a software package and a bot on the channel. It provides many useful services for visitors to the IRC channel. It is available as a haskell package and can be integrated into ghci. Details on the software are found on a [[Lambdabot|separate wiki page]].<br />
<br />
Here is its interface for the IRC user:<br />
<br />
lambdabot's commands are prepended by a '@' sign.<br />
<br />
{| border="1" cellspacing="0" cellpadding="5" align="center"<br />
! Command<br />
! Usage<br />
|-<br />
| @help<br />
| display help to other commands, but help text is not available for all commands.<br />
|-<br />
| @type EXPR or ':t' EXPR<br />
| shows the type of an expression<br />
|-<br />
| @kind TYPECONSTRUCTOR<br />
| shows the kind of a type constructor<br />
|-<br />
| @run EXPR or '>' EXPR<br />
| evaluates EXPR<br />
|-<br />
| @pl FUNCTION<br />
| shows a [[pointfree]] version of FUNCTION<br />
|-<br />
| @pointful FUNCTION or '@unpl' FUNCTION<br />
| shows a 'pointful' version of FUNCTION<br />
|-<br />
| @tell <nick> <msg> -- same as @ask<br />
| Next time <nick> speaks in channel they will be notified they have a message pending and how to receive it.<br />
|}<br />
<br />
=== preflex ===<br />
<br />
is the name of a lambdabot with more commands/plugins enabled. It is run by ?? To talk to preflex, write <tt>preflex: command ARGS</tt><br />
<br />
{| border="1" cellspacing="0" cellpadding="5" align="center"<br />
! Command<br />
! Usage<br />
|-<br />
| help COMMAND<br />
| displays help to other commands.<br />
|-<br />
| list<br />
| lists all plugins with their commands<br />
|-<br />
| NICK++ / NICK--<br />
| in/decrements the karma of NICK.<br />
|-<br />
| karma NICK<br />
| shows the karma of NICK<br />
|-<br />
| seen NICK<br />
| shows information about the last message of a user<br />
|-<br />
| tell / ask<br />
| sends NICK MSG a message when she becomes active.<br />
|-<br />
| xseen<br />
| ''see 'seen' ?? any difference ?''<br />
|-<br />
| quote NICK<br />
| prints a random quote of NICK<br />
|-<br />
| remember NAME QUOTE<br />
| associates NAME with quote. can be accessed by 'quote'<br />
|-<br />
| ...<br />
| ...<br />
|}<br />
<br />
=== hpaste ===<br />
The hpaste bot provides a notification interface to the [http://hpaste.org hpaste pastebin]. [[Hpaste.el|Emacs integration]] is available.<br />
<br />
''Usage?''<br />
<br />
''Not online often !? ''<br />
<br />
=== hackage ===<br />
The hackage bot provides real-time notifications of new package uploads to [http://hackage.haskell.org Hackage].<br />
<br />
== Locations ==<br />
<br />
To get an overview of where everybody on the channel might<br />
be, physically, please visit [[Haskell user locations]].<br />
<br />
<br />
[[Category:Community]]</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Haskell_Lisp&diff=57408Haskell Lisp2014-01-17T17:11:30Z<p>Oubiwann: Added the Haskell-Lisp page</p>
<hr />
<div>= Haskell Lisp =<br />
<br />
Lispers who love Haskell can be heard saying that Haskell is Lisp's missing [http://en.wikipedia.org/wiki/M-expression M-Expression] implementation. Though that statement embodies a great deal of poetic license (an perhaps romanticism), there is a very natural fit between the two.<br />
<br />
In practical terms, there are two areas of intersection between Haskell and Lisp: <br />
# Haskell implementations written in Lisp (there seems to be only one of these), and<br />
# Lisps written in Haskell (much more common)<br />
<br />
There is a [https://github.com/haskell-lisp github organization] which tracks these projects, though more detail is given below.<br />
<br />
Also, there is a [https://twitter.com/HaskellLisp twitter account] dedicated to all things Haskell+Lisp.<br />
<br />
== Haskells in Lisp ==<br />
* TBD<br />
<br />
== Lisps in Haskell ==<br />
* TBD</div>Oubiwannhttps://wiki.haskell.org/index.php?title=User:Oubiwann&diff=57407User:Oubiwann2014-01-17T16:56:18Z<p>Oubiwann: Added more wiki links</p>
<hr />
<div>= Duncan McGreggor =<br />
<br />
== Contact Info ==<br />
* IRC/Freenode: oubiwann on #haskell, #haskell-lisp, #erlang-lisp, etc.<br />
* Github<br />
** oubiwann: https://github.com/oubiwann<br />
** LFE: https://github.com/lfe/<br />
** Haskell-Lisp: https://github.com/haskell-lisp<br />
* Twitter: http://twitter.com/oubiwann<br />
* Blog: http://cogitat.io/<br />
* LinkedIn: https://www.linkedin.com/in/oubiwann<br />
* Other wikis:<br />
** Ubuntu: https://wiki.ubuntu.com/Oubiwann<br />
** OpenStack: https://wiki.openstack.org/wiki/Oubiwann<br />
** Twisted: http://twistedmatrix.com/trac/wiki/People/DuncanMcGreggor<br />
** RosettaCode: [http://rosettacode.org/mw/index.php?title=Special:Contributions/Oubiwann&offset=&limit=500&target=Oubiwann contributions]<br />
** Wikipedia: [http://en.wikipedia.org/w/index.php?title=Special:Contributions/Oubiwann&offset=&limit=500&target=Oubiwann contributions]<br />
<br />
<br />
== Current Interests ==<br />
<br />
* Lisp implementations in Haskell (and other languages)<br />
* Monad implementations in other languages<br />
* Distributed systems<br />
* Services and service client libraries<br />
* Genetic programming<br />
* Math and PL histories<br />
* Hidden corners of data mining<br />
* Old text and ASCII games (e.g., BSD games, zork, etc.)<br />
<br />
== Language History ==<br />
<br />
Languages with the year of initial coding (in reverse chronological order):<br />
* ClojureScript - 2014<br />
* Shen, TinyScheme, ISLISP/OpenLisp, Hy - 2013<br />
* LFE, Erlang, Clojure, Chicken Scheme, NewLisp, CoffeScript - 2012<br />
* Objective-C, Go - 2010<br />
* Haskell - 2009 <br />
* CommonLisp, MzScheme - 2008<br />
* Lua, E - 2006<br />
* Oz (Mozart), Ruby - 2005<br />
* Java - 2004<br />
* Twisted - 2003<br />
* Python, Tcl, C++, R - 1999<br />
* Perl, JavaScript - 1998<br />
* x86 Assembly - 1997<br />
* MATLAB, Bash - 1996<br />
* Mathematica, DCL - 1994<br />
* Pascal - 1992<br />
* C - 1989<br />
* BASIC - 1981</div>Oubiwannhttps://wiki.haskell.org/index.php?title=User:Oubiwann&diff=57406User:Oubiwann2014-01-17T16:21:16Z<p>Oubiwann: Added a personal page</p>
<hr />
<div>= Duncan McGreggor =<br />
<br />
== Contact Info ==<br />
* IRC/Freenode: oubiwann on #haskell, #haskell-lisp, #erlang-lisp, etc.<br />
* Github<br />
** oubiwann: https://github.com/oubiwann<br />
** LFE: https://github.com/lfe/<br />
** Haskell-Lisp: https://github.com/haskell-lisp<br />
* Twitter: http://twitter.com/oubiwann<br />
* Blog: http://cogitat.io/<br />
* LinkedIn: https://www.linkedin.com/in/oubiwann<br />
<br />
== Current Interests ==<br />
<br />
* Lisp implementations in Haskell (and other languages)<br />
* Monad implementations in other languages<br />
* Distributed systems<br />
* Services and service client libraries<br />
* Genetic programming<br />
* Math and PL histories<br />
* Hidden corners of data mining<br />
* Old text and ASCII games (e.g., BSD games, zork, etc.)<br />
<br />
== Language History ==<br />
<br />
Languages with the year of initial coding (in reverse chronological order):<br />
* ClojureScript - 2014<br />
* Shen, TinyScheme, ISLISP/OpenLisp, Hy - 2013<br />
* LFE, Erlang, Clojure, Chicken Scheme, NewLisp, CoffeScript - 2012<br />
* Objective-C, Go - 2010<br />
* Haskell - 2009 <br />
* CommonLisp, MzScheme - 2008<br />
* Lua, E - 2006<br />
* Oz (Mozart), Ruby - 2005<br />
* Java - 2004<br />
* Twisted - 2003<br />
* Python, Tcl, C++, R - 1999<br />
* Perl, JavaScript - 1998<br />
* x86 Assembly - 1997<br />
* MATLAB, Bash - 1996<br />
* Mathematica, DCL - 1994<br />
* Pascal - 1992<br />
* C - 1989<br />
* BASIC - 1981</div>Oubiwannhttps://wiki.haskell.org/index.php?title=Monad&diff=57405Monad2014-01-17T15:15:08Z<p>Oubiwann: /* Monads in other languages */ Added a link to Clojure's implementation</p>
<hr />
<div>{{Standard class|Monad|module=Control.Monad|module-doc=Control-Monad|package=base}}<br />
<br />
'''''Monads''''' in Haskell can be thought of as ''composable'' computation descriptions. The essence of monad is thus ''separation'' of ''composition timeline'' from the composed computation's ''execution timeline'', as well as the ability of ''computation'' to implicitly carry extra data, as pertaining to the computation itself, in addition to its ''one'' (hence the name) output, that it '''''will produce''''' when run (or queried, or called upon). This lends monads to supplementing ''pure'' calculations with features like I/O, common environment or state, etc. <br />
<br />
Each monad, or computation type, provides means, subject to '''''Monad Laws''''', to '''''(a)''''' ''create'' a description of computation action that will produce (a.k.a. "return") a given Haskell value, '''''(b)''''' somehow ''run'' a computation action description (possibly getting its output back into Haskell should the monad choose to allow it, if computations described by the monad are pure, or causing the prescribed side effects if it's not), and '''''(c)''''' ''combine'' (a.k.a. "bind") a computation action description with a ''reaction'' to it &ndash; a regular Haskell function of one argument (that will receive computation-produced value) returning another action description (using or dependent on that value, if need be) &ndash; thus creating a combined computation action description that will feed the original action's output through the reaction while automatically taking care of the particulars of the computational process itself. A monad might also define additional primitives to provide access to and/or enable manipulation of data it implicitly carries, specific to its nature.<br />
<br />
[[Image:Monads inter-dependencies 2.png|center]]<br />
<br />
Thus in Haskell, though it is a purely-functional language, side effects that '''''will be performed''''' by a computation can be dealt with and combined ''purely'' at the monad's composition time. Monads thus resemble programs in a particular [[DSL]]. While programs may describe impure effects and actions ''outside'' Haskell, they can still be combined and processed (''"assembled"'') purely, ''inside'' Haskell, creating a pure Haskell value - a computation action description that describes an impure calculation. That is how Monads in Haskell '''''separate''''' between the ''pure'' and the ''impure''. <br />
<br />
The computation doesn't have to be impure and can be pure itself as well. Then monads serve to provide the benefits of separation of concerns, and automatic creation of a computational "pipeline". Because they are very useful in practice but rather mind-twisting for the beginners, numerous tutorials that deal exclusively with monads were created (see [[Monad#Monad tutorials|monad tutorials]]).<br />
<br />
== Common monads ==<br />
Most common applications of monads include:<br />
* Representing failure using <hask>Maybe</hask> monad<br />
* Nondeterminism using <hask>List</hask> monad to represent carrying multiple values<br />
* State using <hask>State</hask> monad<br />
* Read-only environment using <hask>Reader</hask> monad<br />
* I/O using <hask>IO</hask> monad<br />
<br />
== Monad class ==<br />
<br />
Monads can be viewed as a standard programming interface to various data or control structures, which is captured by the <hask>Monad</hask> class. All common monads are members of it:<br />
<br />
<haskell><br />
class Monad m where<br />
(>>=) :: m a -> (a -> m b) -> m b<br />
(>>) :: m a -> m b -> m b<br />
return :: a -> m a<br />
fail :: String -> m a<br />
</haskell><br />
<br />
In addition to implementing the class functions, all instances of Monad should obey the following equations, or '''''Monad Laws''''':<br />
<br />
<haskell><br />
return a >>= k = k a<br />
m >>= return = m<br />
m >>= (\x -> k x >>= h) = (m >>= k) >>= h<br />
</haskell><br />
<br />
See [[Monad laws|this intuitive explanation]] of why they should obey the Monad laws. It basically says that monad's reactions should be associative under Kleisli composition, defined as <code>(f >=> g) x = f x >>= g</code>, with <code>return</code> its left and right identity element.<br />
<br />
Any Monad can be made a [[Functor]] by defining <br />
<br />
<haskell><br />
fmap ab ma = ma >>= (return . ab)<br />
</haskell><br />
<br />
However, the Functor class is not a superclass of the Monad class. See [[Functor hierarchy proposal]].<br />
<br />
== Special notation ==<br />
<br />
In order to improve the look of code that uses monads Haskell provides a special [[syntactic sugar]] called <hask>do</hask>-notation. For example, the following expression:<br />
<br />
<haskell><br />
thing1 >>= (\x -> func1 x >>= (\y -> thing2 <br />
>>= (\_ -> func2 y >>= (\z -> return z))))<br />
</haskell><br />
<br />
which can be written more clearly by breaking it into several lines and omitting parentheses:<br />
<br />
<haskell><br />
thing1 >>= \x -><br />
func1 x >>= \y -><br />
thing2 >>= \_ -><br />
func2 y >>= \z -><br />
return z<br />
</haskell><br />
<br />
This can also be written using the <hask>do</hask>-notation as follows:<br />
<br />
<haskell><br />
do<br />
x <- thing1<br />
y <- func1 x<br />
thing2<br />
z <- func2 y<br />
return z<br />
</haskell><br />
<br />
Code written using <hask>do</hask>-notation is transformed by the compiler to ordinary expressions that use the functions from the <hask>Monad</hask> class.<br />
<br />
When using <hask>do</hask>-notation and a monad like <hask>State</hask> or <hask>IO</hask> programs look very much like programs written in an imperative language as each line contains a statement that can change the simulated global state of the program and optionally binds a (local) variable that can be used by the statements later in the code block.<br />
<br />
It is possible to intermix the <hask>do</hask>-notation with regular notation.<br />
<br />
More on <hask>do</hask>-notation can be found in a section of [[Monads as computation#Do notation|Monads as computation]] and in other [[Monad#Monad tutorials|tutorials]].<br />
<br />
== Commutative monads ==<br />
'''Commutative monads''' are monads for which the order of actions makes no difference (they '''commute'''), that is when following code:<br />
<haskell><br />
do<br />
a <- actA<br />
b <- actB<br />
m a b<br />
</haskell><br />
is the same as:<br />
<haskell><br />
do<br />
b <- actB<br />
a <- actA<br />
m a b<br />
</haskell><br />
<br />
Examples of commutative include:<br />
* <hask>Reader</hask> monad<br />
* <hask>Maybe</hask> monad<br />
<br />
== Monad tutorials ==<br />
<br />
Monads are known for being deeply confusing to lots of people, so there are plenty of tutorials specifically related to monads. Each takes a different approach to Monads, and hopefully everyone will find something useful.<br />
<br />
See the [[Monad tutorials timeline]] for a comprehensive list of monad tutorials.<br />
<br />
== Monad reference guides ==<br />
<br />
An explanation of the basic Monad functions, with examples, can be found in the reference guide [http://members.chello.nl/hjgtuyl/tourdemonad.html A tour of the Haskell Monad functions], by Henk-Jan van Tuyl.<br />
<br />
== Monad research ==<br />
<br />
A collection of [[Research_papers/Monads_and_arrows|research papers]] about monads.<br />
<br />
== Monads in other languages ==<br />
<br />
Implementations of monads in other languages.<br />
<br />
* [http://www.reddit.com/r/programming/comments/1761q/monads_in_c_pt_ii/ C]<br />
* [https://github.com/clojure/algo.monads Clojure]<br />
* [http://cml.cs.uchicago.edu/pages/cml.html CML.event] ?<br />
* [http://www.st.cs.ru.nl/papers/2010/CleanStdEnvAPI.pdf Clean] State monad<br />
* [http://cratylus.freewebspace.com/monads-in-javascript.htm JavaScript]<br />
* [http://www.ccs.neu.edu/home/dherman/browse/code/monads/JavaMonads/ Java]<br />
* [http://permalink.gmane.org/gmane.comp.lang.concatenative/1506 Joy]<br />
* [http://research.microsoft.com/en-us/um/people/emeijer/Papers/XLinq%20XML%20Programming%20Refactored%20(The%20Return%20Of%20The%20Monoids).htm LINQ]<br />
* [http://common-lisp.net/project/cl-monad-macros/monad-macros.htm Lisp]<br />
* [http://lambda-the-ultimate.org/node/1136#comment-12448 Miranda]<br />
* OCaml:<br />
** [http://www.cas.mcmaster.ca/~carette/pa_monad/ OCaml]<br />
** [https://mailman.rice.edu/pipermail/metaocaml-users-l/2005-March/000057.html more]<br />
** [http://www.cas.mcmaster.ca/~carette/metamonads/ MetaOcaml]<br />
** [http://blog.enfranchisedmind.com/2007/08/a-monad-tutorial-for-ocaml/ A Monad Tutorial for Ocaml]<br />
* [http://www.reddit.com/r/programming/comments/p66e/are_monads_actually_used_in_anything_except Perl6 ?]<br />
* [http://logic.csci.unt.edu/tarau/research/PapersHTML/monadic.html Prolog] <br />
* Python<br />
** [http://code.activestate.com/recipes/439361/ Python]<br />
** Twisted's [http://www.reddit.com/r/programming/comments/p66e/are_monads_actually_used_in_anything_except/cp8eh Deferred monad]<br />
* Ruby:<br />
** [http://moonbase.rydia.net/mental/writings/programming/monads-in-ruby/00introduction.html Ruby]<br />
** [http://meta-meta.blogspot.com/2006/12/monads-in-ruby-part-1-identity.html and other implementation]<br />
* Scheme:<br />
** [http://okmij.org/ftp/Scheme/monad-in-Scheme.html Scheme]<br />
** [http://www.ccs.neu.edu/home/dherman/research/tutorials/monads-for-schemers.txt also]<br />
* [http://wiki.tcl.tk/13844 Tcl]<br />
* [http://okmij.org/ftp/Computation/monadic-shell.html The Unix Shell]<br />
* [http://okmij.org/ftp/Computation/monads.html More monads by Oleg]<br />
* [http://lambda-the-ultimate.org/node/2322 CLL]: a concurrent language based on a first-order intuitionistic linear logic where all right synchronous connectives are restricted to a monad. <br />
<br />
Unfinished:<br />
<br />
* [http://wiki.tcl.tk/14295 Parsing], [http://wiki.tcl.tk/13844 Maybe and Error] in Tcl<br />
<br />
And possibly there exist:<br />
<br />
* Standard ML (via modules?)<br />
<br />
Please add them if you know of other implementations.<br />
<br />
[http://lambda-the-ultimate.org/node/1136 Collection of links to monad implementations in various languages.] on [http://lambda-the-ultimate.org/ Lambda The Ultimate].<br />
<br />
==Interesting monads==<br />
<br />
A list of monads for various evaluation strategies and games:<br />
<br />
* [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Monad-Identity.html Identity monad] - the trivial monad.<br />
* [http://www.haskell.org/ghc/docs/latest/html/libraries/base/Data-Maybe.html Optional results from computations] - error checking without null.<br />
* [http://hackage.haskell.org/packages/archive/monad-mersenne-random/latest/doc/html/Control-Monad-Mersenne-Random.html Random values] - run code in an environment with access to a stream of random numbers.<br />
* [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Monad-Reader.html Read only variables] - guarantee read-only access to values.<br />
* [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Monad-Writer-Lazy.html Writable state] - i.e. log to a state buffer<br />
* [http://www.haskell.org/haskellwiki/New_monads/MonadSupply A supply of unique values] - useful for e.g. guids or unique variable names<br />
* [http://www.haskell.org/ghc/docs/latest/html/libraries/base/Control-Monad-ST.html ST - memory-only, locally-encapsulated mutable variables]. Safely embed mutable state inside pure functions.<br />
* [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Monad-State-Lazy.html Global state] - a scoped, mutable state.<br />
* [http://hackage.haskell.org/packages/archive/Hedi/latest/doc/html/Undo.html Undoable state effects] - roll back state changes<br />
* [http://www.haskell.org/ghc/docs/latest/html/libraries/base/Control-Monad-Instances.html#t:Monad Function application] - chains of function application.<br />
* [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Monad-Error.html Functions which may error] - track location and causes of errors.<br />
* [http://hackage.haskell.org/packages/archive/stm/latest/doc/html/Control-Monad-STM.html Atomic memory transactions] - software transactional memory<br />
* [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control-Monad-Cont.html Continuations] - computations which can be interrupted and resumed.<br />
* [http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO IO] - unrestricted side effects on the world<br />
* [http://hackage.haskell.org/packages/archive/level-monad/0.4.1/doc/html/Control-Monad-Levels.html Search monad] - bfs and dfs search environments.<br />
* [http://hackage.haskell.org/packages/archive/stream-monad/latest/doc/html/Control-Monad-Stream.html non-determinism] - interleave computations with suspension.<br />
* [http://hackage.haskell.org/packages/archive/stepwise/latest/doc/html/Control-Monad-Stepwise.html stepwise computation] - encode non-deterministic choices as stepwise deterministic ones<br />
* [http://logic.csci.unt.edu/tarau/research/PapersHTML/monadic.html Backtracking computations]<br />
* [http://www.cs.cornell.edu/people/fluet/research/rgn-monad/index.html Region allocation effects]<br />
* [http://hackage.haskell.org/packages/archive/logict/0.5.0.2/doc/html/Control-Monad-Logic.html LogicT] - backtracking monad transformer with fair operations and pruning<br />
* [http://hackage.haskell.org/packages/archive/monad-task/latest/doc/html/Control-Monad-Task.html concurrent events and threads] - refactor event and callback heavy programs into straight-line code via co-routines<br />
* [http://hackage.haskell.org/package/QIO QIO] - The Quantum computing monad<br />
* [http://hackage.haskell.org/packages/archive/full-sessions/latest/doc/html/Control-Concurrent-FullSession.html Pi calculus] - a monad for Pi-calculus style concurrent programming<br />
* [http://www-fp.dcs.st-and.ac.uk/~kh/papers/pasco94/subsubsectionstar3_3_2_3.html Commutable monads for parallel programming]<br />
* [http://hackage.haskell.org/package/stream-monad Simple, Fair and Terminating Backtracking Monad]<br />
* [http://hackage.haskell.org/package/control-monad-exception Typed exceptions with call traces as a monad]<br />
* [http://hackage.haskell.org/package/control-monad-omega Breadth first list monad]<br />
* [http://hackage.haskell.org/package/control-monad-queue Continuation-based queues as monads]<br />
* [http://hackage.haskell.org/package/full-sessions Typed network protocol monad]<br />
* [http://hackage.haskell.org/package/level-monad Non-Determinism Monad for Level-Wise Search]<br />
* [http://hackage.haskell.org/package/monad-tx Transactional state monad]<br />
* [http://hackage.haskell.org/package/monadiccp A constraint programming monad]<br />
* [http://hackage.haskell.org/package/ProbabilityMonads A probability distribution monad]<br />
* [http://hackage.haskell.org/package/set-monad Sets] - Set computations<br />
* [http://hackage.haskell.org/package/http-monad/ HTTP] - http connections as a monadic environment<br />
* [http://hackage.haskell.org/package/monad-memo Memoization] - add memoization to code<br />
<br />
There are many more interesting instance of the monad abstraction out there. Please add them as you come across each species.<br />
<br />
==Fun==<br />
<br />
* If you are tired of monads, you can easily [http://www.haskell.org.monadtransformer.parallelnetz.de/haskellwiki/Category:Monad get rid of them].<br />
<br />
==See also==<br />
<br />
* [[What a Monad is not]]<br />
* [[Monads as containers]]<br />
* [[Monads as computation]]<br />
* [[Monad/ST]]<br />
* [http://www.haskellforall.com/2012/06/you-could-have-invented-free-monads.html Why free monads matter] (blog article)<br />
<br />
[[Category:Monad|*]]</div>Oubiwann