Subject: comp.lang.functional Frequently Asked Questions (monthly posting)
From: [email-masked] (Mark P. Jones)
Date: Thu, 14 Apr 1994 17:32:41 GMT
Newsgroups: comp.lang.functional,comp.answers,news.answers

Archive-name: func-lang-faq
Last-modified: April 14, 1994

---------------------------------------------------------------------------
             A Frequently Asked Questions list (FAQ) for
                      comp.lang.functional
---------------------------------------------------------------------------
A copy of this FAQ is available by anonymous ftp from nebula.cs.yale.edu in
the file pub/comp.lang.functional/FAQ.
---------------------------------------------------------------------------
New this month:
 - Information about NESL
 - A new section in response to the recent threads on `purity and the FAQ'.

---------------------------------------------------------------------------
TABLE OF CONTENTS:

1) GENERAL QUESTIONS
   1.1) What is a functional language?
   1.2) Where can I find out more about the history and motivation
        for functional programming?
   1.3) Are there any books about functional programming?
   1.4) Where is a good place to look for information about current
        research in functional languages?
   1.5) What other newsgroups might be of interest to readers of
        comp.lang.functional?
   1.6) Is comp.lang.functional archived anywhere?

2) FREQUENT TOPICS OF DISCUSSION:
   2.1) What is a monad?
   2.2) How can I write a parser in a functional language?
   2.3) What does it mean to say that a language is strict/non-strict?
   2.4) What about the performance of functional programs?
   2.5) What is a purely functional language?
   2.6) Other subjects:

3) LANGUAGE IMPLEMENTATIONS:
   ASpecT, Caml Light, Clean, Erlang, FP, Gofer, Haskell, Hope, Id, IFP,
   J, Miranda(TM), ML, NESL, OPAL, Scheme and Sisal.

4) OTHER RESOURCES:
   4.1) Bibliographies:
   4.2) Translators:
   4.3) Online services:

5) CREDITS AND DISCLAIMERS:

---------------------------------------------------------------------------
1) GENERAL QUESTIONS:

Comp.lang.functional is an unmoderated usenet newsgroup for the
discussion of functional programming languages, including their
design, application, theoretical foundation and implementation.

---------
1.1) What is a functional language?

Opinions differ, even within the functional programming community,
on the precise definition of ``functional programming languages''.
Here is a definition that, broadly speaking, represents the kind of
languages that are discussed in this newsgroup:

  Functional programming is a style of programming that emphasizes
  the evaluation of expressions, rather than execution of commands.
  The expressions in these language are formed by using functions to
  combine basic values.

  A functional language is a language that supports and encourages
  programming in a functional style.

  For example, consider the task of calculating the sum of the
  integers from 1 to 10.  In an imperative language, this might be
  expressed using a loop, repeatedly updating the values held in
  counter and accumulator variables:

       total = 0;
       for (i=1; i<=10; ++i)
           total += i;

  In a functional language, the same program would be expressed
  without any variable updates.  For example, in Haskell or Miranda,
  the required sum can be calculated by evaluating the expression:

       sum [1..10].

  Here, [1..10] is an expression that represents the list of integers
  from 1 to 10, while sum is a function that can be used to calculate
  the sum of an arbitrary list of values.

  The same idea could also be used in strict languages like ML or
  Scheme, but it is more common to find such programs written with
  an explicit loop, often expressed as a form of recursion.
  Nevertheless, there is still no need to update the values of the
  variables involved.

  SML:    let fun sum i tot = if i=0 then tot else sum (i-1) (tot+i)
          in sum 10 0
          end

  Scheme: (define sum
             (lambda (from total)
                 (if (= 0 from)
                     total
                     (sum (- from 1) (+ total from)))))
          (sum 10 0)

  Of course, it is often possible to write programs in an imperative
  language using a functional style, and vice versa.  It is then
  a matter of opinion whether a particular language can be described
  as functional or not.

---------
1.2) Where can I find out more about the history and motivation
for functional programming?

Here are a couple of references that should help:

  "Conception, Evolution, and Application of Functional Programming
  Languages", Paul Hudak, ACM Computing Surveys, Volume 21, Number 3,
  pp.359--411, 1989.

  "Why functional programming matters", John Hughes, The Computer
  Journal, Volume 32, Number 2, April 1989.

---------
1.3) Are there any books about functional programming?

Yes, there are quite a few.  For details about programming in a
functional language:

  o  "Introduction to functional programming", Richard Bird and
     Philip Wadler, Prentice Hall, 1988.  ISBN 0-13-484189-1.

  o  "ML for the working programmer", L.C. Paulson, Cambridge
     University Press, 1991.  ISBN 0-521-39022-2.

And for those with an interest in implementation:

  o  "The implementation of functional programming languages",
     Simon Peyton Jones, Prentice Hall, 1987.  ISBN 0-13-453333-X.

  o  "Compiling with continuations", Andrew Appel, Cambridge
     University Press, 1992.  ISBN 0-521-41695-7.

For brevity, I've restricted myself to two books in each of the
above categories, one concerned with non-strict languages, the
other with strict languages.  There are several other good books
in each category.

The following article may also be of interest to those looking for
books about functional programming:

  o  Simon Thompson, Comparative review of functional programming
     textbooks (Bailey, Bird and Wadler, Holyer, Paulson, Reade,
     Sokoloski, Wikstrom), Computing Reviews, May 1992 (CR number
     9205-0262).

---------
1.4) Where is a good place to look for information about current
     research in functional languages?

Here are some good places to start:

Journals:
  o  The Journal of Functional Programming, published by CUP.
  o  Lisp and Symbolic Computation, published by Kluwer.

Conference proceedings:
  o  Lisp and Functional programming (LFP).
  o  Functional Programming Languages and Computer Architecture (FPCA).
  o  Principles of Programming Languages (POPL).
  o  European Symposium on Programming (ESOP).

  (Most of these are published by the ACM press, or in the Springer
  Verlag Lecture Notes in Computer Science Series).

---------
1.5) What other newsgroups might be of interest to readers of
comp.lang.functional?

There are several newsgroups dealing with related languages and
ideas, including:

    comp.lang.ml	for discussion related to ML
    comp.lang.scheme	for discussion about Scheme
    comp.lang.lisp	for discussion about Lisp
    comp.lang.apl	for discussion about APL, J, etc.

---------
1.6) Is comp.lang.functional archived anywhere?

No, as far as I know, there is no public archive of comp.lang.functional
(but, of course, many readers keep copies of old articles for their
personal use).  The possibility of establishing a public archive
has been raised a number of times in the past but have not been
pursued due to an apparent lack of interest, and concerns that
archiving might discourage novices from posting articles.

---------------------------------------------------------------------------
2) FREQUENT TOPICS OF DISCUSSION:

2.1) What is a monad?
---------------------
The concept of a monad comes from category theory; I'll spare you
the full details since you can find these in standard text books
on the subject.  Much of the recent interest in monads in functional
programming is the result of recent papers that show how monads
can be used to describe all kinds of different programming language
features -- for example, I/O, manipulation of state, continuations
and exceptions -- in purely functional languages like Haskell.

  o  Philip Wadler, Comprehending Monads (from the ACM conference
     on LISP & Functional Programming, Nice, France, 1990).

  o  Philip Wadler, The Essence of Functional Programming (from ACM
     Principles of Programming Languages 1992).

  o  Simon Peyton Jones and Philip Wadler, Imperative Functional
     Programming (from ACM Principles of Programming Languages 1993).

These papers are essential reading for anyone interested in the
use of monads for functional programming.  Copies of these papers
are currently available by anonymous ftp from ftp.dcs.glasgow.ac.uk
in the subdirectory pub/glasgow-fp/papers.

2.2) How can I write a parser in a functional language?
-------------------------------------------------------
A parser is a program that converts a list of input tokens, usually
characters, into a value of the appropriate type.  A simple example
might be a function to find the integer value represented by a
string of digits.  A more complex example might be to translate
programs written in a particular concrete syntax into a suitable
abstract syntax as the first stage in the implementation of a
compiler or interpreter.  There are two common ways to write a
parser in a functional language:

  o  Using a parser generator tool.  Some functional language
     implementations support tools that generate a parser automatically
     from a specification of the grammar (in much the same way that
     a C programmer uses yacc).  Different tools are available,
     depending on the language and implementation used.

  o  Using combinator parsing.  Parsers are represented by functions
     and combined with a small set of combinators, leading to
     parsers that closely resemble the grammar of the language
     being read.  Parsers written in this way can use backtracking.
     The techniques of combinator parsing have been known for quite
     some time.  Two comparatively recent papers on the subject are:

       -  "How to Replace Failure with a List of Successes",
          Philip Wadler, FPCA '85, Springer Verlag LNCS 201, 1985.

       -  "Higher-order functions for parsing", Graham Hutton,
	  Journal of Functional Programming, 2, 3, July 1992.

     The latter paper is also available by anonymous ftp from
     ftp.cs.chalmers.se in the file pub/cs-reports/papers/parsing.dvi
     and includes some references to other related papers.

2.3) What does it mean to say that a language is strict/non-strict?
--------------------------------------------------------------------
Here's one (operational) way to explain the difference:

In a strict language, the arguments to a function are always
evaluated before it is invoked.  As a result, if the evaluation of
an expression exp does not terminate properly (for example, because
it generates a run-time error or enters an infinite loop), then
neither will an expression of the form  f(exp).  ML and Scheme are
both examples of this.

In a non-strict language, the arguments to a function are not
evaluated until their values are actually required.  For example,
evaluating an expression of the form f(exp) may still terminate
properly, even if evaluation of exp would not, if the value of
the parameter is not used in the body of f.  Miranda and Haskell
are examples of this approach.

It is possible to support a mixture of these two approaches; some
versions of Hope do this.

2.4) What about the performance of functional programs?
-------------------------------------------------------
In some circles, programs written in functional languages, have
obtained a reputation for lack of performance.  Part of this results
from the high-level of abstraction that is common in such programs
and from powerful features like higher-order functions, automatic
storage management, etc.  Of course, the performance of functional
languages keeps improving with new developments in compiler
technology.

The paper below compares five current implementations of lazy
functional languages:

  ``Benchmarking implementations of lazy functional languages''
  P. H. Hartel and K. G. Langendoen FPCA 93, ACM, pp 341-349
  (By ftp: ftp.fwi.uva.nl, directory pub/functional).

Experiments with a heavily optimising compiler for Sisal, a strict
functional language, show that functional programs can be faster
than Fortran:

  ``Retire FORTRAN? A debate rekindled''
  D. C. Cann, CACM, 35(8), pp. 81-89, Aug. 1992

2.5) What is a purely functional language?
------------------------------------------
This question has been the subject of some debate in recent messages
posted to comp.lang.functional.  It is widely agreed that languages
like Haskell and Miranda are `purely functional', while SML and
Scheme are not.  However, there are some small differences of
opinion about the precise technical motivation for this distinction.
One definition that has been suggested is as follows:

  The term `purely functional language' is often used to describe
  languages which perform all their computations via function
  application.  This is in contrast to languages, like Scheme and
  Standard ML, which are predominantly functional but also allow
  `side effects' (computational effects caused by expression
  evaluation which persist after the evaluation is completed).

  Sometimes, the term `purely functional' is also used in a broader
  sense to mean languages which might incorporate computational
  effects, but without altering the notion of `function' (as
  evidenced by the fact that the essential properties of functions
  are preserved.)  Typically, the evaluation of an expression can
  yield a `task' which is then executed separately to cause
  computational effects.  The evaluation and execution phases are
  separated in such a way that the evaluation phase does not
  compromise the standard properties of expressions and functions.
  The input/output mechanisms of Haskell, for example, are of this
  kind.

2.6) Other subjects:
--------------------
There probably ought to be something here about programming with
GUIs (Fudgets, eXene, etc.), Input/Output, General Foundations
(basics of lambda calculus, perhaps?), and parallelism.  Anybody
want to write some brief comments addressing one/some of these?
(Some sections are already in preparation.)

---------------------------------------------------------------------------
3) LANGUAGE IMPLEMENTATIONS:

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.  Efficiency
		called for call-by-value evaluation and reference
		counting memory management.

		Over the years more and more features were added,
		including subsorting, functionals and restricted
		polymorphism. The ASpecT compiler translates the
		functional source code to C, resulting in fast and
		efficient binaries.

		The most important application of ASpecT to date
		is the interactive graph visualization system
		daVinci; currently (Oct '93), version 1.2 is composed
		of 23.000 lines of code. For more information please
		contact the project daVinci by e-mail:
		[email-masked]

		ASpecT is available by anonymous FTP from
		wowbagger.PC-Labor.Uni-Bremen.DE in the directory
		/pub/lang/ASpecT. ASpecT has been ported to many
,
		NeXT, Apple A/UX, PC (OS/2, Linux), Amiga and Atari
		ST/TT.

Caml Light:     Caml Light is an implementation of the ML language
		that does not comply to the Standard, but is
		distinguished by its small size, modest memory
		requirements, availability on microcomputers, simple
		separate compilation, interface with C, and portable
		graphics functions.

		Caml Light 0.6 runs on most Unix machines, on the
		Macintosh and on PCs under MSDOS.

		ftp: ftp.inria.fr, directory lang/caml-light

Clean:          The Concurrent Clean system is a programming
		environment for the functional language Concurrent
		Clean, developed at the University of Nijmegen,
		The Netherlands. The system is one of the fastest
		implementations of functional languages available
		at the moment. Its I/O libraries make it possible
		to do modern, yet purely functional I/O (including
		windows, menus, dialogs etc.) in Concurrent Clean.
		With the Concurrent Clean system it is possible to
		develop real-life applications in a purely functional
		language.  Particular features include:

		  o lazy and purely functional
		  o strongly typed - based on Milner/Mycroft scheme
		  o module structure
		  o modern I/O
		  o programmer-influenced evaluation order by
                    annotations

		ftp: host ftp.cs.kun.nl,  directory pub/Clean
		available for: Mac, Sun 3, Sun 4

		There is a book describing Concurrent Clean and
		its implementation on sequential and parallel
		architectures:

		"Functional Programming and Parallel Graph Rewriting",
		Rinus Plasmeijer and Marko van Eekelen,
		Addison Wesley, International Computer Science Series.
		Hardcover, 571 pages.
		ISBN 0-201-41663-8

Erlang:		Concurrent functional programming language for
		large industrial real-time systems. Untyped.
		Pattern matching syntax.  Recursion equations.
		Explicit concurrency, asynchronous message
		passing.  Relatively free from side effects.
		Transparent cross-platform distribution.  Primitives
		for detecting run-time errors.  Real-time GC.
		Modules.  Dynamic code replacement (change code
		in running real-time system, without stopping
		system).  Foreign language interface.

		Availability: Free version (subject to non-commercial
		license) with no support.  Commercial versions
		with support are available (Erlang Systems AB).

		Info: [email-masked]
		FTP Info: euagate.eua.ericsson.se:/pub/eua/erlang/info

		See also:
		"Concurrent Programming in Erlang", J. Armstrong,
		M. Williams & R. Virding, Prentice Hall, 1993.
		ISBN 13-285792-8.

FP:             Backus' side-effect free, combinator style language
		described by:

		"Can Programming be Liberated from the Von
		Neumann Style?", J. Backus, Communications of the
		ACM, 21, 8, pp.613-641, 1978.

		There are (at least) three easily accessible
		implementations of FP.  Two of these are available
		from any site that archives comp.sources.unix.
		For example, at gatekeeper.dec.com you will find
		these in:

		 pub/usenet/comp.sources.unix/volume13/funcproglang
		 pub/usenet/comp.sources.unix/volume20/fpc

		The first of these is an interpreter, the second a
		translator from FP to C.

		The third implementation, IFP is described separately
		below.

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.

		ftp: nebula.cs.yale.edu,  directory: pub/haskell/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 has been produced and is available by
		anonymous ftp from ftp.dcs.glasgow.ac.uk in a
		subdirectory of pub/haskell/gofer.

		Please note the spelling, derived from the notion
		that functional languages are GOod For Equational
		Reasoning.  This is not to be confused with `Gopher',
		the widely used Internet distributed information
		delivery system!

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.

		The Haskell committee released its report on 1
		April 1990. A revised "Version 1.2" appeared in
		SIGPLAN Notices 27(5) (May 1992), along with a
		tutorial on Haskell by Hudak and Fasel.

		At the time of writing, there are three different
		Haskell systems available, developed by groups at
		Chalmers, Glasgow and Yale (several others are
		being developed).  These systems are available
		from the following sites:
		   Chalmers	ftp.cs.chalmers.se
		   Glasgow	ftp.dcs.glasgow.ac.uk
		   Yale		nebula.cs.yale.edu
		At each site, all of the files related to Haskell
		are stored in the directory pub/haskell.  Specialized
		material, or recent releases of these systems may
		sometimes only be available from the systems ``home
		site''.  Machine-readable versions of the Haskell
		report, tutorials, and some programs are also
		available at these sites.

		A description of the current status of the various
		Haskell implementations is occasionally posted on
		the Haskell mailing list, and sometimes on
		comp.lang.functional.  Copies of this document are
		often kept on the Haskell sites mentioned above.
		For example, this information may be found in
		pub/haskell/papers/Haskell.status at the Yale site
		(nebula.cs.yale.edu).

