Implementation Of Functional Languages Research Articles

Derivative grammars: a symbolic approach to parsing with derivatives

We present a novel approach to context-free grammar parsing that is based on generating a sequence of grammars called derivative grammars from a given context-free grammar and input string. The generation of the derivative grammars is described by a few simple inference rules. We present an O ( n 2 ) space and O ( n 3 ) time recognition algorithm, which can be extended to generate parse trees in O ( n 3 ) time and O ( n 2 log n ) space. Derivative grammars can be viewed as a symbolic approach to implementing the notion of derivative languages , which was introduced by Brzozowski. Might and others have explored an operational approach to implementing derivative languages in which the context-free grammar is encoded as a collection of recursive algebraic data types in a functional language like Haskell. Functional language implementation features like knot-tying and lazy evaluation are exploited to ensure that parsing is done correctly and efficiently in spite of complications like left-recursion. In contrast, our symbolic approach using inference rules can be implemented easily in any programming language and we obtain better space bounds for parsing. Reifying derivative languages by encoding them symbolically as grammars also enables formal connections to be made for the first time between the derivatives approach and classical parsing methods like the Earley and LL/LR parsers. In particular, we show that the sets of Earley items maintained by the Earley parser implicitly encode derivative grammars and we give a procedure for producing derivative grammars from these sets. Conversely, we show that our derivative grammar recognizer can be transformed into the Earley recognizer by optimizing some of its bookkeeping. These results suggest that derivative grammars may provide a new foundation for context-free grammar recognition and parsing.

A NECESSARY AND SUFFICIENT CONDITION FOR THE UNIQUENESS OF $ \beta\delta $-NORMAL FORM OF TYPED $ \lambda $-TERMS FOR THE CANONICAL NOTION OF $ \delta $-REDUCTION

In this paper the canonical notion of $ \delta $-reduction is considered. Typed $ \lambda $-terms use variables of any order and constants of order $ \leq 1 $, where the constants of order 1 are strongly computable, monotonic functions with indeterminate values of arguments. The canonical notion of $ \delta $-reduction is the notion of $ \delta $-reduction that is used in the implementation of functional programming languages. It is shown that for canonical notion of $ \delta $-reduction SI-property is the necessary and sufficient condition for the uniqueness of $ \beta\delta $-normal form of typed $ \lambda $-terms.

ON THE UNIQUENESS OF $ \beta\delta $-NORMAL FORM OF TYPED $ \lambda $-TERMS FOR THE CANONICAL NOTION OF $ \delta $-REDUCTION

In this paper we consider a substitution and inheritance property, which is the necessary and sufficient condition for the uniqueness of $ \beta\delta $-normal form of typed $ \lambda $-terms, for canonical notion of $ \delta $-reduction. Typed $ \lambda $-terms use variables of any order and constants of order $ \leq 1 $, where the constants of order 1 are strongly computable, monotonic functions with indeterminate values of arguments. The canonical notion of $ \delta $-reduction is the notion of $ \delta $-reduction that is used in the implementation of functional programming languages.

On Church-Rosser Property of Notion of βδ-Reduction for Canonical Notion of δ-Reduction

In this paper the canonical notions of δ-reduction for typed λ-terms are considered. Typed λ-terms use variables of any order and constants of order ≤ 1, where constants of order 1 are strongly computable, monotonic functions with indeterminate values of arguments. The canonical notions of δ-reduction are the notions of δ-reduction that are used in the implementations of functional programming languages. It is shown that for the main canonical notion of δ-reduction the notion of βδ-reduction has the Church-Rosser property. It is also shown that there exists a canonical notion of δ-reduction such that the notion of βδ-reduction does not have Church-Rosser property.

ON MAIN CANONICAL NOTION OF $ \delta $-REDUCTION

In this paper the main canonical notion of $ \delta $-reduction is considered. Typed $ \lambda $-terms use variables of any order and constants of order $ \leq 1 $, where constants of order 1 are strongly computable, monotonic functions with indeterminate values of arguments. The canonical notion of $ \delta $-reduction is the notion of $ \delta $-reduction that is used in the implementation of functional programming languages. For main canonical notion of d-reduction the uniqueness of $ \beta\delta $-normal form of typed $ \lambda $-terms is shown.

Hierarchical memory management for mutable state

It is well known that modern functional programming languages are naturally amenable to parallel programming. Achieving efficient parallelism using functional languages, however, remains difficult. Perhaps the most important reason for this is their lack of support for efficient in-place updates, i.e., mutation, which is important for the implementation of both parallel algorithms and the run-time system services (e.g., schedulers and synchronization primitives) used to execute them. In this paper, we propose techniques for efficient mutation in parallel functional languages. To this end, we couple the memory manager with the thread scheduler to make reading and updating data allocated by nested threads efficient. We describe the key algorithms behind our technique, implement them in the MLton Standard ML compiler, and present an empirical evaluation. Our experiments show that the approach performs well, significantly improving efficiency over existing functional language implementations.

