Functional Programming Systems Research Articles

Perspectives of Functional Programming of Parallel Computations

The article is devoted to the results of the analysis of modern trends in functional programming, considered as a metaparadigm for solving the problems of organizing parallel computations and multithreaded programs for multiprocessor complexes and distributed systems. Taking into account the multi-paradigm nature of parallel programming, the paradigm analysis of languages and functional programming systems is used. This makes it possible to reduce the complexity of the problems being solved by methods of decomposition of programs into autonomously developed components, to evaluate their similarities and differences. Consideration of such features is necessary when predicting the course of application processes, as well as when planning the study and organizing the development of programs. There is reason to believe that functional programming has the ability to improve programs performance. A variety of paradigmatic characteristics inherent in the preparation and debugging of long-lived parallel computing programs are shown.

Schema-Guided Inductive Functional Programming

Inductive Program Synthesis or Inductive Programming (IP) is the task of generating (recursive) programs from an incomplete specification, such as input/output (I/O) examples. All known IP algorithms can be described as search in the space of all candidate programs, with consequently exponential complexity. To constrain the search space and guide the search traditionally program schemes are used, usually given a priori by an expert user. Consequently, all further given data is interpreted w.r.t. this schema which now almost exclusively decides on success and failure, depending on whether it fits the data or not. Instead of trying to fit the data to a given schema indiscriminately, in my thesis (Schema-guided inductive functional programmin through automatic detection of type morphisms, 2010) I proposed to utilise knowledge about data types to choose and fit a suitable schema to the data! Recursion operators associated with data type definitions are well known in functional programming, but less in IP. I showed how to exploit universal properties of type morphisms which may be detected in the given I/O examples. This technique allows to introduce generic recursion schemes, such as catamorphisms or paramorphisms, on arbitrary inductive data types in the analytical inductive functional programming system Igor II which was already presented here in a previous issue (Kitzelmann in Kunstl. Intell. 25:179–182, 2011).

Representation sharing for Prolog

AbstractRepresentation sharing can reduce the memory footprint of a program by sharing one representation between duplicate terms. The most common implementation of representation sharing in functional programming systems is known as hash-consing. In the context of Prolog, representation sharing has been given little attention. Some current techniques that deal with representation sharing are reviewed. The new contributions are (1) an easy implementation ofinput sharingforfindall/3; and (2) a description of asharermodule that introduces representation sharing at runtime. Their realization is shown in the context of the Warren Abstract Machine (WAM) as implemented by hProlog. Both can be adapted to any WAM-like Prolog implementation. The sharer works independently of the garbage collector, but it can be made to cooperate with the garbage collector. Benchmark results show that the sharer has a cost comparable to the heap garbage collector, that its effectiveness is highly application-dependent, and that its policy must be tuned to the collector.

Efficient Intensional Implementation for Lazy Functional Languages

The intensional transformation is a technique that can be used in order to eliminate higher-order functions from a functional program by introducing appropriate context-manipulation operators. The transformation can be applied to a significant class of higher-order programs and results in equivalent zero-order intensional programs that can be executed in a simple demand-driven way. Despite its simplicity, the transformation has never been seriously evaluated with respect to its efficiency and potential. Certain simple implementations of the technique have been performed, but questions regarding the merits of the method have remained inconclusive. In this paper we demonstrate that the transformation can be efficiently implemented by using what we call lazy activation records, namely activation records in which some entries are filled on-demand. An evaluation of our implementation demonstrates that the technique outperforms some of the most well-known functional programming systems, for the class of programs that can be transformed.

Methods and system of functional programming for supporting supercomputing

AbstractIn the paper, the functional programming system SFP being under development at the Institute of Informatics Systems in Novosibirsk is considered. The SFP system is aimed at supporting development of parallel computing applications that still offer high performance and portability. (© 2008 WILEY‐VCH Verlag GmbH & Co. KGaA, Weinheim)