Hope:		A small polymorphically-typed functional language.
		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.
		A fully lazy interpreter is available from:

		ftp: santos.doc.ic.ac.uk:/pub/papers/R.Paterson/hope.tar.Z

Id:             The core of Id is a non-strict functional language
		with implicit parallelism.  It has the usual features
		of many modern functional languages, including a
		Hindley/Milner type inference system, algebraic
		types and definitions with clauses and pattern
		matching, and list comprehensions.

IFP:            The Illinois FP system is a modified version of
		Backus' FP with a more Algol-like syntax and
		structure.  Described in:

		"The Illinois Functional Programming Interpreter",
		Arch D. Robison, Proceedings of the SIGPLAN '87
		Symposium on Interpreters and Interpretive Techniques,
		SIGPLAN notices vol 22, no 7, July 1987.

		ftp: a.cs.uiuc.edu.    versions for Unix and MSDOS

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.

		ftp: watserv1.waterloo.edu.

Miranda(TM):    Miranda was designed in 1985-6 by David Turner with
		the aim of providing a standard non-strict purely
		functional language.  It is described in D. A.
		Turner ``Miranda: A Non-Strict Functional Language
		with Polymorphic Types'', Proceedings FPLCA, Nancy,
		France, September 1985 (Springer LNCS vol 201, pp
		1-16) and D. A. Turner ``An Overview of  Miranda'',
		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 now running at over 600 sites,
		including 250 universities.  It is widely used for
		teaching, often in conjunction with "Introduction
		to Functional Programming", by Bird & 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 the later language
		Haskell (see separate entry).

		Miranda was awarded a medal for technical achievement
 Computer Society (BCS Awards, 1990).

		The Miranda system is a commercial product of
		Research Software Limited.  Miranda release two
		(the current version) 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 an online reference
		manual.

		Note that the word "Miranda" is a trademark (TM)
		of Research Software Limited.  There are no public
		domain versions of Miranda.

		Further information about Miranda may be obtained
		from
                   [email-masked]
                or
                   Research Software Ltd
                   23 St Augustines Road
                   Canterbury CT1 1XP       phone: (+44) 227 471844
                   ENGLAND                  fax:   (+44) 227 454458

