Results 11  20
of
23
Strong Sequentiality of LeftLinear Overlapping Rewrite Systems
 Proc. of Workshop on Conditional Term Rewriting Systems, CTRS'94, LNCS 968:235246
, 1994
"... . Confluent term rewriting systems can be seen as a model for functional computations, in which redexes corresponding to instances of left hand sides of rules are repeatedly replaced by their corresponding right hand side instance. Lazy sequential strategies reduce a given redex in a term if and onl ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
(Show Context)
. Confluent term rewriting systems can be seen as a model for functional computations, in which redexes corresponding to instances of left hand sides of rules are repeatedly replaced by their corresponding right hand side instance. Lazy sequential strategies reduce a given redex in a term if and only if this redex must be reduced by any other sequential strategy computing the normal form of the term. Lazy strategies always terminate when a normal form exist, and are indeed optimal. In a landmark paper, Huet and Levy showed that such a strategy always exists for left linear nonoverlapping rewrite systems that are strongly sequential, a property that they proved decidable for such systems. This paper generalises the result to the case of leftlinear, possibly overlapping rewrite systems. 1 Introduction Confluent term rewriting systems can be seen as a model for functional computations, in which redexes corresponding to instances of left hand sides of rules are repeatedly replaced by the...
Fast Parallel Implementation of Lazy Languages  The EQUALS Experience
 Journal of Functional Programming
, 1992
"... This paper describes equals, a fast parallel implementation of a lazy functional language on a commercially available sharedmemory parallel machine, the Sequent Symmetry. In contrast to previous implementations, we detect parallelism automatically using strictness analysis. Another important differ ..."
Abstract

Cited by 11 (4 self)
 Add to MetaCart
(Show Context)
This paper describes equals, a fast parallel implementation of a lazy functional language on a commercially available sharedmemory parallel machine, the Sequent Symmetry. In contrast to previous implementations, we detect parallelism automatically using strictness analysis. Another important difference between equals and previous implementations is the use of reference counting for memory management, instead of garbage collection. Our implementation shows that reference counting leads to very good scalability, low memory requirements and improved locality. We compare our results with other sequential (SML/NJ) and parallel (h; Gimachine and GAML) implementations of functional languages.
When Do MatchCompilation Heuristics Matter?
, 2000
"... Modern, statically typed, functional languages define functions by pattern matching. Although pattern matching is defined in terms of sequential checking of a value against one pattern after another, real implementations translate patterns into automata that can test a value against many pattern ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
Modern, statically typed, functional languages define functions by pattern matching. Although pattern matching is defined in terms of sequential checking of a value against one pattern after another, real implementations translate patterns into automata that can test a value against many patterns at once. Decision trees are popular automata.
Some Practical Aspects of Dependent Datatypes
"... The mechanism for declaring datatypes to model data structures in functional programming languages such as Standard ML and Haskell can offer both convenience in programming and clarity in code. With the introduction of dependent datatypes in DML, the programmer can model data structures more accur ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
The mechanism for declaring datatypes to model data structures in functional programming languages such as Standard ML and Haskell can offer both convenience in programming and clarity in code. With the introduction of dependent datatypes in DML, the programmer can model data structures more accurately, capturing more program invariants. In this paper, we study some practical aspects of dependent datatypes that affect both typechecking and compiling pattern matching as well as datatype representation. The results, which have already been tested, demonstrate that dependent datatype can not only offer various programming benefits but also lead to performance gains, yielding a concrete case where safer programs run faster.
The Coq Proof Assistant  Reference Manual Version 6.1
, 1997
"... : Coq is a proof assistant based on a higherorder logic allowing powerful definitions of functions. Coq V6.1 is available by anonymous ftp at ftp.inria.fr:/INRIA/Projects/coq/V6.1 and ftp.enslyon.fr:/pub/LIP/COQ/V6.1 Keywords: Coq, Proof Assistant, Formal Proofs, Calculus of Inductives Constru ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
: Coq is a proof assistant based on a higherorder logic allowing powerful definitions of functions. Coq V6.1 is available by anonymous ftp at ftp.inria.fr:/INRIA/Projects/coq/V6.1 and ftp.enslyon.fr:/pub/LIP/COQ/V6.1 Keywords: Coq, Proof Assistant, Formal Proofs, Calculus of Inductives Constructions (R'esum'e : tsvp) This research was partly supported by ESPRIT Basic Research Action "Types" and by the GDR "Programmation " cofinanced by MREPRC and CNRS. Unit'e de recherche INRIA Rocquencourt Domaine de Voluceau, Rocquencourt, BP 105, 78153 LE CHESNAY Cedex (France) T'el'ephone : (33 1) 39 63 55 11  T'el'ecopie : (33 1) 39 63 53 30 Manuel de r'ef'erence du syst`eme Coq version V6.1 R'esum'e : Coq est un syst`eme permettant le d'eveloppement et la v'erification de preuves formelles dans une logique d'ordre sup'erieure incluant un riche langage de d'efinitions de fonctions. Ce document constitue le manuel de r'ef'erence de la version V6.1 qui est distribu 'ee par ftp ...
Fast Strictness Analysis Based on Demand Propagation
 ACM Transactions on Programming Languages and Systems
