Functional Programming Style Research Articles

Using memorization to achieve polynomial complexity of purely functional executable specifications of non-deterministic top-down parsers

Norvig [1991] has shown that a process with properties that are similar to those of Earley's algorithm can be generated by a simple top-down backtracking parser when augmented by memoization. Unfortunately, Norvig's approach cannot be implemented directly in pure functional programming languages such as Miranda, Haskell, LML, etc, owing to the fact that such languages do not provide any form of mutable object. This restriction is a necessary condition for referential transparency, a property of programs that simplifies reasoning about them and which is widely regarded as one of the main advantages of the pure functional programming style. In this note, we show how Norvig's approach can be adapted and used to achieve polynomial complexity of non-deterministic top-down backtracking parsers that are implemented as executable specifications in pure functional programming languages. The technique that we present uses a slight variation of an approach to implementing memoization in pure functional languages that is described in Field and Harrison [1988].

Data abstraction in Modula-2

Data abstraction is one of the most fundamental principles of software engineering. The increasing realization of this is reflected in the design of programming languages, from the tentative user-defined data types of Pascal through to the more extensive facilities provided today by languages such as Ada and Modula-2. This tutorial paper examines how the data abstraction facilities provided by Modula-2 can be used in a sophisticated application. We demonstrate that data abstraction facilitates the production of code which is highly modularized, is easy to write and easy to read. The application, garbage collection, is an important part of system software, and is particularly interesting because it highlights the conflict between efficiency and expressive power. We show the extent to which a functional style of programming can be utilized in solving a problem which is inherently concerned with ‘state’, and we also show how formal semantics can be provided for the abstract data types.

Parallel Functional Programming with Arrays

AbstractWe present an algebraic theory of arrays for data-parallel functionalprogramming. Non-nested arrays simplify the mapping problem toregular architectures, avoid nested list representations and prevent theoccurrence of an explosive number of algebraic laws. The MOA formal-ism describes arrays in a dimension-independent algebra. A new styleof functional programming is described with MOA operators, allowingrecursion equations to describe the meaning as well as the structure ofalgorithms for mesh- or hypercube-connected multiprocessors. 1 Introduction In a recent study, Marino and Succi [19] have enumerated requirements foruseful parallel data structures. Data structures should:match existing and future computer architectures;allow for ecient parallel implementations;be formally de ned in an applicative language;allow the de nition of complex objects in a constructive way. Work supported by an NSERC operating granty G. Hains, Universite de Montreal, Informatique et Recherche Operationnelle, casepostale 6128,succursale A, Montreal, Quebec, Canada H3C 3J7, hains@iro.umontreal.ca. L.M.R.Mullin, Computer Science and Electrical Engineering, University of Vermont, Burlington,Vermont, 05405 USA lenore@newton.uvm.edu

Logic programming with arrays

Nial is a programming language designed around a mathematical treatment of data as nested arrays. A goal of the research described is to integrate within Nial a functional style of programming based on the theory of arrays with the declarative capabilities of a logic programming environment. This is partially accomplished by storing logic clauses as arrays which can be manipulated using logic clauses. Arrays as terms are considered as part of the syntax of the clauses. The approach to logic programming is based on providing a flexible environment for experimenting with full clausal or Horn clause logic. A variety of predefined control strategies and the capability for user-defined control strategies have been provided. The expressive capabilities of combining logic and functional programming styles provides a suitable language for many application areas. The philosophy and design behind a combined logic/database model used to prototype a knowledge-based systems application are described. >

Parallel computers for advanced information processing

An overview is given of ESPRIT project 415, which involved the study of object-oriented, functional, and logic programming styles in six subprojects. The parallel languages and architectures designed to implement them are described, and the technology of the object-oriented approach pursued by the authors' team is examined. Their design includes a novel language, decentralized memory architecture, and system software. >

A functional style of programming with CSP-like communication mechanisms

This paper introduces CSP-like communication mechanisms into Backus’ Functional Programming (FP) systems extended by nondeterministic constructs. Several new functionals are used to describe nondeterminism and communication in programs. The functionals union and restriction are introduced into FP systems to develop a simple algebra of programs with nondeterminism. The behaviour of other functionals proposed in this paper are characterized by the properties of union and restriction. The axiomatic semantics of communication constructs are presented. Examples show that it is possible to reason about a communicating program by first transforming it into a non-communicating program by using the axioms of communication, and then reasoning about the resulting non-communicating version of the program. It is also shown that communicating programs can be developed from non-communicating programs given as specifications by using a transformational approach.

Making form follow function: An exercise in functional programming style

AbstractThe combined use of user‐defined infix operators and higher order functions allows the programmer to invent new control structures tailored to a particular problem area.This paper is to suggest that such a combination has beneficial effects on the ease of both writing and reading programs, and hence can increase programmer productivity. As an example, a parser for a simple language is presented in this style. The compactness of this parser and its notational similarity to the BNF of the language are important advantages of the approach taken.It is hoped that the presentation will be palatable to people unfamiliar with the concepts of functional programming.