Functional BIP: Embedding connectors in functional programming languages

This paper presents a theoretical foundation for functional language implementations of Behaviour–Interaction–Priority (BIP). We introduce a set of connector combinators describing synchronisation, data transfer, priorities and dynamicity in a principled way. A static type system ensures the soundness of connector semantics.Based on this foundation, we implemented BIP as an embedded domain specific language (DSL) in Haskell and Scala. The DSL embedding allows programmers to benefit from the full expressive power of high-level languages. The clear separation of behaviour and coordination inherited from BIP leads to systems that are arguably simpler to maintain and reason about, compared to other approaches.

ON CANONICAL NOTION OF $\delta$-REDUCTION AND ON TRANSLATION OF TYPED $\lambda$-TERMS INTO UNTYPED $\lambda$-TERMS

In the paper typed and untyped $\lambda$-terms are considered. Typed $\lambda$-terms use variables of any order and constants of order $\leq$1. Constants of order 1 are strong computable functions with indeterminate values of arguments and every function has an untyped $\lambda$-term that $\lambda$-defines it. The so-called canonical notion of $\delta$-reduction is introduced. This is the notion of $\delta$-reduction that is used in the implementation of functional programming languages. For the canonical notion of $\delta$-reduction the translation of typed $\lambda$-terms into untyped $\lambda$-terms is studied.

Exploiting diversity in type checkers for better error messages

Producing precise and helpful type error messages has been a challenge for the implementations of functional programming languages for over 3 decades now. Many different approaches and methods have been tried to solve this thorny problem, but current type-error reporting tools still suffer from a lack of precision in many cases. Based on the observation that different approaches work well in different situations, we have studied the question of whether a combination of tools that exploits their diversity can lead to improved accuracy. Specifically, we have studied Helium, a Haskell implementation particularly aimed at producing good type error messages, and Lazy Typing, an approach developed previously by us to address the premature-error-commitment problem in type checkers. By analyzing the respective strengths and weaknesses of the two approaches we were able to identify a strategy to combine both tools that could markedly improve the accuracy of reported errors. Specifically, we report an evaluation of 1069 unique ill-typed programs out of a total of 11,256 Haskell programs that reveals that this combination strategy enjoys a correctness rate of 82%, which is an improvement of 25%/20% compared to using Lazy Typing/Helium alone. In addition to describing this particular case study, we will also report insights we gained into the combination of error-reporting tools in general.

From Push/Enter to Eval/Apply by Program Transformation

Push/enter and eval/apply are two calling conventions used in implementations of functional languages. In this paper, we explore the following observation: when considering functions with multiple arguments, the stack under the push/enter and eval/apply conventions behaves similarly to two particular implementations of the list datatype: the regular cons-list and a form of lists with lazy concatenation respectively. Along the lines of Danvy et al.'s functional correspondence between definitional interpreters and abstract machines, we use this observation to transform an abstract machine that implements push/enter into an abstract machine that implements eval/apply. We show that our method is flexible enough to transform the push/enter Spineless Tagless G-machine (which is the semantic core of the GHC Haskell compiler) into its eval/apply variant.

The Reduceron reconfigured and re-evaluated

AbstractA new version of a special-purpose processor for running lazy functional programs is presented. This processor – the Reduceron – exploits parallel memories and dynamic analyses to increase evaluation speed, and is implemented using reconfigurable hardware. Compared to a more conventional functional language implementation targeting a standard RISC processor running on the same reconfigurable hardware, the Reduceron offers a significant improvement in run-time performance.

Repetitive Reduction Patterns in Lambda Calculus with letrec (Work in Progress)

For the lambda-calculus with letrec we develop an optimisation, which is based on the contraction of a certain class of 'future' (also: virtual) redexes. In the implementation of functional programming languages it is common practice to perform beta-reductions at compile time whenever possible in order to produce code that requires fewer reductions at run time. This is, however, in principle limited to redexes and created redexes that are 'visible' (in the sense that they can be contracted without the need for unsharing), and cannot generally be extended to redexes that are concealed by sharing constructs such as letrec. In the case of recursion, concealed redexes become visible only after unwindings during evaluation, and then have to be contracted time and again. We observe that in some cases such redexes exhibit a certain form of repetitive behaviour at run time. We describe an analysis for identifying binders that give rise to such repetitive reduction patterns, and eliminate them by a sort of predictive contraction. Thereby these binders are lifted out of recursive positions or eliminated altogether, as a result alleviating the amount of beta-reductions required for each recursive iteration. Both our analysis and simplification are suitable to be integrated into existing compilers for functional programming languages as an additional optimisation phase. With this work we hope to contribute to increasing the efficiency of executing programs written in such languages.