, 1995
"... Interpretation versus Demand Propagation Wadler [1987] uses abstract interpretation over a fourpoint domain for reasoning about strictness on lists. The four points correspond to undefined list (represented by value 0), infinite lists and lists with some tail undefined (value 1), lists with at lea ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Interpretation versus Demand Propagation Wadler [1987] uses abstract interpretation over a fourpoint domain for reasoning about strictness on lists. The four points correspond to undefined list (represented by value 0), infinite lists and lists with some tail undefined (value 1), lists with at least one head undefined (value 2), and all lists (value 3). Burn's work [Burn 1987] on evaluation transformers also uses abstract interpretation on the abovementioned domain for strictness analysis. He defines four evaluators that correspond to the four points mentioned above in the sense that the ith evaluator will fail to produce an answer when given a list with the abstract value i \Gamma 1.
Free Sequentiality in Orthogonal OrderSorted Rewriting Systems with Constructors
 In Proc. 11th Int. Conf. on Automated Deduction
, 1992
"... We introduce the notions of sequentiality and strong sequentiality in ordersorted rewriting systems, both closely related to the subsort order and to the form of declarations of the signature. We define free sequentiality for the class of orthogonal systems with constructors, a notion which does not ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
We introduce the notions of sequentiality and strong sequentiality in ordersorted rewriting systems, both closely related to the subsort order and to the form of declarations of the signature. We define free sequentiality for the class of orthogonal systems with constructors, a notion which does not impose conditions over the signature. We provide an effective decision procedure for free sequentiality that gives at the same time a simple construction of a nondeterministic pattern matching tree. These trees describe how the refinement of sorts and structures has to be done along the reduction sequence in such a way that wasteful computations are avoided.
SIMPLIFYING THE ANALYSIS OF C++ PROGRAMS
, 2013
"... Based on our experience of working with different C++ front ends, this thesis identifies numerous problems that complicate the analysis of C++ programs along the entire spectrum of analysis applications. We utilize library, language, and tool extensions to address these problems and offer solutions ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Based on our experience of working with different C++ front ends, this thesis identifies numerous problems that complicate the analysis of C++ programs along the entire spectrum of analysis applications. We utilize library, language, and tool extensions to address these problems and offer solutions to many syntax trees of a program, which together render the visitor design pattern obsolete. We further extend C++ with open multimethods to deal with the broader expression problem. Finally, we offer two techniques, one based on refining the type system of a language and the other on abstract interpretation, both of which allow developers to statically ensure or verify various runtime properties of their programs without having to deal with the full language semantics or even the abstract syntax tree of a program. Together, the solutions presented in this thesis make ensuring properties of interest about C++ programs available to average language users.
A Framework for Lazy Parallel Evaluation of Equational Programs
"... Strongly sequential systems, developed by Huet and Levy [HL79], has formed the basis of equational programming languages. Experience with such languages so far suggests that even complex equational programs are based only on strongly sequential systems with constructors. ..."
Abstract
 Add to MetaCart
Strongly sequential systems, developed by Huet and Levy [HL79], has formed the basis of equational programming languages. Experience with such languages so far suggests that even complex equational programs are based only on strongly sequential systems with constructors.
Regular Expression Pattern Matching for XML
"... We propose regular expression pattern matching as a core feature for programming languages for manipulating XML (and similar treestructured data formats). We extend conventional patternmatching facilities with regular expression operators uch as repetition (*), alternation (I), etc., that can mat ..."
Abstract
 Add to MetaCart
We propose regular expression pattern matching as a core feature for programming languages for manipulating XML (and similar treestructured data formats). We extend conventional patternmatching facilities with regular expression operators uch as repetition (*), alternation (I), etc., that can match arbitrarily long sequences of subtrees, allowing a compact pattern to extract data from the middle of a complex sequence. We show how to check standard notions of exhaustiveness and redundancy for these patterns. Regular expression patterns are intended to be used in languages whose type systems are also based on the regular expression types. To avoid excessive type annotations, we develop a type inference scheme that propagates type constraints to pattern variables from the surrounding context. The type inference algorithm translates types and patterns into regular tree automata nd then works in terms of standard closure operations (union, intersection, and difference) on tree automata. The main technical challenge is dealing with the interaction of repetition and alternation patterns with the firstmatch policy, which gives rise to subtleties concerning both the termination and the precision of the analysis. We address these issues by introducing a data structure representing closure operations lazily. 1