ML:             ML (which stands for Meta-Language) 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, is taught at many universities
		(and is the first programming language taught at
		some).

		There is a moderated usenet newsgroup, comp.lang.ml,
		for the discussion of topics related to ML.  A list
		of frequently asked questions for ML is posted to
		this group each month by the moderator, Greg
		Morrisett.  The first paragraph above is taken
		directly from this FAQ.

		There are several implementations of ML including
		Poly/ML, SML/NJ, PoplogML, Edinburgh, ANU ML, Micro
		ML, sml2c, Caml Light, and the ML kit.  Further
		details for each of these systems are included in
		the comp.lang.ml FAQ.

		The Standard ML language is formally defined by:

		"The Definition of Standard ML", Robin Milner, Mads
		Tofte and Robert Harper, MIT, 1990.  ISBN:
		0-262-63132-6

		"Commentary on Standard ML", Robin Milner and Mads
		Tofte, MIT, 1991 ISBN: 0-262-63137-7

		There are a number of texts describing programming
		in ML.  Again, full details are given in the
		comp.lang.ml FAQ.

NESL:		NESL is a fine-grained, functional, nested
		data-parallel language.  The current implementation
		runs on workstations, the Connection Machines CM2
		and CM5, the Cray Y-MP and the MasPar MP2.

		NESL is loosely 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 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
		(e.g. double-precision floats don't 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 (e.g graphs and sparse matrices)
		it generates code comparable in efficiency to
		machine-specific low-level code (e.g. Fortran or C).

		The system is available via anonymous FTP to
		nesl.scandal.cs.cmu.edu (currently 128.2.222.128),
		in the file code/nesl/nesl.tar.Z (1.2Mbytes).
		There is a README file in the nesl directory that
		contains further information.  You can be added to
		the NESL mailing list by sending e-mail to
		[email-masked].  The examples and
		documentation are also available separately.

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 which belongs to the
		tradition of HOPE and ML. The algebraic flavour of
		OPAL shows up in the syntactical appearance and
		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.

		Papers describing OPAL, and the OPAL compilation
		system itself, are available by anonymous ftp from:

			ftp.cs.tu-berlin.de

		This includes an overview of OPAL in the file:

		    pub/local/uebb/papers/DesignImplOpal.ps.gz

		A language tutorial:

		    pub/local/uebb/papers/TutorialOpal.ps.gz

		The compilation system is in the pub/local/uebb/ocs
		directory.  Installation is straightforward and
		has been successfully performed for SPARCs,
		DECstations, NeXTs, and PCs running LINUX.

Scheme:		Scheme is a dialect of Lisp that stresses conceptual
		elegance and simplicity. It is specified in R4RS
		and IEEE standard P1178. (See question [1-7] for
		details on standards for Scheme.) 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 represent many programming abstractions
		with its simple primitives.

		There is an unmoderated usenet newsgroup,
		comp.lang.scheme for the discussion of topics
		related to Scheme, and a list of frequently asked
		questions for Scheme is posted to the group each
		month by Mark Kantrowitz.  The FAQ list is also
		available online from several sources; for example,
		it can be obtained by anonymous ftp from ftp.think.com
		in the file /public/think/lisp/scheme-faq.text.

		There are many books and papers dealing with Scheme.
		Please consult the comp.lang.scheme frequently
		asked questions list for further details.

		The Scheme Repository, maintained by Ozan S. Yigit,
		is accessible by anonymous ftp at nexus.yorku.ca
		[130.63.9.66] in the directory pub/scheme/, and
		contains a Scheme bibliography, copies of the R4RS
		report, IEEE P1178 specification and other papers,
		sample Scheme code for a variety of purposes,
		several utilities, and some implementations.  The
		repository is mirrored in INRIA, courtesy of
		Christian Queinnec [Ecole Polytechnique and
		INRIA-Rocquencourt], ftp.inria.fr:lang/Scheme.

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
mmetry,
		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.

		ftp: sisal.llnl.gov (128.115.19.65)

		For more information, pleases send an email request to:
			[email-masked]

		See also: "Retire FORTRAN? A debate rekindled",
		David Cann, CACM, 35(8), pp.81-89, Aug 1992

---------------------------------------------------------------------------
4) OTHER RESOURCES:

