allanswers.org - comp.lang.functional Frequently Asked Questions (monthly posting)

 Home >  Programming >

comp.lang.functional Frequently Asked Questions (monthly posting)

Section 1 of 2 - Prev - Next


Archive-name: func-lang-faq
Url: http://www.cs.nott.ac.uk/Department/Staff/gmh/faq.html
Last-modified: August 1, 1999

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

             Frequently Asked Questions for comp.lang.functional

             Edited by Graham Hutton, University of Nottingham

                         Version of 1st August 1999

         0. New this month                  5. Languages
                                                 5.1. ASpecT
         1. This document                        5.2. Caml
                                                 5.3. Clean
         2. General topics                       5.4. Erlang
              2.1. Functional languages          5.5. FP
              2.2. History and motivation        5.6. Gofer
              2.3. Textbooks                     5.7. Haskell
              2.4. Journals and conferences      5.8. Hope
              2.5. Schools and workshops         5.9. Hugs
              2.6. Education                     5.10. Id
                                                 5.11. J
         3. Technical topics                     5.12. Miranda(TM)
              3.1. Purity                        5.13. Mercury
              3.2. Currying                      5.14. ML
              3.3. Monads                        5.15. NESL
              3.4. Parsers                       5.16. OPAL
              3.5. Strictness                    5.17. Oz
              3.6. Performance                   5.18. Pizza
              3.7. Applications                  5.19. Scheme
                                                 5.20. Sisal
         4. Other resources
              4.1. Web pages
              4.2. Research groups
              4.3. Newsgroups
              4.4. Bibliographies
              4.5. Translators

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

0. New this month

   * No changes this month.

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

1. This document

Comp.lang.functional is an unmoderated usenet newsgroup for the discussion
of all aspects of functional programming languages, including their design,
application, theoretical foundation, and implementation. Articles posted to
this (and other) newsgroups are archived on the web at:

     http://www.dejanews.com/.

This document is a Frequently Asked Questions list (FAQ) for
comp.lang.functional, and provides brief answers to a number of common
questions concerning functional programming languages, and some pointers to
relevant literature and internet resources. The latest version of this
document is available on the web from:

     http://www.cs.nott.ac.uk/Department/Staff/gmh/faq.html.

Much of the information in this document has been taken from public sources,
mostly from articles posted to comp.lang.functional. Because of the way that
this document was compiled, a complete list of contributors is not
available. Any opinions expressed in this document are those of the
individual contributors, and may not be representative of views of the
editor, or of others in the functional programming community. Every effort
has been made to ensure that the content of this document is correct and
up-to-date, but no guarantees are given for the accuracy of the information
provided here. Your corrections and contributions are encouraged!

The original version of this Frequently Asked Questions list 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.)

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

2. General topics

This section gives brief answers to a number of general questions concerning
functional programming languages, and some pointers to relevant literature
and internet resources.

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

2.1. Functional languages

What is a "functional programming language"?

Opinions differ, even within the functional programming community, on the
precise definition of what constitutes a functional programming language.
However, here is a definition that, broadly speaking, represents the kind of
languages that are discussed in comp.lang.functional:

     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 such as C, this might be expressed using a
simple loop, repeatedly updating the values held in an accumulator variable
total and a counter variable i:

     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, the result 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) functional languages such as
SML or Scheme, but it is more common to find such programs written with an
explicit loop, often expressed recursively. 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)

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

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

2.2. History and motivation

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

Here are two useful references:

   * "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. Available on the web from:

          http://www.cs.chalmers.se/~rjmh/Papers/whyfp.html.

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

2.3. Textbooks

Are there any textbooks about functional programming?

Yes, here are a selection:

Programming:

   * "Introduction to functional programming using Haskell", 2nd edition,
     Richard Bird, Prentice Hall Europe, 1998. ISBN 0-13-484346-0.

   * "Haskell: The craft of functional programming", 2nd edition, Simon
     Thompson, Addison-Wesley, 1999. ISBN 0-201-34275-8. Further information
     is available on the web from:

          http://www.cs.ukc.ac.uk/people/staff/sjt/craft2e.

   * "ML for the working programmer", 2nd Edition, L.C. Paulson, Cambridge
     University Press, 1996. ISBN 0-521-56543-X. Further information is
     available on the web from:

          http://www.cl.cam.ac.uk/users/lcp/MLbook/.