Trends in Trends in Functional Programming 1999/2000 versus 2007/2008

The Trends in Functional Programming Symposia are an annual event dedicated to promoting new research directions in functional programming and to investigating the relationship between functional programming and other branches of Computer Science. The TFP series started in 1999 and the 2008 meeting marked the first decade of the symposium. In this paper we identify and discuss the trends presented at TFP using a macro-vision lens that looks at topics in the first two volumes of TFP and the two most recent volumes of TFP. The goal is to calibrate how trends have changed over a decade instead of analyzing trends with a micro-vision lens that focuses on changes from year to year. The major trends identified are work on parallel functional programming, types, formal verification, implementation of functional languages, and application development.

The Peter Landin prize

The Peter Landin prize honours the best paper presented at each year's International Symposium on the Implementation and Application of Functional Languages (IFL). It has been awarded every year since 2003, and covers a range of topics including functional operating systems, static analysis for cost information of functional programs, techniques to improve array processing for data locality and parallelism, explicit parallel coordination, supercompilation, and a rational deconstruction of Landin's SECD machine itself. This article describes the history of the prize, explains why Peter Landin was chosen as nominee, and describes each of the articles that have been awarded the prize to date.

Regular-expression derivatives re-examined

AbstractRegular-expression derivatives are an old, but elegant, technique for compiling regular expressions to deterministic finite-state machines. It easily supports extending the regular-expression operators with boolean operations, such as intersection and complement. Unfortunately, this technique has been lost in the sands of time and few computer scientists are aware of it. In this paper, we reexamine regular-expression derivatives and report on our experiences in the context of two different functional-language implementations. The basic implementation is simple and we show how to extend it to handle large character sets (e.g., Unicode). We also show that the derivatives approach leads to smaller state machines than the traditional algorithm given by McNaughton and Yamada.

Declaring Numbers

Most implementations of functional and functional logic languages treat numbers and the basic numeric operations as external entities. The main reason for this is efficiency. However, this basic design decision has many unfortunate consequences for all programs using numbers. We present an approach to model numbers in a declarative way and argue that the loss in efficiency is compensated by the newly gained possibilities. Functional logic languages benefit the most from this proposal because all the numeric operations become fully narrowable. This enables the solving of simple equations on numbers in an efficient way without having to resort to external constraint solvers.The presented approach can either be used as a library for purely declarative numbers or it can be employed as a basic data type of functional (logic) languages. Indeed, we have integrated the presented data structures as the only numbers available in our compiler for the functional logic language Curry.

Explaining the lazy Krivine machine using explicit substitution and addresses

In a previous paper, Benaissa, Lescanne, and Rose, have extended the weak lambda-calculus of explicit substitution λ σ w with addresses, so that it gives an account of the sharing implemented by lazy functional language interpreters. We show in this paper that their calculus, called λ σ a w , fits well to the lazy Krivine machine, which describes the core of a lazy (call-by-need) functional programming language implementation. The lazy Krivine machine implements term evaluation sharing, that is essential for efficiency of such languages. The originality of our proof is that it gives a very detailed account of the implemented strategy.

The next 700 Krivine machines

The Krivine machine is a simple and natural implementation of the normal weak-head reduction strategy for pure ?-terms. While its original description has remained unpublished, this machine has served as a basis for many variants, extensions and theoretical studies. In this paper, we present the Krivine machine and some well-known variants in a common framework. Our framework consists of a hierarchy of intermediate languages that are subsets of the ?-calculus. The whole implementation process (compiler?+?abstract machine) is described via a sequence of transformations all of which express an implementation choice. We characterize the essence of the Krivine machine and locate it in the design space of functional language implementations. We show that, even within the particular class of Krivine machines, hundreds of variants can be designed.

Lazy Context Cloning for Non-Deterministic Graph Rewriting

We define a rewrite strategy for a class of non-confluent constructor-based term graph rewriting systems and prove its correctness. Our strategy and its extension to narrowing are intended for the implementation of non-strict non-deterministic functional logic programming languages. Our strategy is based on a graph transformation, called bubbling, that avoids the construction of large contexts of redexes with distinct replacements, an expensive and frequently wasteful operation executed by competitive complete techniques.

Structure and Properties of Traces for Functional Programs

The tracer Hat records in a detailed trace the computation of a program written in the lazy functional language Haskell. The trace can then be viewed in various ways to support program comprehension and debugging. The trace was named the augmented redex trail. Its structure was inspired by standard graph rewriting implementations of functional languages. Here we describe a model of the trace that captures its essential properties and allows formal reasoning. The trace is a graph constructed by graph rewriting but goes beyond simple term graphs. Although the trace is a graph whose structure is independent of any rewriting strategy, we define the trace inductively, thus giving us a powerful method for proving its properties.