4.1) Bibliographies:

  o  Mike Joy maintains a bibliography on Functional Languages,
     in refer(1) format.  It is available by anonymous ftp from:
     ftp.dcs.warwick.ac.uk in the files:

       pub/biblio/functional.README pub/biblio/functional.refer.Z

  o  Tony Davie maintains a bibliography of over 2,600 papers,
     articles and books on functional programming and functional
     systems.  It can be obtained by anonymous ftp from
     tamdhu.dcs.st-and.ac.uk in the directory pub/staple, either
     as a hypercard stack in pubs.sit.Hqx, or as a (compressed)
     text file in pubs.txt.Z.

  o  Wolfgang Schreiner has compiled an annotated bibliography
     on parallel functional programming that lists more than 350
     publications mostly including their *full abstracts*.

     You can retrieve the bibliography by anonymous ftp from
     ftp.risc.uni-linz.ac.at (193.170.36.100) in
     pub/reports/parlab/pfpbib2.dvi.Z (or pfpbib2.ps.Z).

  o  State in Functional Programming: An Annotated Bibliography,
     edited by P. Hudak and D. Rabin, is available by anonymous
     ftp from nebula.cs.yale.edu in the files:

       pub/yale-fp/papers/state-bib.<format>.<compression> where
       <format>      ::= ps | dvi
	     <compression> :: = z | Z