Algorithms and data structures:

   * "Purely functional data structures", Chris Okasaki, Cambridge
     University Press, 1998. ISBN 0-521-63124-6.

   * "Algorithms: A functional programming approach", Fethi Rabhi and Guy
     Lapalme, Addison-Wesley, 1999. ISBN 0-201-59604-0. Further information
     is available on the web from:

          http://www.iro.umontreal.ca/~lapalme/Algorithms-functional.html.

Implementation:

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

   * "Compiling with continuations", Andrew Appel, Cambridge University
     Press, 1992. ISBN 0-521-41695-7. Further information is available on
     the web from:

          http://www.cup.org/Titles/416/0521416957.html.

There are several other textbooks available, particularly in the programming
and implementation categories. A comparison of a number of functional
programming textbooks is made in the following article:

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

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

2.4. Journals and conferences

Are there any journals and conferences about functional programming?

Yes, here are a selection:

Journals:

   * The Journal of Functional Programming (JFP), published by Cambridge
     University Press. Further information is available on the web from:

          http://www.dcs.gla.ac.uk/jfp/.

   * The Journal of Functional and Logic Programming (JFLP), an electronic
     journal published by MIT Press, and available on the web from:

          http://www.cs.tu-berlin.de/journal/jflp/.

   * Lisp and Symbolic Computation, published by Kluwer.

Conferences:

   * The International Conference on Functional Programming (ICFP). This
     conference combines and replaces the earlier conferences on Lisp and
     Functional Programming (LFP), and Functional Programming Languages and
     Computer Architecture (FPCA). Further information about the next ICFP
     conference (September 1999 at the time of writing) is available on the
     web from:

          http://pauillac.inria.fr/pli/icfp/.

   * Mathematics of Program Construction (MPC). Further information about
     the most recent MPC conference (June 1998 at the time of writing) is
     available on the web from:

          http://www.md.chalmers.se/Conf/MPC98/.

   * Principles of Programming Languages (POPL). Further information about
     the next POPL conference (January 1999 at the time of writing) is
     available on the web from:

          http://www.cs.princeton.edu/~appel/popl99/index.html.

   * European Symposium on Programming (ESOP). Further information about the
     next ESOP conference (March 1999 at the time of writing) is available
     on the web from:

          http://www.daimi.aau.dk/~hrn/ESOP/esop.html.

Most of these conferences have proceedings published by the ACM press, or in
the Springer Verlag LNCS (Lecture Notes in Computer Science) series.

In addition to the above, Philip Wadler edits a column on functional
programming for the Formal Aspects of Computer Science Newsletter, which is
published by the British Computing Society Formal Aspects of Computing group
and Formal Methods Europe.

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

2.5. Schools and workshops

Are there any schools and workshops on functional programming?

Yes, here are a selection:

Schools:

   * The Third International Summer School on Advanced Functional
     Programming Techniques, September 12-19, 1998, Braga, Portugal. Further
     information is available on the web from:

          http://www.di.uminho.pt/~afp.

   * Spring School on Advanced Functional Programming Techniques, May 24-31,
     1995, Baastad, Sweden. The proceedings of the school were published in
     the Springer Verlag LNCS (Lecture Notes in Computer Science) series,
     number 925.

   * The Second International Summer School on Advanced Functional
     Programming Techniques, August 25-30, 1996, Washington, USA. The
     proceedings of the school were published in the Springer Verlag LNCS
     (Lecture Notes in Computer Science) series, number 1129. Further
     information is available on the web from:

          http://www.cse.ogi.edu/PacSoft/summerschool96.html.

