Results 1  10
of
11
Pure Pattern Type Systems
 In POPL’03
, 2003
"... We introduce a new framework of algebraic pure type systems in which we consider rewrite rules as lambda terms with patterns and rewrite rule application as abstraction application with builtin matching facilities. This framework, that we call “Pure Pattern Type Systems”, is particularly wellsuite ..."
Abstract

Cited by 43 (20 self)
 Add to MetaCart
We introduce a new framework of algebraic pure type systems in which we consider rewrite rules as lambda terms with patterns and rewrite rule application as abstraction application with builtin matching facilities. This framework, that we call “Pure Pattern Type Systems”, is particularly wellsuited for the foundations of programming (meta)languages and proof assistants since it provides in a fully unified setting higherorder capabilities and pattern matching ability together with powerful type systems. We prove some standard properties like confluence and subject reduction for the case of a syntactic theory and under a syntactical restriction over the shape of patterns. We also conjecture the strong normalization of typable terms. This work should be seen as a contribution to a formal connection between logics and rewriting, and a step towards new proof engines based on the CurryHoward isomorphism.
Rewriting calculus with fixpoints: Untyped and firstorder systems
 In Postproceedings of TYPES, Lecture Notes in Computer Science
, 2003
"... Abstract The rewriting calculus, also called ρcalculus, is a framework embedding λcalculus and rewriting capabilities, by allowing abstraction not only on variables but also on patterns. The higherorder mechanisms of the λcalculus and the pattern matching facilities of the rewriting are then bot ..."
Abstract

Cited by 26 (10 self)
 Add to MetaCart
Abstract The rewriting calculus, also called ρcalculus, is a framework embedding λcalculus and rewriting capabilities, by allowing abstraction not only on variables but also on patterns. The higherorder mechanisms of the λcalculus and the pattern matching facilities of the rewriting are then both available at the same level. Many type systems for the λcalculus can be generalized to the ρcalculus: in this paper, we study extensively a firstorder ρcalculus à la Church, called ρ stk The type system of ρ stk � allows one to type (object oriented flavored) fixpoints, leading to an expressive and safe calculus. In particular, using pattern matching, one can encode and typecheck term rewriting systems in a natural and automatic way. Therefore, we can see our framework as a starting point for the theoretical basis of a powerful typed rewritingbased language.
Rewrite Strategies in the Rewriting Calculus
 WRS 2003
, 2003
"... This paper presents an overview on the use of the rewriting calculus to express rewrite strategies. We motivate first the use of rewrite strategies by examples in the ELAN language. We then show how this has been modeled in the initial version of the rewriting calculus and how the matching power of ..."
Abstract

Cited by 18 (7 self)
 Add to MetaCart
This paper presents an overview on the use of the rewriting calculus to express rewrite strategies. We motivate first the use of rewrite strategies by examples in the ELAN language. We then show how this has been modeled in the initial version of the rewriting calculus and how the matching power of this framework facilitates the representation of powerful strategies.
A rewriting calculus for cyclic higherorder term graphs
 in "2nd International Workshop on Term Graph Rewriting  TERMGRAPH’2004
, 2004
"... graphs ..."
A DomainSpecific Language for Incremental and Modular Design of LargeScale VerifiablySafe Flow Networks (Preliminary Report)
"... We define a domainspecific language (DSL) to inductively assemble flow networks from small networks or modules to produce arbitrarily large ones, with interchangeable functionallyequivalent parts. Our small networks or modules are “small ” only as the building blocks in this inductive definition ( ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
We define a domainspecific language (DSL) to inductively assemble flow networks from small networks or modules to produce arbitrarily large ones, with interchangeable functionallyequivalent parts. Our small networks or modules are “small ” only as the building blocks in this inductive definition (there is no limit on their size). Associated with our DSL is a type theory, a system of formal annotations to express desirable properties of flow networks together with rules that enforce them as invariants across their interfaces, i.e., the rules guarantee the properties are preserved as we build larger networks from smaller ones. A prerequisite for a type theory is a formal semantics, i.e., a rigorous definition of the entities that qualify as feasible flows through the networks, possibly restricted to satisfy additional efficiency or safety requirements. This can be carried out in one of two ways, as a denotational semantics or as an operational (or reduction) semantics; we choose the first in preference to the second, partly to avoid exponentialgrowth rewriting in the operational approach. We set up a typing system and prove its soundness for our DSL. 1
Translating Combinatory Reduction Systems into the Rewriting Calculus
 in « 4th International Workshop on RuleBased Programming (RULE 2003
, 2003
"... The last few years have seen the development of the rewriting calculus (or rhocalculus, ρCal) that extends first order term rewriting and λcalculus. The integration of these two latter formalisms has been already handled either by enriching firstorder rewriting with higherorder capabilities, like ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
The last few years have seen the development of the rewriting calculus (or rhocalculus, ρCal) that extends first order term rewriting and λcalculus. The integration of these two latter formalisms has been already handled either by enriching firstorder rewriting with higherorder capabilities, like in the Combinatory Reduction Systems, or by adding to λcalculus algebraic features. The different higherorder rewriting systems and the rewriting calculus share similar concepts and have similar applications, and thus, it seems natural to compare these formalisms. We analyze in this paper the relationship between the Rewriting Calculus and the Combinatory Reduction Systems and we present a translation of CRSterms and rewrite rules into rhoterms and we show that for any CRSreduction we have a corresponding rhoreduction. 1
From functional programs to interaction nets via the Rewriting Calculus
 WRS 2006 PRELIMINARY VERSION
, 2006
"... We use the ρcalculus as an intermediate language to compile functional languages with patternmatching features, and give an interaction net encoding of the ρterms arising from the compilation. This encoding gives rise to new strategies of evaluation, where patternmatching and ‘traditional ’ βre ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
We use the ρcalculus as an intermediate language to compile functional languages with patternmatching features, and give an interaction net encoding of the ρterms arising from the compilation. This encoding gives rise to new strategies of evaluation, where patternmatching and ‘traditional ’ βreduction can proceed in parallel without overheads.
iRho: an imperative rewriting calculus
, 2008
"... We propose an imperative version of the Rewriting Calculus, a calculus based on pattern matching, pattern abstraction and side effects, which we call iRho. We formulate both a static and bigstep callbyvalue operational semantics of iRho. The operational semantics is deterministic, and immediately ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
We propose an imperative version of the Rewriting Calculus, a calculus based on pattern matching, pattern abstraction and side effects, which we call iRho. We formulate both a static and bigstep callbyvalue operational semantics of iRho. The operational semantics is deterministic, and immediately suggests how an interpreter for the calculus may be built. The static semantics is given using a firstorder type system based on a form of product types, which can be assigned to termlike structures (that is, records). The calculus is à la Church, that is, pattern abstractions are decorated with the types of the free variables of the pattern. iRho is a good candidate for the core of a patternmatching imperative language, where a (monomorphic) typed store can be safely manipulated and where fixed points are built into the language itself. Properties such as determinism of the interpreter and subjectreduction have been completely checked using a machineassisted approach with the Coq proof assistant. Progress and decidability of type checking are proved using pen and paper.
2. Overall Objectives........................................................................ 1 2.1. LogNet’s Motto and Logo 1
"... c t i v it y e p o r t ..."