Personal tools

Applications and libraries/Compilers and interpreters

From HaskellWiki

< Applications and libraries(Difference between revisions)
Jump to: navigation, search
(Constantinople)
(Large languages: Added Elm, moved BASIC to a better location, improved lay-out)
 
(One intermediate revision by one user not shown)
Line 28: Line 28:
 
;[http://www.csg.lcs.mit.edu/projects/languages/ph.shtml pH]
 
;[http://www.csg.lcs.mit.edu/projects/languages/ph.shtml pH]
 
:A parallel version of Haskell from MIT.
 
:A parallel version of Haskell from MIT.
  +
   
 
====Helium====
 
====Helium====
  +
 
;[http://www.cs.uu.nl/helium/ Helium]
 
;[http://www.cs.uu.nl/helium/ Helium]
 
:A Haskell subset for educational purposes
 
:A Haskell subset for educational purposes
  +
   
 
====Generic Haskell====
 
====Generic Haskell====
  +
 
;[http://generic-haskell.org/ Generic Haskell]
 
;[http://generic-haskell.org/ Generic Haskell]
 
:An extension of Haskell that supports generic programming
 
:An extension of Haskell that supports generic programming
  +
   
 
====Data Field Haskell====
 
====Data Field Haskell====
  +
 
;[http://www.mrtc.mdh.se/projects/DFH/ Data Field Haskell]
 
;[http://www.mrtc.mdh.se/projects/DFH/ Data Field Haskell]
 
:A dialect of the functional programming language Haskell that provides an instance of data fields
 
:A dialect of the functional programming language Haskell that provides an instance of data fields
  +
   
 
====Eden====
 
====Eden====
  +
 
;[http://www.mathematik.uni-marburg.de/~eden/ Eden]
 
;[http://www.mathematik.uni-marburg.de/~eden/ Eden]
 
:A Haskell dialect for parallel programming
 
:A Haskell dialect for parallel programming
   
====BASIC====
 
 
;[http://hackage.haskell.org/package/BASIC BASIC]
 
:A simplified version of the original BASIC embedded in Haskell.
 
   
 
====Chameleon====
 
====Chameleon====
  +
 
;[http://taichi.ddns.comp.nus.edu.sg/taichiwiki/ChameleonHomePage Chameleon]
 
;[http://taichi.ddns.comp.nus.edu.sg/taichiwiki/ChameleonHomePage Chameleon]
 
:A Haskell-style language which implements the ideas described in a ``A Theory of Overloading``
 
:A Haskell-style language which implements the ideas described in a ``A Theory of Overloading``
  +
   
 
====CHR (Constraint Handling Rules)====
 
====CHR (Constraint Handling Rules)====
  +
 
;[http://www.cs.mu.oz.au/~gjd/haskellchr/ Haskell CHR]
 
;[http://www.cs.mu.oz.au/~gjd/haskellchr/ Haskell CHR]
 
:A concurrent committed-choice constraint logic programming language, implemented using GHC's software transactional memory. According to the site referenced by the above-mentioned link, "It also contains an implementation of WAM for Haskell, so Prolog-style terms with variables are now possible."
 
:A concurrent committed-choice constraint logic programming language, implemented using GHC's software transactional memory. According to the site referenced by the above-mentioned link, "It also contains an implementation of WAM for Haskell, so Prolog-style terms with variables are now possible."
Line 62: Line 69:
 
;[http://taichi.ddns.comp.nus.edu.sg/taichiwiki/CCHR CCHR: STM-based CHR implementation by Lam and Sulzmann]
 
;[http://taichi.ddns.comp.nus.edu.sg/taichiwiki/CCHR CCHR: STM-based CHR implementation by Lam and Sulzmann]
 
:According to the site referenced by the above-mentioned link, "CCHR is an experimental concurrent implementation of Constraint Handling Rules, designed to exploit concurrency and parallelism explicitly. CCHR is implemented in Haskell, with software transactional memory to manage synchronization of multiple solver threads working on the same problem. Constraint Handling Rules (CHR) is a concurrent committed choice constraint logic programming language to describe transformations (rewritings) among multi-sets of constraints (atomic formulae). CHR naturally support concurrent programming. Conjunction of constraints can be regarded as interacting collections of multiple asynchronous agents or processes. Their interaction is specified via transformation rules which can be applied simultaneously if the transformation rules do not interfere. Hence, one would expect to run CHR faster by executing transformation rules in parallel on a multi-core machine architecture. CCHR exactly allows such concurrency while solving CHR problems and exhibits significant speed up in most problems when executed on multi-core systems."
 
:According to the site referenced by the above-mentioned link, "CCHR is an experimental concurrent implementation of Constraint Handling Rules, designed to exploit concurrency and parallelism explicitly. CCHR is implemented in Haskell, with software transactional memory to manage synchronization of multiple solver threads working on the same problem. Constraint Handling Rules (CHR) is a concurrent committed choice constraint logic programming language to describe transformations (rewritings) among multi-sets of constraints (atomic formulae). CHR naturally support concurrent programming. Conjunction of constraints can be regarded as interacting collections of multiple asynchronous agents or processes. Their interaction is specified via transformation rules which can be applied simultaneously if the transformation rules do not interfere. Hence, one would expect to run CHR faster by executing transformation rules in parallel on a multi-core machine architecture. CCHR exactly allows such concurrency while solving CHR problems and exhibits significant speed up in most problems when executed on multi-core systems."
  +
  +
  +
=== Elm ===
  +
  +
;[http://elm-lang.org/ Elm]
  +
:The Elm programming language aims to make web development more pleasant. Elm is a type-safe, functional reactive language that compiles to HTML, CSS, and JavaScript.
  +
  +
  +
===BASIC===
  +
  +
;[http://hackage.haskell.org/package/BASIC BASIC]
  +
:A simplified version of the original BASIC embedded in Haskell.
  +
   
 
===Liskell===
 
===Liskell===
  +
 
;[http://liskell.org Liskell]
 
;[http://liskell.org Liskell]
 
:Liskell is Haskell on the inside but looks like Lisp on the outside
 
:Liskell is Haskell on the inside but looks like Lisp on the outside
  +
   
 
===Perl===
 
===Perl===
Line 71: Line 93:
 
;[http://pugscode.org Pugs]
 
;[http://pugscode.org Pugs]
 
:Pugs is an implementation of Perl 6, written in Haskell. It aims to implement the full Perl6 specification.
 
:Pugs is an implementation of Perl 6, written in Haskell. It aims to implement the full Perl6 specification.
  +
   
 
===Python===
 
===Python===
Line 79: Line 102:
 
;[http://code.google.com/p/haspy/ haspy]
 
;[http://code.google.com/p/haspy/ haspy]
 
:Haspy is an implementation of Python in Haskell
 
:Haspy is an implementation of Python in Haskell
  +
   
 
===Ruby===
 
===Ruby===
Line 84: Line 108:
 
;[http://raa.ruby-lang.org/project/rtype/ RType]
 
;[http://raa.ruby-lang.org/project/rtype/ RType]
 
:RType is a Ruby interpreter written in Haskell
 
:RType is a Ruby interpreter written in Haskell
  +
   
 
===Flapjax===
 
===Flapjax===
 
;[http://www.flapjax-lang.org/ Flapjax]
 
;[http://www.flapjax-lang.org/ Flapjax]
 
:Flapjax is a language for functional reactive programming of AJAX web applications, whose compiler ([http://www.flapjax-lang.org/download/flapjax-source.tar.gz source]) is written in Haskell.
 
:Flapjax is a language for functional reactive programming of AJAX web applications, whose compiler ([http://www.flapjax-lang.org/download/flapjax-source.tar.gz source]) is written in Haskell.
  +
   
 
===Scheme===
 
===Scheme===
Line 95: Line 121:
   
 
;[http://www.korgwal.com/haskeem/ A Scheme in Haskell]
 
;[http://www.korgwal.com/haskeem/ A Scheme in Haskell]
  +
   
 
===Lisp===
 
===Lisp===
Line 100: Line 127:
 
;[http://www.defmacro.org/ramblings/lisp-in-haskell.html A Lisp Interpreter In Haskell]
 
;[http://www.defmacro.org/ramblings/lisp-in-haskell.html A Lisp Interpreter In Haskell]
 
:A small lisp interpreter written in Haskell
 
:A small lisp interpreter written in Haskell
  +
   
 
=== Emacs Lisp ===
 
=== Emacs Lisp ===
  +
 
;[http://www.codersbase.com/index.php/helisp Helisp]
 
;[http://www.codersbase.com/index.php/helisp Helisp]
 
:The beginnings of an Emacs lisp compiler/interpreter.
 
:The beginnings of an Emacs lisp compiler/interpreter.
  +
   
 
===Epigram===
 
===Epigram===
Line 109: Line 139:
 
;[http://www.e-pig.org/ Epigram]
 
;[http://www.e-pig.org/ Epigram]
 
:Epigram is a prototype dependently typed functional programming language
 
:Epigram is a prototype dependently typed functional programming language
  +
   
 
===Curry===
 
===Curry===
Line 114: Line 145:
 
;[http://danae.uni-muenster.de/~lux/curry/ The M&uuml;nster Curry Compiler]
 
;[http://danae.uni-muenster.de/~lux/curry/ The M&uuml;nster Curry Compiler]
 
:A native code compiler for the declarative multi-paradigm language Curry, written in Haskell
 
:A native code compiler for the declarative multi-paradigm language Curry, written in Haskell
  +
   
 
===Bluespec===
 
===Bluespec===
 
;[http://www.bluespec.com Bluespec]
 
;[http://www.bluespec.com Bluespec]
 
:A compiler for a hardware description language translating a Haskell-like (but with System Verilog syntax these days) language to Verilog.
 
:A compiler for a hardware description language translating a Haskell-like (but with System Verilog syntax these days) language to Verilog.
  +
   
 
===Cayenne===
 
===Cayenne===
;[http://www.dependent-types.org/ Cayenne]
+
  +
;[http://www.augustsson.net/Darcs/Cayenne/html/ Cayenne]
 
:A compiler for a Haskell-like language with dependent types.
 
:A compiler for a Haskell-like language with dependent types.
  +
   
 
===Agda===
 
===Agda===
  +
 
;[http://wiki.portal.chalmers.se/agda/pmwiki.php Agda]
 
;[http://wiki.portal.chalmers.se/agda/pmwiki.php Agda]
 
:A Cayenne-like programming language and proof assistant.
 
:A Cayenne-like programming language and proof assistant.
  +
   
 
===PolyP===
 
===PolyP===
  +
 
;[http://www.cs.chalmers.se/~patrikj/poly/polyp/ PolyP]
 
;[http://www.cs.chalmers.se/~patrikj/poly/polyp/ PolyP]
 
:A polytypic programming language
 
:A polytypic programming language
  +
   
 
===Forth===
 
===Forth===
Line 135: Line 173:
 
;[http://feather.perl6.nl/~nothingmuch/harrorth/ Harrorth]
 
;[http://feather.perl6.nl/~nothingmuch/harrorth/ Harrorth]
 
:Harrorth, a Forth interpreter
 
:Harrorth, a Forth interpreter
  +
   
 
===Eiffel===
 
===Eiffel===
Line 140: Line 179:
 
;[http://eiffelsoftware.origo.ethz.ch/index.php/DynBindModelHaskell Dynamic binding in Eiffel]
 
;[http://eiffelsoftware.origo.ethz.ch/index.php/DynBindModelHaskell Dynamic binding in Eiffel]
 
:A model of dynamic binding in ECMA Eiffel, in Haskell
 
:A model of dynamic binding in ECMA Eiffel, in Haskell
  +
   
 
===Crouton===
 
===Crouton===
Line 145: Line 185:
 
;[http://crouton.sourceforge.net/ Crouton]
 
;[http://crouton.sourceforge.net/ Crouton]
 
:Crouton is a small but fairly complete functional programming language for querying and transforming parsed manuscripts, such as the PPCME. It is intended as an alternative to Corpus Search, based on a different philosophy. It is written in (and largely based on) the very nice functional programming language Haskell using the Parsec library
 
:Crouton is a small but fairly complete functional programming language for querying and transforming parsed manuscripts, such as the PPCME. It is intended as an alternative to Corpus Search, based on a different philosophy. It is written in (and largely based on) the very nice functional programming language Haskell using the Parsec library
  +
   
 
=== JavaScript ===
 
=== JavaScript ===
  +
 
;[http://www.haskell.org/haskellwiki/Libraries_and_tools/HJS HJS]
 
;[http://www.haskell.org/haskellwiki/Libraries_and_tools/HJS HJS]
 
:HJS is a JavaScript parser written in Haskell. Available from HackageDB.
 
:HJS is a JavaScript parser written in Haskell. Available from HackageDB.
  +
   
 
===TCL===
 
===TCL===
  +
 
;[http://code.google.com/p/hiccup/ Hiccup]
 
;[http://code.google.com/p/hiccup/ Hiccup]
 
:Hiccup is a minimalistic TCL interpreter. It tries to be relatively simple, relatively efficient, and mostly correct.
 
:Hiccup is a minimalistic TCL interpreter. It tries to be relatively simple, relatively efficient, and mostly correct.
  +
   
 
===Smalltalk===
 
===Smalltalk===
Line 158: Line 203:
 
;[http://code.google.com/p/hst/ hst]
 
;[http://code.google.com/p/hst/ hst]
 
:HST is a Smalltalk implementation in Haskell. [http://lstephen.wordpress.com/2007/07/23/completing-the-spike/ See here for more information]
 
:HST is a Smalltalk implementation in Haskell. [http://lstephen.wordpress.com/2007/07/23/completing-the-spike/ See here for more information]
  +
   
 
=== Disciple ===
 
=== Disciple ===
  +
 
;[[DDC]]
 
;[[DDC]]
 
:Disciple is an explicitly lazy dialect of Haskell which supports destructive update, computational effects, type directed field projections and some other useful things.
 
:Disciple is an explicitly lazy dialect of Haskell which supports destructive update, computational effects, type directed field projections and some other useful things.
  +
   
 
=== Timber ===
 
=== Timber ===
  +
 
;[http://timber-lang.org/Timber Timber]
 
;[http://timber-lang.org/Timber Timber]
 
:Timber is a modern language for building event-driven systems, based around the notion of reactive objects. It is also a purely functional language derived from Haskell, although with a strict evaluation semantics. The Timber compiler currently runs on Linux and MacOS X platforms, but uses gcc as its back-end so it should be easily portable to most POSIX-like environments.
 
:Timber is a modern language for building event-driven systems, based around the notion of reactive objects. It is also a purely functional language derived from Haskell, although with a strict evaluation semantics. The Timber compiler currently runs on Linux and MacOS X platforms, but uses gcc as its back-end so it should be easily portable to most POSIX-like environments.
 
 
   
 
==Small languages==
 
==Small languages==

Latest revision as of 09:47, 30 August 2012

Haskell, with its support for pattern matching on data structures, generic structure traversals, and expressive type system, is popular for implementing compilers and interpreters. Here's a selection of compilers and interpreters implemented in Haskell.

Contents

[edit] 1 Large languages

[edit] 1.1 Haskell

GHC
GHC, The Glasgow Haskell Compiler, is written in Haskell
Yhc
Yhc, The York Haskell Compiler, is written in Haskell
Jhc
Jhc is a Haskell compiler which aims to produce the most efficient programs possible via whole program analysis
nhc98
A compiler for Haskell 98, written in Haskell
Ehc
The purpose of the EHC project is to provide a description of a Haskell compiler which is as understandable as possible so it can be used for education as well as research.
UHC
UHC is the Utrecht Haskell Compiler. UHC supports almost all Haskell 98 features plus experimental extensions. The compiler runs under Mac OS X, Windows (Cygwin), and various Unix flavors.
pH
A parallel version of Haskell from MIT.


[edit] 1.1.1 Helium

Helium
A Haskell subset for educational purposes


[edit] 1.1.2 Generic Haskell

Generic Haskell
An extension of Haskell that supports generic programming


[edit] 1.1.3 Data Field Haskell

Data Field Haskell
A dialect of the functional programming language Haskell that provides an instance of data fields


[edit] 1.1.4 Eden

Eden
A Haskell dialect for parallel programming


[edit] 1.1.5 Chameleon

Chameleon
A Haskell-style language which implements the ideas described in a ``A Theory of Overloading``


[edit] 1.1.6 CHR (Constraint Handling Rules)

Haskell CHR
A concurrent committed-choice constraint logic programming language, implemented using GHC's software transactional memory. According to the site referenced by the above-mentioned link, "It also contains an implementation of WAM for Haskell, so Prolog-style terms with variables are now possible."
STM-based CHR implementation, by Michael Stahl (gzipped TAR file)
CCHR: STM-based CHR implementation by Lam and Sulzmann
According to the site referenced by the above-mentioned link, "CCHR is an experimental concurrent implementation of Constraint Handling Rules, designed to exploit concurrency and parallelism explicitly. CCHR is implemented in Haskell, with software transactional memory to manage synchronization of multiple solver threads working on the same problem. Constraint Handling Rules (CHR) is a concurrent committed choice constraint logic programming language to describe transformations (rewritings) among multi-sets of constraints (atomic formulae). CHR naturally support concurrent programming. Conjunction of constraints can be regarded as interacting collections of multiple asynchronous agents or processes. Their interaction is specified via transformation rules which can be applied simultaneously if the transformation rules do not interfere. Hence, one would expect to run CHR faster by executing transformation rules in parallel on a multi-core machine architecture. CCHR exactly allows such concurrency while solving CHR problems and exhibits significant speed up in most problems when executed on multi-core systems."


[edit] 1.2 Elm

Elm
The Elm programming language aims to make web development more pleasant. Elm is a type-safe, functional reactive language that compiles to HTML, CSS, and JavaScript.


[edit] 1.3 BASIC

BASIC
A simplified version of the original BASIC embedded in Haskell.


[edit] 1.4 Liskell

Liskell
Liskell is Haskell on the inside but looks like Lisp on the outside


[edit] 1.5 Perl

Pugs
Pugs is an implementation of Perl 6, written in Haskell. It aims to implement the full Perl6 specification.


[edit] 1.6 Python

Berp
Berp is an implementation of Python 3 in Haskell.
haspy
Haspy is an implementation of Python in Haskell


[edit] 1.7 Ruby

RType
RType is a Ruby interpreter written in Haskell


[edit] 1.8 Flapjax

Flapjax
Flapjax is a language for functional reactive programming of AJAX web applications, whose compiler (source) is written in Haskell.


[edit] 1.9 Scheme

Write Yourself a Scheme in 48 Hours
A small Scheme interpreter
A Scheme in Haskell


[edit] 1.10 Lisp

A Lisp Interpreter In Haskell
A small lisp interpreter written in Haskell


[edit] 1.11 Emacs Lisp

Helisp
The beginnings of an Emacs lisp compiler/interpreter.


[edit] 1.12 Epigram

Epigram
Epigram is a prototype dependently typed functional programming language


[edit] 1.13 Curry

The Münster Curry Compiler
A native code compiler for the declarative multi-paradigm language Curry, written in Haskell


[edit] 1.14 Bluespec

Bluespec
A compiler for a hardware description language translating a Haskell-like (but with System Verilog syntax these days) language to Verilog.


[edit] 1.15 Cayenne

Cayenne
A compiler for a Haskell-like language with dependent types.


[edit] 1.16 Agda

Agda
A Cayenne-like programming language and proof assistant.


[edit] 1.17 PolyP

PolyP
A polytypic programming language


[edit] 1.18 Forth

Harrorth
Harrorth, a Forth interpreter


[edit] 1.19 Eiffel

Dynamic binding in Eiffel
A model of dynamic binding in ECMA Eiffel, in Haskell


[edit] 1.20 Crouton

Crouton
Crouton is a small but fairly complete functional programming language for querying and transforming parsed manuscripts, such as the PPCME. It is intended as an alternative to Corpus Search, based on a different philosophy. It is written in (and largely based on) the very nice functional programming language Haskell using the Parsec library


[edit] 1.21 JavaScript

HJS
HJS is a JavaScript parser written in Haskell. Available from HackageDB.


[edit] 1.22 TCL

Hiccup
Hiccup is a minimalistic TCL interpreter. It tries to be relatively simple, relatively efficient, and mostly correct.


[edit] 1.23 Smalltalk

hst
HST is a Smalltalk implementation in Haskell. See here for more information


[edit] 1.24 Disciple

DDC
Disciple is an explicitly lazy dialect of Haskell which supports destructive update, computational effects, type directed field projections and some other useful things.


[edit] 1.25 Timber

Timber
Timber is a modern language for building event-driven systems, based around the notion of reactive objects. It is also a purely functional language derived from Haskell, although with a strict evaluation semantics. The Timber compiler currently runs on Linux and MacOS X platforms, but uses gcc as its back-end so it should be easily portable to most POSIX-like environments.

[edit] 2 Small languages

[edit] 2.1 Baskell

Baskell
An interpreter for a small functional programming language. Supports strict and non-strict evaluation, and type inference. Useful for teaching purposes.

[edit] 2.2 LambdaPi

LambdaPi
LambdaPi, An Implementation of a Dependently Typed Lambda Calculus

[edit] 2.3 Unlambda

Unlambda.hs
An implementation of Unlambda in Haskell

[edit] 2.4 BF

BF.hs
An implementation of BF in Haskell


[edit] 2.5 Lambda calculus

4 lambda calculus implementations
With code, by Lennart Augustsson.
LMEngine
An implementation of the untyped lambda calculus

[edit] 2.6 QML, a functional quantum programming language

QML: A Functional Quantum Programming Language project
It is implemented in Haskell.
For online material on quantum computing in general, see Quantum Computation course held by John Preskill.

[edit] 2.7 HQL - HHM's Quantified Lambda

Hernan's Quantified Lambda
a small functional language, whose expressions can involve the use of quantifier operators

[edit] 2.8 Atom

Atom
Atom is a small HDL that compiles conditional term rewriting systems down to Verilog RTL.

[edit] 2.9 Feldspar

Feldspar
Feldspar (Functional Embedded Language for DSP and PARallelism) is an embedded DSL for describing digital signal processing algorithms developed at Ericsson.

[edit] 2.10 AL (Assignment Language)

It is used for teaching purposes in at the Technical University of Vienna.
An interpreter implemented in Haskell is described in ALI - an AL Interpreter implemented in Haskell written by Peter Robinson.

[edit] 2.11 Whitespace

Whitespace
A language that uses whitespace characters as language elements and ignores all non-whitespace characters

[edit] 2.12 LIPL

LIPL
An interpreter for a tiny functional programming language. It features Hindley-Milner style type inference.

[edit] 2.13 Ministg

Ministg
An interpreter for a high-level, small-step, operational semantics for the STG machine. Features execution tracing, rendered in HTML. Useful for studying the behaviour of the STG machine and experimenting with extensions to the machine. Also useful for studying program language implementation.

[edit] 2.14 Constantinople

Constantinople
A compiler for the Constantinople esolang. There are two datatypes, the list, and the bit, which can either be 0 or 1. Lists are infinite and lazily evaluated.

[edit] 3 Embedded languages

[edit] 3.1 ForSyDe

The ForSyDe (Formal System Design) methodology has been developed with the objective to move system-on-chip design to a higher level of abstraction. ForSyDe is implemented as a Haskell-embedded behavioral DSL.

[edit] 4 Debuggers

Debussy
A declarative debugger for OBJ-like languages
See also Debugging.

This page contains a list of libraries and tools in a certain category. For a comprehensive list of such pages, see Libraries and tools.