Conception, evolution, and application of functional programming languages

  title={Conception, evolution, and application of functional programming languages},
  author={Paul Hudak},
  journal={ACM Comput. Surv.},
  • P. Hudak
  • Published 1 September 1989
  • Computer Science
  • ACM Comput. Surv.
The foundations of functional programming languages are examined from both historical and technical perspectives. Their evolution is traced through several critical periods: early work on lambda calculus and combinatory calculus, Lisp, Iswim, FP, ML, and modern functional languages such as Miranda1 and Haskell. The fundamental premises on which the functional programming methodology stands are critically analyzed with respect to philosophical, theoretical, and pragmatic concerns. Particular… 

Figures from this paper

Enhancing Functional and Irregular Parallelism: Stateful Functions and their Semantics
This work describes an approach in which stateful computations can be expressed within the framework of a functional language and proposes to extend the Sisal language with state variables encapsulated within stateful functions.
Developing and Measuring Parallel Rule-Based Systems in a Functional Programming Environment
This thesis investigates the suitability of using functional programming for building parallel rule-based systems, and a profiler was developed for higher-order, lazy, functional languages which allows the programmer to measure and verify the behaviour of a program.
AI and the Origins of the Functional Programming Language Style
The origins of Lisp in the early AI programming work of the mid-to-late 1950s are examined, the key technical differences between it and the style first manifested in the Logic Theory Machine are analyzed, and it is concluded that programming practice and experience play a large and underappreciated role in the development of programming styles and languages.
An implementation of syntax directed functional programming on nested-stack machines
In the underlying result the class of functions computed by total deterministic macro tree-to-string transducers with the call-by-name computation strategy is characterized bytotal deterministic checking-tree nested-stack transducers.
Lazy evaluation in logic programming
  • S. Narain
  • Computer Science
    Proceedings. 1990 International Conference on Computer Languages
  • 1990
A method for bringing the concept of lazy evaluation to logic programming in a rigorous yet efficient manner is presented, based on making the SLD-resolution rule of inference directly simulate the behavior of a lazy rewriting interpreter satisfying strong computational properties.
Extending functional languages with stateful computations
  • Yung-Syau Chen, J. Gaudiot
  • Computer Science
    Proceedings of SPDP '96: 8th IEEE Symposium on Parallel and Distributed Processing
  • 1996
A new approach in which stateful computations can be performed within the framework of a functional programming language is presented and can greatly help users in writing programs, simplifying parallel compilation, and improving performance.
Widening the representation bottleneck: a functional implementation of relational programming
A relational language is described,, that retains the lazy, polymorphic and higher-order aspects of functional languages and the flexible handling of non-determinism and search based computation of logic languages.
A domain-theoretic approach to functional and logic programming
The result is a simple, elegant and purely declarative language that successfully combines the most important features of both pure functional programming and pure Horn logic programming.
Compiling standard ML for efficient execution on modern machines
This dissertation presents the design and evaluation of several new compilation techniques that meet tough challenges to efficient implementations of Standard ML by taking advantage of some of the higher-level language features in SML.


Integrating functional and imperative programming
A class of programming languages that enables the advantages of functional and imperative computation to be combined within a single program, which is called fluent languages, which have distinct sublanguages forfunctional and imperative programming.
Design and implementation of a simple typed language based on the lambda-calculus
This thesis is a reexamination of the possibility of designing and implementing a small but practical language based on very few primitive constructs in a new language called Ponder, which is statically typed and an efficient implementation of normal order reduction.
A Theory of Type Polymorphism in Programming
  • R. Milner
  • Computer Science
    J. Comput. Syst. Sci.
  • 1978
On understanding types, data abstraction, and polymorphism
A λ-calculus-based model for type systems that allows us to explore the interaction among the concepts of type, data abstraction, and polymorphism in a simple setting, unencumbered by complexities of production programming languages is developed.
Annotations to Control Parallelism and Reduction Order in the Distributed Evaluation of Functional Programs
The introduction of annotations to give the programmer control over the above decisions is proposed and their effects are defined in terms of the lambda calculus.
On the Expressiveness of Purely Functional I/O Systems
A series of surprisingly simple translations between the three models of I/O are given, demonstrating that they are not as diierent as their programming styles suggest, and implying that the styles could be mixed within a single program.
Correct and optimal implementations of recursion in a simple programming language
This paper describes an implementation of recursion which is both correct and optimal in a general class of sequential languages, and therefore constitutes an attractive alternative to both “ call-by-name” and “call- by-value”.
Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs
A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules; these systems have semantics loosely coupled to states—only one state transition occurs per major computation.
HOPE: An experimental applicative language
An applicative language called HOPE is described and discussed, to produce a very simple programming language which encourages the construction of clear and manipulable programs.