Workshops:

   * Third Haskell Workshop, October 1, 1999, Paris, France. Held in
     conjunction with ICFP'99. Further information is available on the web
     from:

          http://www.haskell.org/HaskellWorkshop.html

   * Workshop on Algorithmic Aspects of Advanced Programming Languages,
     September 29-30, 1999, Paris, France. Further information is available
     on the web from:

          http://www.cs.columbia.edu/~cdo/waaapl.html.

   * 1st Scottish Functional Programming Workshop, August 29-September 1,
     1999, Stirling, Scotland. Further information is available on the web
     from:

          http://www.cee.hw.ac.uk/~gjm/sfp/.

   * From 1988 to 1998 the Glasgow functional programming group organised a
     yearly workshop in Scotland. Further information is available on the
     web from:

          http://www.dcs.gla.ac.uk/fp/workshops/.

   * The 9th International Workshop on the Implementation of Functional
     Languages, Sept 10-12, 1997, St. Andrews, Scotland. Further information
     is available on the web from:

          http://www.dcs.st-and.ac.uk/~ifl97.

   * The Haskell Workshop, June 7, 1997, Amsterdam, The Netherlands. Held is
     conjunction with ICFP'97. Further information is available on the web
     from:

          http://www.cse.ogi.edu/~jl/ACM/Haskell.html.

   * The 2nd Fuji International Workshop on Functional and Logic
     Programming, November 1-4, 1996, Shonan Village, Japan. Further
     information is available on the web from:

          http://www.kurims.kyoto-u.ac.jp/~ohori/fuji96.html.

   * The 1st Workshop on Functional Programming in Argentina, September 12,
     1996, Buenos Aires, Argentina. Further information is available on the
     web from:

          http://www-lifia.info.unlp.edu.ar/~lambda/first/english/.

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

2.6. Education

Are functional programming languages useful in education?

Functional languages are gathering momentum in education because they
facilitate the expression of concepts and structures at a high level of
abstraction. Many university computing science departments now make use of
functional programming in their undergraduate courses; indeed, a number of
departments teach a functional language as their first programming language.
Further information about the use of functional programming languages in
education (including links to relevant conferences and workshops) is
available on the web from:

     http://www.cs.kun.nl/fple/.

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

3. Technical topics

This section gives brief answers to a number of technical questions
concerning functional programming languages, and some pointers to relevant
literature and internet resources.

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

3.1. Purity

What is a "purely functional" programming language?