Functional Parallel Typified Language and Its Implementation on Clusters

In the paper, a functional parallel programming system implemented on clusters is discussed. It includes a language of compositional functional parallel programming, program development tools, and tools for controlling parallel code execution on the clusters.

More efficient left-to-right matching for overlapping pattern

Pattern matching is a fundamental feature in many applications such as functional programming, logic programming, theorem proving, term rewriting and rule-based expert systems. Usually, patterns are pre-processed into a deterministic finite automaton. Using such an automaton allows one to determine the matched pattern(s) by a single scan of the input term. The matching automaton is typically based on left-to-right traversal of patterns. In this paper, we propose a method to build such an automaton. Then, we propose an incremental method to build a deterministic concise automaton for non-necessarily sequential rewriting systems. With ambiguous patterns a subject term may be an instance of more than one pattern. To select the pattern to use, a priority rule is usually engaged. The pre-processing of the patterns adds new patterns, which are instances of the original ones. When the original patterns are ambiguous, some of the instances supplied may be irrelevant for the matching process. They may cause an unnecessary increase in the space requirements of the automaton and may also reduce the time efficiency of the matching process. Here, we devise a new pre-processing operation that recognises and avoids such irrelevant instances. Hence improves space and time requirements for the matching automaton.

Efficient concise deterministic pattern-matching automata for ambiguous patterns

Pattern-matching is a fundamental feature in many applications such as functional programming, logic programming, theorem proving, term rewriting and rule-based expert systems. Usually, patterns are pre-processed into a deterministic finite automaton. Using such an automaton allows one to determine the matched pattern(s) by a single scan of the input term. The matching automaton is typically based on left-to-right traversal of patterns. With ambiguous patterns a subject term may be an instance of more than one pattern. To select the pattern to use, a priority rule is usually engaged. The pre-processing of the patterns adds new patterns which are instances of the original ones. When the original patterns are ambiguous, some of the instances supplied may be irrelevant for the matching process. They may cause an unnecessary increase in the space requirements of the automaton and may also reduce the time efficiency of the matching process. Here, we devise a new pre-processing operation that recognises and avoids such irrelevant instances and hence improves space and time requirements for the matching automaton.

Semantics of Untyped Functional Programs

The paper is devoted to procedural semantics that use interpretation algorithms on which interpreters of untyped functional programming systems are based (or can be based). The aim of this study is to describe such algorithms and compare procedural semantics based on them both with each other and with the basic semantics defined by means of the fixed-point combinator Y.

Preface: Volume 59, Issue 4

