|
|
| Home > Programming > |
comp.lang.functional Frequently Asked Questions (monthly posting) |
Section 2 of 2 - Prev - Next
relevant literature and internet resources. The table below classifies the
languages into strict/non-strict and sequential/concurrent, and may be
useful when searching for suitable languages for particular applications.
Some of the languages have multiple versions with different classifications
(see the language overviews for further details), but for simplicity only
the most common version of each language is considered in the table.
Sequential: Concurrent:
Strict: ASpecT Erlang
Caml NESL
FP Oz
J Pizza
Mercury Sisal
ML
OPAL
Scheme
Non-strict: Gofer Clean
Haskell Id
Hope
Hugs
Miranda
----------------------------------------------------------------------------
5.1. ASpecT
ASpecT is a strict functional language, developed at the University of
Bremen, originally intended as an attempt to provide an implementation for
(a subset of) Algebraic Specifications of Abstract Datatypes. The system was
designed to be as user-friendly as possible, including overloading
facilities and a source-level debugger. For reasons of efficiency, the
system uses call-by-value evaluation and reference counting memory
management.
Over the years more and more features have been added, including subsorting,
functionals, and restricted polymorphism. The ASpecT compiler translates the
functional source code to C, resulting in fast and efficient binaries.
ASpecT has been ported to many different platforms, including Sun3, Sun4,
Dec VAX, IBM RS6000, NeXT, Apple A/UX, PC (OS/2, Linux), Amiga and Atari
ST/TT. The ASpecT compiler is available by ftp from:
Host: ftp.Uni-Bremen.DE;
Directory: /pub/programming/languages/ASpecT.
The most important application of ASpecT to date is the interactive graph
visualization system daVinci; currently (September '96), version 2.0.x is
composed of 34.000 lines of ASpecT code, 12.000 lines of C code and 8000
lines of Tcl/Tk code. daVinci is an X11 program, and is available for UNIX
workstations from Sun, HP, IBM, DEC, SGI, and for Intel PCs with a UNIX
operating system. Further information about daVinci is available on the web
from:
http://www.Informatik.Uni-Bremen.DE/~davinci.
----------------------------------------------------------------------------
5.2. Caml
Caml is a dialect of the ML language developed at INRIA that does not comply
to the Standard, but actually tries to go beyond the Standard, in particular
in the areas of separate compilation, modules, and objects. Two
implementations of Caml are available:
* The older implementation, Caml Light, is distinguished by its small
size, modest memory requirements, availability on microcomputers,
simple separate compilation, interface with C, and portable graphics
functions. It runs on most Unix machines, on the Macintosh and on PCs
under Ms Windows and MSDOS. The current version at the time of writing
is 0.71.
* A more ambitious implementation, Objective Caml (formerly known as Caml
Special Light), is also available. It adds the following extensions to
Caml Light:
o Full support for objects and classes, here combined for the first
time with ML-style type reconstruction;
o A powerful module calculus in the style of Standard ML, but
providing better support for separate compilation;
o A high-performance native code compiler, in addition to a Caml
Light-style bytecode compiler.
Objective Caml is available for Unix and Windows 95/NT, with the
native-code compiler supporting the following processors: Alpha, Sparc,
Pentium, Mips, Power, HPPA.
Both implementations of Caml are available by ftp from:
Host: ftp.inria.fr;
Directory: /lang/caml-light.
Further information about Caml is available on the web from:
http://pauillac.inria.fr/caml/index-eng.html (English);
http://pauillac.inria.fr/caml/index-fra.html (French).
----------------------------------------------------------------------------
5.3. Clean
The Concurrent Clean system is a programming environment for the functional
language Concurrent Clean, developed at the University of Nijmegen in The
Netherlands. The system is one of the fastest implementations of functional
languages available at the time of writing. Through the use of uniqueness
typing, it is possible to write purely functional interactive programs,
including windows, menus, dialogs, etc. It is also possible to develop
real-life applications that interface with non-functional systems. With
version 1.0, the language emerged from an intermediate language to a proper
programming language. Features provided by the language include:
* Lazy evaluation;
* Modern input/output;
* Annotations for parallelism;
* Automatic strictness analysis;
* Annotations for evaluation order;
* Inferred polymorphic uniqueness types;
* Records, mutable arrays, module structure;
* Existential types, type classes, constructor classes;
* Strong typing, based on the Milner/Mycroft scheme.
Concurrent Clean is available for Machintoshs (Motorola, PowerPC), PCs (OS2,
Linux), and Sun4s (Solaris, SunOS). The system is available by ftp from:
Host: ftp.cs.kun.nl;
Directory: /pub/Clean.
Further information about Concurrent Clean is available on the web from:
http://www.cs.kun.nl/~clean.
A book describing the background and implementation of Concurrent Clean is
also available:
* "Functional programming and parallel graph rewriting", Rinus Plasmeijer
and Marko van Eekelen, Addison Wesley, International Computer Science
Series. ISBN 0-201-41663-8
----------------------------------------------------------------------------
5.4. Erlang
Erlang is a dynamically typed concurrent functional programming language for
large industrial real-time systems. Features of Erlang include:
* Modules;
* Recursion equations;
* Explicit concurrency;
* Pattern matching syntax;
* Dynamic code replacement;
* Foreign language interface;
* Real-time garbage collection;
* Asynchronous message passing;
* Relative freedom from side effects;
* Transparent cross-platform distribution;
* Primitives for detecting run-time errors.
Erlang is freely available on the web from:
http://www.erlang.org.
Erlang is distributed together with full source code for a number of
applications, including:
* Inets - HTTP 1.0 server and FTP client;
* Orber - CORBA v2.0 Object Request Broker (ORB);
* ASN.1 - compile-time and runtime package for ASN.1;
* SNMP - extensible SNMP v1/v2 agent and MIB compiler;
* Mnesia - distributed real-time database for Erlang;
* Mnemosyne - optional query language for Mnesia.
See also:
* "Concurrent programming in Erlang" (second edition), J. Armstrong, M.
Williams, R. Virding, and Claes Wikström, Prentice Hall, 1996. ISBN
0-13-508301-X.
----------------------------------------------------------------------------
5.5. FP
FP is a side-effect free, combinator style language, described in:
* "Can programming be liberated from the von Neumann style?", John
Backus, Communications of the ACM, 21, 8, pp.613-641, 1978.
A interpreter and a compiler (to C) for FP are available by ftp from:
Host: gatekeeper.dec.com;
Directory: pub/usenet/comp.sources.unix/volume13/funcproglang;
Directory: pub/usenet/comp.sources.unix/volume20/fpc.
The Illinois FP system supports a modified version of FP that has a more
Algol-like syntax and structure, and is described in the following article:
* "The Illinois functional programming interpreter", Arch D. Robison,
Proceedings of the SIGPLAN '87 Symposium on Interpreters and
Interpretive Techniques, SIGPLAN notices, Volume 22, Number 7, July
1987.
----------------------------------------------------------------------------
5.6. Gofer
The Gofer system provides an interpreter for a small language based closely
on the current version of the Haskell report. In particular, Gofer supports
lazy evaluation, higher-order functions, polymorphic typing,
pattern-matching, support for overloading, etc.
The most recent version of Gofer, 2.30a, is available by ftp from:
Host: ftp.cs.nott.ac.uk;
Directory: /nott-fp/languages/gofer.
Gofer runs on a wide range of machines including PCs, Ataris, Amigas, etc.
as well as larger Unix-based systems. A version for the Apple Macintosh is
also available, by ftp from:
Host: ftp.dcs.glasgow.ac.uk;
Directory: /pub/haskell/gofer/macgofer.
Please note the spelling of Gofer, derived from the notion that functional
languages are GO(od) F(or) E(quational) R(easoning). This is not to be
confused with `Gopher', the widely used internet distributed information
delivery system.
----------------------------------------------------------------------------
5.7. Haskell
In the mid-1980s, there was no "standard" non-strict, purely-functional
programming language. A language-design committee was set up in 1987, and
the Haskell language is the result. At the time of writing, version 1.4 is
the latest version of the language. Further information about Haskell,
including the latest version of the Haskell report, is available on the web
from:
http://www.haskell.org/;
http://www-i2.informatik.rwth-aachen.de/Forschung/FP/Haskell/.
At the time of writing, there are three different Haskell systems available,
developed by groups at Chalmers, Glasgow and Yale. These systems are
available by ftp from the following sites:
Host: ftp.cs.chalmers.se;
Directory: /pub/haskell.
Host: ftp.dcs.glasgow.ac.uk;
Directory: /pub/haskell.
Host: haskell.cs.yale.edu;
Directory: /pub/haskell.
Host: ftp.cs.nott.ac.uk;
Directory: /haskell.
Host: src.doc.ic.ac.uk;
Directory: /pub/computing/programming/languages/haskell.
You can join the Haskell mailing list by emailing majordomo@dcs.gla.ac.uk,
with a message body of the form: subscribe haskell Forename Surname
.
----------------------------------------------------------------------------
5.8. Hope
Hope is a small polymorphically-typed functional language, and was the first
language to use call-by-pattern. Hope was originally strict, but there are
versions with lazy lists, or with lazy constructors but strict functions.
Further information is available on the web from:
http://www.unl.ac.uk/~rpaterson/Hope/.
----------------------------------------------------------------------------
5.9. Hugs
Hugs, the Haskell User's Gofer System, is an interpreted implementation of
Haskell with an interactive development environment much like that of Gofer.
At the time of writing, the latest release of Hugs is largely conformant
with Haskell 1.4, including monad and record syntax, newtypes, strictness
annotations, and modules. In addition, it comes packaged with the libraries
defined in the most recent version of the Haskell library report.
Further information about Hugs is available on the web from:
http://www.cs.nott.ac.uk/Department/Staff/mpj/hugs.html
or by ftp from:
Host: ftp.cs.nott.ac.uk;
Directory: /haskell/hugs.
----------------------------------------------------------------------------
5.10. Id
Id is a dataflow programming language, whose core is a non-strict functional
language with implicit parallelism. It has the usual features of many modern
functional programming languages, including a Hindley/Milner type inference
system, algebraic types and definitions with clauses and pattern matching,
and list comprehensions.
----------------------------------------------------------------------------
5.11. J
J was designed and developed by Ken Iverson and Roger Hui. It is similar to
the language APL, departing from APL in using using the ASCII alphabet
exclusively, but employing a spelling scheme that retains the advantages of
the special alphabet required by APL. It has added features and control
structures that extend its power beyond standard APL. Although it can be
used as a conventional procedural programming language, it can also be used
as a pure functional programming language. Further information about J is
available on the web from:
http://www.jsoftware.com.
----------------------------------------------------------------------------
5.12. Miranda(TM)
Miranda was designed in 1985-6 by David Turner with the aim of providing a
standard non-strict purely functional language, and is described in the
following articles:
* "Miranda: a non-strict functional language with polymorphic types",
D.A. Turner, Proceedings FPLCA, Nancy, France, September 1985 (Springer
LNCS vol 201, pp 1-16).
* "An overview of Miranda", D.A. Turner, SIGPLAN Notices, vol 21, no 12,
pp 158-166, December 1986.
Miranda was the first widely disseminated language with non-strict semantics
and polymorphic strong typing, and is running at over 600 sites, including
250 universities. It is widely used for teaching, often in conjunction with
"Introduction to Functional Programming", by Bird and Wadler, which uses a
notation closely based on Miranda. It has also had a strong influence on the
subsequent development of the field, and provided one of the main inputs for
the design of Haskell.
The Miranda system is a commercial product of Research Software Limited.
Miranda release two (the current version at the time of writing) supports
unbounded precision integers and has a module system with provision for
parameterized modules and a built in "make" facility. The compiler works in
conjunction with a screen editor and programs are automatically recompiled
after edits. There is also an online reference manual.
Further information about Miranda is available by email from:
mira-request@ukc.ac.uk
or by post from:
Research Software Ltd, 23 St Augustines Road, Canterbury CT1 1XP,
ENGLAND. Phone: (+44) 227 471844, fax: (+44) 227 454458.
Miranda was awarded a medal for technical achievement by the British
Computer Society (BCS Awards, 1990). Note that the word "Miranda" is a
trademark (TM) of Research Software Limited. There are no public domain
versions of Miranda.
----------------------------------------------------------------------------
5.13. Mercury
Mercury is a logic/functional programming language, which combines the
clarity and expressiveness of declarative programming with advanced static
analysis and error detection facilities. It has a strong type system, a
module system (allowing separate compilation), a mode system, algebraic data
types, parametric polymorphism, support for higher-order programming, and a
determinism system --- all of which are aimed at both reducing programming
errors and providing useful information for programmers and compilers.
The Mercury compiler is written in Mercury itself, and compiles to C. The
compiler is available for a variety of platforms running Unix and Microsoft
operating systems.
Further information about Mercury is available on the web from:
http://www.cs.mu.oz.au/mercury.
----------------------------------------------------------------------------
5.14. ML
ML stands for meta-language, and is a family of advanced programming
languages with (usually) functional control structures, strict semantics, a
strict polymorphic type system, and parameterized modules. It includes
Standard ML, Lazy ML, CAML, CAML Light, and various research languages.
Implementations are available on many platforms, including PCs, mainframes,
most models of workstation, multi-processors and supercomputers. ML has many
thousands of users, and is taught to undergraduates at many universities.
There is a moderated usenet newsgroup, comp.lang.ml, for discussion of
topics related to ML. A list of frequently asked questions for this
newsgroup (which includes pointers to many of the different implementations
and variants of ML) is available by ftp from:
Host: pop.cs.cmu.edu;
Directory: /usr/rowan/sml-archive/.
The Standard ML language is formally defined by:
* "The Definition of Standard ML - Revised", Robin Milner, Mads Tofte,
Robert Harper, and David MacQueen, MIT, 1997. ISBN 0-262-63181-4.
Further information is available on the web from:
http://mitpress.mit.edu/promotions/books/MILDPRF97.
* "Commentary on Standard ML", Robin Milner and Mads Tofte, MIT, 1990.
ISBN 0-262-63137-7. Further information is available on the web from:
http://mitpress.mit.edu/promotions/books/MILCPF90.
There is now a revised version of Standard ML, sometimes referred to as
"Standard ML '97" to distinguish it from the original 1990 version. The new
version combines modest changes in the language with a major revision and
expansion of the SML Basis Library. Further details about Standard ML '97
are available on the web from:
http://cm.bell-labs.com/cm/cs/what/smlnj/sml97.html.
----------------------------------------------------------------------------
5.15. NESL
NESL is a fine-grained, functional, nested data-parallel language, loosly
based on ML. It includes a built-in parallel data-type, sequences, and
parallel operations on sequences (the element type of a sequence can be any
type, not just scalars). It is based on eager evaluation, and supports
polymorphism, type inference and a limited use of higher-order functions.
Currently, it does not have support for modules and its datatype definition
is limited. Except for I/O and some system utilities it is purely functional
(it does not support reference cells or call/cc).
The NESL compiler is based on delayed compilation and compiles separate code
for each type a function is used with (compiled code is monomorphic). The
implementation therefore requires no type bits, and can do some important
data-layout optimizations (for example, double-precision floats do not need
to be boxed, and nested sequences can be laid out efficiently across
multiple processors.) For several small benchmark applications on irregular
and/or dynamic data (for example, graphs and sparse matrices) it generates
code comparable in efficiency to machine-specific low-level code (for
example, Fortran or C.)
The current implementation of NESL runs on workstations, the Connection
Machines CM2 and CM5, the Cray Y-MP and the MasPar MP2.
Further information about NESL is available on the web from:
http://www.cs.cmu.edu/afs/cs.cmu.edu/project/scandal/public/www/nesl.html
or by ftp from:
Host: nesl.scandal.cs.cmu.edu;
Directory: nesl.
You can join to the NESL mailing list by emailing nesl-request@cs.cmu.edu.
----------------------------------------------------------------------------
5.16. OPAL
The language OPAL has been designed as a testbed for the development of
functional programs. Opal molds concepts from Algebraic Specification and
Functional Programming, which shall favor the formal development of large
production-quality software that is written in a purely functional style.
The core of OPAL is a strongly typed, higher-order, strict applicative
language that belongs to the tradition of Hope and ML. The algebraic flavour
of OPAL shows up in the syntactical appearance and in the preference of
parameterization to polymorphism.
OPAL is used for research on the highly optimizing compilation of
applicative languages. This has resulted in a compiler which produces very
efficient code. The OPAL compiler itself is entirely written in OPAL.
Installation is straightforward and has been successfully performed for
SPARCs, DECstations, NeXTs, and PCs running LINUX.
Further information about OPAL is available by ftp from:
Host: ftp.cs.tu-berlin.de;
Directory: /pub/local/uebb/.
----------------------------------------------------------------------------
5.17. Oz
Oz is a concurrent constraint programming language designed for applications
that require complex symbolic computations, organization into multiple
agents, and soft real-time control. It is based on a new computation model
providing a uniform foundation for higher-order functional programming,
constraint logic programming, and concurrent objects with multiple
inheritance. From functional languages Oz inherits full compositionality,
and from logic languages Oz inherits logic variables and constraints
(including feature and finite domain constraints.) Search in Oz is
encapsulated (no backtracking) and includes one, best and all solution
strategies.
DFKI Oz is an interactive implementation of Oz featuring am Emacs
programming interface, a concurrent browser, an object-oriented interface to
Tcl/Tk, powerful interoperability features (sockets, C, C++), an incremental
compiler, a garbage collector, and support for stand-alone applications.
Performance is competitive with commercial Prolog and Lisp systems. DFKI Oz
is available for many platforms running Unix/X, including Sparcs and 486
PCs, and has been used for applications including simulations, multi-agent
systems, natural language processing, virtual reality, graphical user
interfaces, scheduling, placement problems, and configuration.
Further information about Oz is available on the web from:
http://www.ps.uni-sb.de/oz/
or by ftp from:
Host: ftp.ps.uni-sb.de;
Directory: /pub/oz.
Specific questions on Oz may be emailed oz@ps.uni-sb.de. You can join the Oz
users mailing list by emailing oz-users-request@ps.uni-sb.de.
----------------------------------------------------------------------------
5.18. Pizza
Pizza is a strict superset of Java that incorporates three ideas from
functional programming:
* Parametric polymorphism;
* Higher-order functions;
* Algebraic data types.
Pizza is defined by translation into Java and compiles into the Java Virtual
Machine, requirements which strongly constrain the design space. Thus Pizza
programs interface easily with Java libraries, and programs first developed
in Pizza may be automatically converted to Java for ease of maintenance. The
Pizza compiler is itself written in Pizza, and may be used as a replacement
for Sun's Java compiler (except that the Pizza compiler runs faster).
Pizza was designed by Martin Odersky and Philip Wadler, and implemented by
Odersky. The design is described in the following paper:
* "Pizza into Java: translating theory into practice", Martin Odersky and
Philip Wadler, 24th ACM Symposium on Principles of Programming
Languages, Paris, January 1997.
The paper, downloads, and other information on Pizza is available on the web
from any of the following locations (which mirror each other):
http://www.cis.unisa.edu.au/~pizza;
http://cm.bell-labs.com/cm/cs/who/wadler/pizza/welcome.html;
http://wwwipd.ira.uka.de/~pizza;
http://www.math.luc.edu/pizza/;
ftp://ftp.eecs.tulane.edu/pub/maraist/pizza/welcome.html.
Pizza has received a `cool' award from Gamelan ( http://www-c.gamelan.com/.)
----------------------------------------------------------------------------
5.19. Scheme
Scheme is a dialect of Lisp that stresses conceptual elegance and
simplicity. It is specified in R4RS and IEEE standard P1178. Scheme is much
smaller than Common Lisp; the specification is about 50 pages. Scheme is
often used in computer science curricula and programming language research,
due to its ability to simply represent many programming abstractions.
Further information about Scheme is available on the web from:
http://www-swiss.ai.mit.edu/scheme-home.html.
There is an unmoderated usenet newsgroup, comp.lang.scheme, for the
discussion of topics related to Scheme. A list of frequently asked questions
(which includes details of the many books and papers concerned with Scheme)
for this newsgroup is available by ftp from:
Host: ftp.think.com;
Directory: /public/think/lisp/.
----------------------------------------------------------------------------
5.20. Sisal
Sisal (Streams and Iteration in a Single Assignment Language) is a
functional language designed with several goals in mind: to support clear,
efficient expression of scientific programs; to free application programmers
from details irrelevant to their endeavors; and, to allow automatic
detection and exploitation of the parallelism expressed in source programs.
Sisal syntax is modern and easy to read; Sisal code looks similar to Pascal,
Modula, or Ada, with modern constructs and long identifiers. The major
difference between Sisal and more conventional languages is that it does not
express explicit program control flow.
Sisal semantics are mathematically sound. Programs consist of function
definitions and invocations. Functions have no side effects, taking as
inputs only explicitly passed arguments, and producing only explicitly
returned results. There is no concept of state in Sisal. Identifiers are
used, rather than variables, to denote values, rather than memory locations.
The Sisal language currently exists for several shared memory and vector
systems that run Berkeley Unix(tm), including the Sequent Balance and
Symmetry, the Alliant, the Cray X/MP and Y/MP, Cray 2, and a few other less
well-known ones. Sisal is available on sequential machines such as Sparc,
RS/6000, and HP. Sisal also runs under MS-DOS and Macintosh Unix (A/UX).
It's been shown to be fairly easy to port the entire language system to new
machines.
Further information about Sisal is available on the web from:
http://www.llnl.gov/sisal/SisalHomePage.html.
----------------------------------------------------------------------------
The original version of this Frequently Asked Questions list (FAQ) was
compiled and edited by Mark P. Jones. All questions, comments, corrections,
and suggestions regarding this document should be addressed to the current
editor, Graham Hutton (email: gmh@cs.nott.ac.uk.)
Section 2 of 2 - Prev - Next
| Back to category Programming - Use Smart Search |
| Home - Smart Search - About the project - Feedback |
© allanswers.org | Terms of use