This question has been the subject of some debate in the functional
programming community. It is widely agreed that languages such as 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" is often used to describe languages
     that perform all their computations via function application. This
     is in contrast to languages, such as Scheme and Standard ML, that
     are predominantly functional but also allow `side effects'
     (computational effects caused by expression evaluation that
     persist after the evaluation is completed).

     Sometimes, the term "purely functional" is also used in a broader
     sense to mean languages that 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.

See also:

   * "What is a purely functional language", Amr Sabry, Journal of
     Functional Programming, 8(1):1-22, Cambridge University Press, January
     1998.

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

3.2. Currying

What is "currying", and where does it come from?

Currying has its origins in the mathematical study of functions. It was
observed by Frege in 1893 that it suffices to restrict attention to
functions of a single argument. For example, for any two parameter function
f(x,y), there is a one parameter function f' such that f'(x) is a function
that can be applied to y to give (f'(x))(y) = f (x,y). This corresponds to
the well known fact that the sets (AxB -> C) and (A -> (B -> C)) are
isomorphic, where "x" is cartesian product and "->" is function space. In
functional programming, function application is denoted by juxtaposition,
and assumed to associate to the left, so that the equation above becomes f'
x y = f(x,y).

Apparently, Frege did not pursue the idea further. It was rediscovered
independently by Schoenfinkel, together with the result that all functions
having to do with the structure of functions can be built up out of only two
basic combinators, K and S. About a decade later, this sparked off the
subject of combinatory logic, invented by Haskell Curry. The term "currying"
honours him; the function f' in the example above is called the "curried"
form of the function f. From a functional programming perspective, currying
can be described by a function:

     curry : ((a,b) -> c) -> (a -> b -> c)

The inverse operation is, unsurprisingly, refered to as uncurrying:

     uncurry : (a -> b -> c) -> ((a,b) -> c)

For further reading, see:

   * "Highlights of the history of the lambda-calculus", J. Barkley Rosser,
     ACM Lisp and Functional Programming, 1982.

   * "Ueber die Bausteine der mathematischen Logik", Moses Sch\"onfinkel,
     Mathematische Annalen, 92, 1924. An English translation, "On the
     building blocks of mathematical logic", appears in "From Frege to
     G\"odel", Jean van Heijenoort, Harvard University Press, Cambridge,
     1967.

   * "Combinatory logic", Haskell B. Curry and Robert Feys, North-Holland,
     1958. This work also contains many references to earlier work by Curry,
     Church, and others.

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

3.3. Monads

What is a "monad", and what are they used for?

The concept of a monad comes from category theory; full details can be found
in any standard textbook on the subject. Much of the 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 such as Haskell:

   * "Comprehending monads", Philip Wadler, Mathematical Structures in
     Computer Science, Special issue of selected papers from 6th Conference
     on Lisp and Functional Programming, 1992. Available on the web from:

          http://www.cs.bell-labs.com/~wadler/topics/monads.html#monads

   * "The essence of functional programming", Philip Wadler, Invited talk,
     19th Symposium on Principles of Programming Languages, ACM Press,
     Albuquerque, January 1992. Available on the web from:

          http://www.cs.bell-labs.com/~wadler/topics/monads.html#essence

   * "Imperative functional programming", Simon Peyton Jones and Philip
     Wadler, 20th Symposium on Principles of Programming Languages, ACM
     Press, Charlotte, North Carolina, January 1993. Available on the web
     from:

          http://www.cs.bell-labs.com/~wadler/topics/monads.html#imperative

   * "How to declare an imperative", Philip Wadler, ACM Computing Surveys,
     to appear. Available on the web from:

          http://www.cs.bell-labs.com/~wadler/topics/monads.html#monadsdeclare

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

3.4. Parsers

How can I write a "parser" in a functional programming 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:

   * Using a parser generator tool. Some functional language implementations
     support tools that generate a parser automatically from a specification
     of the grammar. See:

        o Happy: a parser generator system for Haskell and Gofer, similar to
          the tool `yacc' for C. Available on the web from:

               http://www.dcs.gla.ac.uk/fp/software/happy/.

        o Ratatosk: a parser and scanner generator for Gofer. Available by
          ftp from:

                Host:      ftp.diku.dk;
                Directory: /pub/diku/dists.

        o ML-Yacc and ML-Lex: an LALR parser generator and a lexical
          analyser generator for Standard ML. Included with SML/NJ,
          available by ftp from:

                Host:      ftp.research.bell-labs.com;
                Directory: /dist/smlnj.

   * 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. See:

        o "How to replace failure with a list of successes", Philip Wadler,
          FPCA '85, Springer Verlag LNCS 201, 1985.

        o "Higher-order functions for parsing", Graham Hutton, Journal of
          Functional Programming, Volume 2, Number 3, July 1992. Available
          on the web from:

               http://www.cs.nott.ac.uk/Department/Staff/gmh/bib.html#parsing.

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

3.5. Strictness

What does it mean to say that a functional programming language is "strict"
or "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.

There is much debate in the functional programming community about the
relative merits of strict and non-strict languages. It is possible, however,
to support a mixture of these two approaches; for example, some versions of
the functional language Hope do this.

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

3.6. Performance

What is the performance of functional programs like?

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
such as higher-order functions, automatic storage management, etc. Of
course, the performance of interpreters and compilers for functional
languages keeps improving with new technological developments.

Here are a selection of references for further reading:

   * Over 25 implementations of different functional languages have been
     compared using a single program, the "Pseudoknot" benchmark, which is a
     floating-point intensive application taken from molecular biology. See:

        o "Benchmarking implementations of functional languages with
          'Pseudoknot', a float-intensive benchmark", Pieter H. Hartel et
          al, Journal of Functional Programming, 6(4):621-655, July 1996.
          Available on the web from:

               ftp://ftp.fwi.uva.nl/pub/computer-systems/functional/reports/.

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

        o "Benchmarking implementations of lazy functional languages", P.H.
          Hartel and K.G. Langendoen, FPCA 93, ACM, pp 341-349. Available by
          ftp from:

                Host:      ftp.fwi.uva.nl;
                Directory: pub/functional/reports.

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

        o "Retire FORTRAN? A debate rekindled", D.C. Cann, Communications of
          the ACM, 35(8), pp. 81-89, August 1992.

   * Postscript versions of a number of papers from the 1995 conference on
     High Performance Functional Computing (HPFC) are available on the web
     from:

          ftp://sisal.llnl.gov/pub/hpfc/index.html.

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

3.7. Applications

Where can I find out about applications of functional programming?

