Results 11  20
of
24
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.
Compiling Lazy Pattern Matching
 In Proc. of the 1992 conference on Lisp and Functional Programming
, 1992
"... this paper we take a more direct approach: we compile pattern matching on overlapping patterns. We first recall the semantics of lazy pattern matching, as given by A. Laville [5]. Then, we explain our compilation technique as a source to source transformation. Given a set of patterns, several compil ..."
Abstract

Cited by 11 (4 self)
 Add to MetaCart
(Show Context)
this paper we take a more direct approach: we compile pattern matching on overlapping patterns. We first recall the semantics of lazy pattern matching, as given by A. Laville [5]. Then, we explain our compilation technique as a source to source transformation. Given a set of patterns, several compilations are possible, we prove that they all satisfy a partial correctness
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.
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.
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.
Open Pattern Matching for C++
"... Pattern matching is an abstraction mechanism that can greatly simplify source code. We present functionalstyle pattern matching for C++ implemented as a library, called Mach7 1. All the patterns are userdefinable, can be stored in variables, passed among functions, and allow the use of class hiera ..."
Abstract
 Add to MetaCart
Pattern matching is an abstraction mechanism that can greatly simplify source code. We present functionalstyle pattern matching for C++ implemented as a library, called Mach7 1. All the patterns are userdefinable, can be stored in variables, passed among functions, and allow the use of class hierarchies. As an example, we implement common patterns used in functional languages. Our approach to pattern matching is based on compiletime composition of pattern objects through concepts. This is superior (in terms of performance and expressiveness) to approaches based on runtime composition of polymorphic pattern objects. In particular, our solution allows mapping functional code based on pattern matching directly into C++ and produces code that is only a few percent slower than handoptimized C++ code. The library uses an efficient type switch construct, further extending it to multiple scrutinees and general patterns. We compare the performance of pattern matching to that of double dispatch and open multimethods in C++.