4.2) Translators:

  o  Miranda(TM) to LML and Miranda(TM) to Haskell translators
     written by Denis Howe are available by anonymous ftp from
     wombat.doc.ic.ac.uk (146.169.22.42) in directory pub, files
     mira2hs-1.05 and mira2lml-0.00

4.3) Online services:

  o If you have wais, the source is listed below, or it can be
    easily obtained from the directory-of-servers. If you don't
    have wais, subscribe to comp.infosystems.wais and find someone
    to ask.

    (:source
       :version  3 :ip-address "137.219.17.4" :ip-name
       "coral.cs.jcu.edu.au" :tcp-port 8000 :database-name
       "Func-Prog-Abstracts" :cost 0.00 :cost-unit :free :maintainer
       "[email-masked]" :description "Server created
       with WAIS release 8 b3.1
	 on Apr 22 19:06:25 1992 by [email-masked]

     Keywords: help intro introduction info information computer
	science technical reports functional programming

     This is a small collection of computer science technical
     reports, abstracts and papers gathered from ftp sites etc.
     all over the world. Due to space considerations, I am limiting
     it to functional programming, my area of interest, and papers
     produced by the department (which may or may not be related
     to functional programming).

     Comments, problems etc to the maintainer above.  " )

  o The Free On-Line Dictionary of Computing is available by Gopher
    and FTP from wombat.doc.ic.ac.uk.  It is not restricted to
    functional programming but does include quite a few FP terms.

---------------------------------------------------------------------------
5) CREDITS AND DISCLAIMERS:

The information in this article has been taken from public sources,
mostly from articles posted on comp.lang.functional during the past
eighteen months.  This FAQ includes contributions from many different
people -- because of the way that the FAQ was compiled, I regret
to say that I do not have a complete list of contributors.

The aim of this FAQ is to provide information about functional
languages and to reflect widely held views in the functional
programming community.  Any opinions expressed in this message are
those of the individual contributors, and may not be representative
either of my own personal views, or of others in the community.

It is very likely that this FAQ contains some significant errors
and omissions: There are no guarantees for the accuracy of the
information provided here.  Of course, your corrections and
contributions are encouraged!

---------------------------------------------------------------------------