ForewordThis volume contains the Proceedings of the Second International Workshop on Rule-Based Programming (RULE2001). The Workshop was held in Firenze, Italy on September 4, 2001, as satellite event to PLI2001.This is the second edition of the International Workshop on Rule-Based Programming (RULE'2001). We aim with this workshop at a fruitful cross fertilization of the theoretical foundations of rule-based programming with practical applications and implementation of rule-based systems. We are very pleased with the broad range of papers: quite a number of very theoretical ones upto papers describing a system and a paper describing a comparison between a number of rule-based systems to tackle a bio-medical problem.Rule-based programming began with AI rule-based systems in the seventies. This paradigm is inherent in Prolog and has been used in program-manipulation systems like Refine. Indeed, the rewriting concept appears throughout computer science, from its theoretical foundations to very practical implementations. Extreme examples include the mail system in Unix which uses rules in order to rewrite mail addresses to canonical forms and the transition rules describing the behaviour of tree automata. Rewriting is used in semantics in order to describe the meaning of programming languages, as well as in program transformations like the re-engineering of Cobol programs. It is used to compute, implicitly or explicitly, as in Mathematica or OBJ, but also to perform deduction when using inference rules to describe a logic, theorem prover or constraint solver. Last, but not least, this approach is central to systems that raise the notion of rule to an explicit first class object, like expert systems, programming languages based on equational logic, algebraic specifications (e.g. OBJ), functional programming (e.g. ML) and transition systems (e.g. Murphi).Rule-based programming is currently experiencing a renewed period of growth with the emergence of new concepts and systems that allow one to better understand and better use it. From the theoretical side, after the in-depth study of rewriting concepts during the eighties, the nineties saw the emergence of the general concepts of rewriting logic and of the rewriting calculus. On the practical side, new languages, like ASM, ASF+SDF, Claire, ELAN and Maude, systems like LRR, and also commercial products, like Ilog Rules, have shown that the concept of rule could be of major interest as a programming tool. In particular, because it is now of practical use, fundamental questions arise, like the theoretical study of the algorithmic complexity of programs written in such languages, as well as their optimisation. Of course, semantics of such languages, compilation techniques and methodological studies of their use should also be explored.Rule based programming is closely related to both functional programming (when the term rewrite system is confluent and terminating) as well as classical logic programming (when the rewrite system is used for nondeterministic search).Accordingly, the purpose of this workshop is to bring together researchers from these various domains to foster fertilisation between theory and practice, as well as to favour the growth of this programming paradigm. Mark van den Brand(CWI Amsterdam)Iliano Cervesato(ITT Industries)Nachum Dershowitz(Tel-Aviv University)Bernd Fischer(RIACS/NASA Ames, Moffett Field)Claude Kirchner(LORIA Nancy)Jean-Yves Marion(LORIA Nancy)Narciso Marti-Oliet(Universidad Complutense de Madrid)Rakesh M. Verma(University of Houston)Eelco Visser(Utrecht University)This volume will be published as volume 44-2 in the series Electronic Notes in Theoretical Computer Science (ENTCS). This series is published electronically through the facilities of Elsevier Science B.V. and its auspices. The volumes in the ENTCS series can be accessed at the URLWe would like to thank the program committee members for their help in evaluating the papers and making a scientifically interesting selection. Furthermore, we would like to thank the {\\bf PLI} organizing committee for taking care of the local organization of our workshop. We thank the ACM organization for sponsoring this workshop. We thank Elsevier for publishing these proceedings in the Electronic Notes in Theoretical Computer Science (ENTCS). Finally, we thank Professor Michael Mislove for providing and adapting the style files for ENTCS.November, 2001 Mark van den Brand and Rakesh M. Verma

Adaptive Pattern Matching

Pattern matching is an important operation used in many applications such as functional programming, rewriting, and rule-based expert systems. By preprocessing the patterns into a DFA-like automaton, we can rapidly select the matching pattern(s) in a single scan of the relevant portions of the input term. This automaton is typically based on left-to-right traversal of the patterns. By adapting the traversal order to suit the set of input patterns, it is possible to considerably reduce the space and matching time requirements of the automaton. The design of such adaptive automata is the focus of this paper. We first formalize the notion of an adaptive traversal. We then present several strategies for synthesizing adaptive traversal orders aimed at reducing space and matching time complexity. In the worst case, however, the space requirements can be exponential in the size of the patterns. We show this by establishing an exponential lower bounds on space that is independent of the traversal order used. We then discuss an orthogonal approach to space minimization based on direct construction of optimal dag automata. Finally, our work brings forth the impact of typing in pattern matching. In particular, we show that several important problems (e.g., lazy pattern matching in ML) are computationally hard in the presence of type disciplines, whereas they can be solved efficiently in the untyped setting.

Extending a functional programming system for embedded applications

AbstractFunctional languages do not usually mesh well with embedded applications because of the need for special I/O device‐handling. By introducing a process model to a language, however, it becomes possible to express register‐level device operations and interrupts in a modular manner. This paper describes such a model, its implementation by extension to the Gofer programming system, and examples of its use. Performance results indicate that even this prototype interpretive system is adequate for small applications. The major gain of using a functional language is the ease with which abstraction can be layered over low‐level detail, improving both the readability of code and its tractability.

Transformation of Logic Programs to FP Programs Based on Dataflows

This paper is concerned with functionality of a logic program. Functionality based on input-output relations declared in predicates is not treated, but functionality of extensionalities of predicates, involved in a logic program, is realized by a dataflow computation and a functional programming (FP) system. By capturing the extensionality of a predicate as an atom sequence, we pay attention to the role of a definite clause together with already existing predicates in the resolution deduction, and abstractly interpret a definite clause as a function to provide a sequence emanating from its head (that is, conclusion) for already existing sequences unified with its body (premise expressed as a conjunction of predicates). Then we regard a logic program as a functional of functions of atom sequences. The functional is really a dataflow extracted from a logic program such that the dataflow preserves the same meaning. The atom sequence is replaced by a substitution sequence to affect a designated predicate, and the dataflow is thereby expressed by semantic functions over a sequence domain of substitutions, where the semantic functions are defined by algebraic manipulations of substitutions. The dataflow is represented by a functional form (FP program) of functions in accordance with substitution sequence variables. The FP program is a meaning preserving program transformed from a given logic program.

BOOK REVIEW: An Inlroduction to Functional Programming Systems Using Haskell by Antony J. T. Davie

BOOK REVIEW: An Inlroduction to Functional Programming Systems Using Haskell by Antony J. T. Davie

A list-oriented extension of the lambda-calculus satisfying the Church—Rosser theorem

A list-oriented extension of the type-free lambda-calculus is considered where lists have a unique applicative property. This property is related to the combining form of construction in Backus's functional programming system called FP. We express this property in our system by two extra reduction rules, which we call γ-rules. Our extension helps reducing the gap between type-free lambda-calculus and high-level functional languages. The main purpose of this paper is to prove the consistency of this extended lambda-calculus by showing that it satisfies the Church—Rosser theorem.

Real-time functional programming systems

Real-time processing systems are typically characterised by high processing rates, high reliability, and high input/output rates. Functional programming, derived from the lambda calculus, is a formal basis for computation which facilitates the design of well-structured, highly reliable programs, and also enables a rigorous implementation on parallel hardware to provide high processing rates and I/O bandwidth. The principles of CTDNet2, a new reduction mechanism for real-time applications based on graph reduction, and a combination of eager and lazy evaluation, are presented. CTDNet2 has been designed with real-time processing in mind, and is intended for highly parallel multiprocessor implementation. It is particularly suitable for transputer networks.

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.

Comparing two functional programming systems

A technique is presented for comparing the performance of functional languages with different evaluation strategies running on different machines. A set of small benchmarks is used, and th execution times of these programs running in the functional language and in the implementation language of the functional system are compared. The ratio of these execution times measured how well the functional system used the resources of the underlying hardware and implementation language. Also two functional programming systems are described. One system is a graph reduction interpreter for lambda calculus. The other is a DEL-style intermediate instruction set architecture for FP. The benchmarks in FP and the performances of the two systems on these benchmarks are presented.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Functional Programming and Operating Systems

Functional Programming and Operating Systems

Experiments with applicative updating: Practical results

Large scale computing applications often consist of calculations that are repeated for many sets of input data. If the variance between the data sets is small, there may be portions of the computation which are not affected by the changes in the input values. The effort required for such systems can be reduced with efficient methods of recomputation. This paper presents an approach for efficient recomputation over function graphs. A change to an input value of a previously computed function initiates a process of retraction along the data paths dependent on that input. The retraction process consists of first tracing the paths from the input to the output, noting along the way that a change is impending, then tracing back from the output to the input, removing the previously computed values from the intermediate nodes. The modified input value is then released into the function graph, and the retracted portions of the graph are recomputed. Throughout this process, all nonretracted output values are an accurate reflection of the current input values. A retraction mechanism that allows efficient recomputation increases the usefulness of functional programming systems. We present the results of some experiments showing the time taken by the recomputation for two different types of problems. We propose the characteristics of function graphs for which this technique will be most effective.