Implementation of an FP-Shell

One of the best features of the UNIX™ Shell is that it provides a framework which can be used to build complex programs by interconnecting existing simple programs. However, it is limited to linear combinations of programs, and building of more complex programs must be accomplished by executing sequences of commands. This paper introduces Backus' FP (Functional Programming) as an alternative command language for UNIX. In FP, programs are true functions and another distinctive feature of FP languages is that they contain functional forms, which are constructs for combining programs to build new programs. Also, the functional style of programming provides a natural way of exploiting parallel machine architecture.

Solving 1-D boundary-value problems with BandAid: A functional programming style and a complementary software tool

This study examines the use of a functional programming style for writing computer programs to solve two-point boundary-value problems. The results of the study consist of a suggestion for an effective writing style, and of the implementation of a software tool that supports programming in that style.

Functional programming in graphs

Abstract The notation of functional programming (FP) provides a clear and general syntax for writing programs which have extremely simple semantics and exhibit a clear hierarchical structure. Unfortunately, functional languages have a reputation of being hard to learn. This paper suggests an FP style of programming in which programmers deal with graphs as primary representations in programming, editing and executing programs. Programming becomes constructing system by which programs are built up as structured assemblies of functions. The programming technique developed in this paper follows four steps: (1) to define object types; (2) to define type clauses; (3) to construct program graphs; and (4) to automatically convert program graphs into FP programs. These programming processes help programmers easily form clear and correct mental images of a program's structure and function.

APL2 and AI: a study of search

The APL2 language and its environment offers a number of features which make it an effective vehicle for AI research and for the development of knowledge-based systems. In the language, general arrays can easily model various knowledge representations; it is easy to model parallel behavior; there are various ways to implement deductive reasoning: and there are some interesting features that support a functional style of programming. In the environment, editors, interactive graphics, and debugging tools provide excellent human interfaces; Fortran, REXX, and Assembler routines may transparently replace APL2 functions; relational tables which are subsets of APL2 arrays may be retrieved dynamically; and user-to-user shared variable processing can be used to model parallel behavior. In this paper, we will demonstrate the usage of APL2 for AI problems by presenting concise functional programs for searching a database of rules and facts. Various simple enhancements are shown which extend the scope of the programs to and/or, heuristic, bi-directional, and parallel search.

Yacc in sasl — an exercise in functional programming

AbstractAmong the advantages claimed for a purely functional programming style is ease of designing and implementing large programs. However, little experience of actually doing so has been gained so far. The experience of writing a particular medium sized program in a functional language is described here, with particular emphasis on the differences in programming style that were appropriate. This is compared with the experience of writing a very similar program in an imperative language. The main conclusions appear to be that the functional version was significantly easier to write, and was considerably smaller, though not by as large a factor as is sometimes claimed; that strong typing is, if anything, more desirable than in imperative systems; and that the question of debugging functional programs needs further research attention.

Experiments with muMATH in Austrian high schools

In Austrian high schools, some experiments for using computer algebra systems in secondary education have been made. The results of these experiments are discussed and some improvements for the systems are proposed. The experiments consisted of two parts: training of functional programming style in muSIMP, routine in the use of the muMATH/muSIMP arithmetic, equation, and solve package, application of muMATH to symbolic transformations in analytic geometry as it is used in school.

Can programming be liberated from the von Neumann style?

Conventional programming languages are growing ever more enormous, but not stronger. Inherent defects at the most basic level cause them to be both fat and weak: their primitive word-at-a-time style of programming inherited from their common ancestor—the von Neumann computer, their close coupling of semantics to state transitions, their division of programming into a world of expressions and a world of statements, their inability to effectively use powerful combining forms for building new programs from existing ones, and their lack of useful mathematical properties for reasoning about programs. An alternative functional style of programming is founded on the use of combining forms for creating programs. Functional programs deal with structured data, are often nonrepetitive and nonrecursive, are hierarchically constructed, do not name their arguments, and do not require the complex machinery of procedure declarations to become generally applicable. Combining forms can use high level programs to build still higher level ones in a style not possible in conventional languages. Associated with the functional style of programming is an algebra of programs whose variables range over programs and whose operations are combining forms. This algebra can be used to transform programs and to solve equations whose “unknowns” are programs in much the same way one transforms equations in high school algebra. These transformations are given by algebraic laws and are carried out in the same language in which programs are written. Combining forms are chosen not only for their programming power but also for the power of their associated algebraic laws. General theorems of the algebra give the detailed behavior and termination conditions for large classes of programs. A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules. Unlike von Neumann languages, these systems have semantics loosely coupled to states—only one state transition occurs per major computation.