Here are a selection of places to look:

   * "Special issue on state-of-the-art applications of pure functional
     programming languages", edited by Pieter Hartel and Rinus Plasmeijer,
     Journal of Functional Programming, Volume 5, Number 3, July 1995.

   * "Applications of functional programming", edited by Colin Runciman and
     David Wakeling, UCL Press, 1995. ISBN 1-85728-377-5.

   * An online list of real-world applications of functional programming is
     maintained, which includes programs written in several different
     functional languages. The main criterion for being considered a
     real-world application is that the program was written primarily to
     perform some task, rather than to experiment with functional
     programming.

     Further details are available on the web from:

          http://www.cs.bell-labs.com/~wadler/realworld/.

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

4. Other resources

This section gives some pointers to other internet resources on functional
programming.

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

4.1. Web pages

   * Philip Wadler's guide to functional programming on the web:

          http://cm.bell-labs.com/cm/cs/who/wadler/guide.html.

   * Philip Wadler's list of real-world application of functional
     programming:

          http://www.cs.bell-labs.com/~wadler/realworld/.

   * The SEL-HPC WWW functional programming archive:

          http://hypatia.dcs.qmw.ac.uk/SEL-HPC/Articles/FuncArchive.html.

   * Jon Mountjoy's functional languages page:

          http://carol.wins.uva.nl/~jon/func.html.

   * Claus Reinke's functional programming bookmarks:

          http://www.cs.nott.ac.uk/~czr/FP.html.

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

4.2. Research groups

   * The Chalmers functional programming group:

          http://www.md.chalmers.se/Cs/Research/Functional/.

   * The Glasgow functional programming group:

          http://www.dcs.gla.ac.uk/fp.

   * The Nijmegen functional programming group:

          http://www.cs.kun.nl/~clean.

   * The Nottingham languages and programming group:

          http://www.cs.nott.ac.uk/Research/lap/index.html.

   * The St Andrews functional programming group:

          http://www-fp.dcs.st-and.ac.uk/.

   * The Yale functional programming group:

          http://www.cs.yale.edu/HTML/YALE/CS/haskell/yale-fp.html.

   * The York functional programming group:

          http://www.cs.york.ac.uk/fp/.

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

4.3. Newsgroups

   * For discussion about ML:

          comp.lang.ml.

   * For discussion about Scheme:

          comp.lang.scheme.

   * For discussion about Lisp:

          comp.lang.lisp.

   * For discussion about APL, J, etc:

          comp.lang.apl.

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

4.4. Bibliographies

   * Mike Joy's bibliography on functional programming languages, in
     refer(1) format:

           Host:      ftp.dcs.warwick.ac.uk;
           Directory: /pub/biblio.

   * Tony Davie's bibliography of over 2,600 papers, articles and books on
     functional programming, available as a text file or a hypercard stack
     by ftp from:

           Host:      tamdhu.dcs.st-and.ac.uk;
           Directory: /pub/staple.

   * "State in functional programming: an annotated bibliography", edited by
     P. Hudak and D. Rabin, available as a dvi or postscript file by ftp
     from:

           Host:      nebula.cs.yale.edu;
           Directory: /pub/yale-fp/papers.

   * Wolfgang Schreiner's annotated bibliography of over 350 publications on
     parallel functional programming (most with abstracts), available on the
     web from:

          http://www.risc.uni-linz.ac.at/people/schreine/papers/pfpbib.ps.gz.

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

4.5. Translators

   * The smugweb system for typesetting Haskell code in TeX, available from:

          http://www5.informatik.uni-jena.de/~joe/smugweb.html.

   * The miratex package for typesetting Miranda(TM) code in TeX, available
     from:

          http://www.cs.tcd.ie/www/jgllgher/miratex/index.html.

   * Denis Howe's translators from Miranda(TM) to LML and Haskell, available
     from:

          http://wombat.doc.ic.ac.uk/pub/mira2lml;

          http://wombat.doc.ic.ac.uk/pub/mira2hs.

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

5. Languages

This section gives a brief overview of a number of programming languages
that support aspects of the functional paradigm, and some pointers to

Section 1 of 2 - Prev - Next

Back to category Programming - Use Smart Search
Home - Smart Search - About the project - Feedback

© allanswers.org | Terms of use

LiveInternet