Results 11  20
of
56
Recursion for HigherOrder Encodings
"... This paper describes a calculus of partial recursive functions that range over arbitrary and possibly higherorder objects in LF [HHP93]. Its most novel features include recursion under lambdabinders and matching against dynamically introduced parameters. ..."
Abstract

Cited by 19 (11 self)
 Add to MetaCart
This paper describes a calculus of partial recursive functions that range over arbitrary and possibly higherorder objects in LF [HHP93]. Its most novel features include recursion under lambdabinders and matching against dynamically introduced parameters.
Scrap your Nameplate  Functional Pearl
"... Recent research has shown how boilerplate code, or repetitive code for traversing datatypes, can be eliminated using generic programming techniques already available within some implementations of Haskell. One particularly intractable kind of boilerplate is nameplate, or code having to do with names ..."
Abstract

Cited by 17 (5 self)
 Add to MetaCart
Recent research has shown how boilerplate code, or repetitive code for traversing datatypes, can be eliminated using generic programming techniques already available within some implementations of Haskell. One particularly intractable kind of boilerplate is nameplate, or code having to do with names, namebinding, and fresh name generation. One reason for the difficulty is that operations on data structures involving names, as usually implemented, are not regular instances of standard map, fold , or zip operations. However, in nominal abstract syntax, an alternative treatment of names and binding based on swapping, operations such as #equivalence, captureavoiding substitution, and free variable set functions are much betterbehaved.
A Universe of Binding and Computation
"... We construct a logical framework supporting datatypes that mix binding and computation, implemented as a universe in the dependently typed programming language Agda 2. We represent binding pronominally, using wellscoped de Bruijn indices, so that types can be used to reason about the scoping of var ..."
Abstract

Cited by 17 (5 self)
 Add to MetaCart
We construct a logical framework supporting datatypes that mix binding and computation, implemented as a universe in the dependently typed programming language Agda 2. We represent binding pronominally, using wellscoped de Bruijn indices, so that types can be used to reason about the scoping of variables. We equip our universe with datatypegeneric implementations of weakening, substitution, exchange, contraction, and subordinationbased strengthening, so that programmers need not reimplement these operations for each individual language they define. In our mixed, pronominal setting, weakening and substitution hold only under some conditions on types, but we show that these conditions can be discharged automatically in many cases. Finally, we program a variety of standard difficult test cases from the literature, such as normalizationbyevaluation for the untyped λcalculus, demonstrating that we can express detailed invariants about variable usage in a program’s type while still writing clean and clear code.
A Dependent Type Theory with Names and Binding
 In Proceedings of the 2004 Computer Science Logic Conference, number 3210 in Lecture notes in Computer Science
, 2004
"... We consider the problem of providing formal support for working with abstract syntax involving variable binders. Gabbay and Pitts have shown in their work on FraenkelMostowski (FM) set theory how to address this through firstclass names: in this paper we present a dependent type theory for prog ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
We consider the problem of providing formal support for working with abstract syntax involving variable binders. Gabbay and Pitts have shown in their work on FraenkelMostowski (FM) set theory how to address this through firstclass names: in this paper we present a dependent type theory for programming and reasoning with such names. Our development is based on a categorical axiomatisation of names, with freshness as its central notion. An associated adjunction captures constructions known from FM theory: the freshness quantifier N , namebinding, and unique choice of fresh names. The Schanuel topos  the category underlying FM set theory  is an instance of this axiomatisation.
A Monadic Multistage Metalanguage
, 2003
"... We describe a metalanguage MMML, which makes explicit the order of evaluation (in the spirit of monadic metalanguages) and the staging of computations (as in languages for multilevel bindingtime analysis). The main contribution of the paper is an operational semantics which is sufficiently detaile ..."
Abstract

Cited by 15 (7 self)
 Add to MetaCart
We describe a metalanguage MMML, which makes explicit the order of evaluation (in the spirit of monadic metalanguages) and the staging of computations (as in languages for multilevel bindingtime analysis). The main contribution of the paper is an operational semantics which is sufficiently detailed for analyzing subtle aspects of multistage programming, but also intuitive enough to serve as a reference semantics. For instance, the separation of computational types from code types, makes clear the distinction between a computation for generating code and the generated code, and provides a basis for multilingual extensions, where a variety of programming languages (aka monads) coexist. The operational semantics consists of two parts: local (semantics preserving) simplification rules, and computation steps executed in a deterministic order (because they may have sideeffects). We focus on the computational aspects, thus we adopt a simple type system, that can detect usual type errors, but not the unresolved link errors. Because of its explicit annotations, MMML is suitable as an intermediate language.
Fine Control of Demand in Haskell
 In 6th International Conference on the Mathematics of Program Construction, Dagstuhl
, 2002
"... Functional languages have the Acalculus at their core, but then depart fi'om this fu'm foundation by including features that alter their default evaluation order. The resulting mixed evaluationpartly lazy and partly strictcomplicates the formal semantics of these languages. ..."
Abstract

Cited by 13 (6 self)
 Add to MetaCart
Functional languages have the Acalculus at their core, but then depart fi'om this fu'm foundation by including features that alter their default evaluation order. The resulting mixed evaluationpartly lazy and partly strictcomplicates the formal semantics of these languages.
Relating StateBased and ProcessBased Concurrency through Linear Logic
, 2006
"... This paper has the purpose of reviewing some of the established relationships between logic and concurrency, and of exploring new ones. Concurrent and distributed systems are notoriously hard to get right. Therefore, following an approach that has proved highly beneficial for sequential programs, mu ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
This paper has the purpose of reviewing some of the established relationships between logic and concurrency, and of exploring new ones. Concurrent and distributed systems are notoriously hard to get right. Therefore, following an approach that has proved highly beneficial for sequential programs, much effort has been invested in tracing the foundations of concurrency in logic. The starting points of such investigations have been various idealized languages of concurrent and distributed programming, in particular the wellestablished statetransformation model inspired to Petri nets and multiset rewriting, and the prolific processbased models such as the πcalculus and other process algebras. In nearly all cases, the target of these investigations has been linear logic, a formal language that supports a view of formulas as consumable resources. In the first part of this paper, we review some of these interpretations of concurrent languages into linear logic. In the second part of the paper, we propose a completely new approach to understanding concurrent and distributed programming as a manifestation of logic, which yields a language that merges those two main paradigms of concurrency. Specifically, we present a new semantics for multiset rewriting founded on an alternative view of linear logic. The resulting interpretation is extended with a majority of linear connectives into the language of ωmultisets. This interpretation drops the distinction between multiset elements and rewrite rules, and considerably enriches the expressive power of standard multiset rewriting with embedded rules, choice, replication, and more. Derivations are now primarily viewed as open objects, and are closed only to examine intermediate rewriting states. The resulting language can also be interpreted as a process algebra. For example, a simple translation maps process constructors of the asynchronous πcalculus to rewrite operators, while the structural equivalence corresponds directly to logicallymotivated structural properties of ωmultisets (with one exception).
From coalgebraic specifications to implementation: The Mihda toolkit
 In Second International Symposium on Formal Methods for Components and Objects, Lecture Notes in Computer Science
, 2003
"... Abstract. This paper describes the architecture of a toolkit, called Mihda, providing facilities to minimise labelled transition systems for name passing calculi. The structure of the toolkit is derived from the coalgebraic formulation of the partitionrefinement minimisation algorithm for HDautom ..."
Abstract

Cited by 9 (7 self)
 Add to MetaCart
Abstract. This paper describes the architecture of a toolkit, called Mihda, providing facilities to minimise labelled transition systems for name passing calculi. The structure of the toolkit is derived from the coalgebraic formulation of the partitionrefinement minimisation algorithm for HDautomata. HDautomata have been specifically designed to allocate and garbage collect names and they provide faithful finite state representations of the behaviours of πcalculus processes. The direct correspondence between the coalgebraic specification and the implementation structure facilitates the proof of correctness of the implementation. We evaluate the usefulness of Mihda in practise by performing finite state verification of πcalculus specifications. 1
Staged Computation with Names and Necessity
, 2005
"... Staging is a programming technique for dividing the computation in order to exploit the early availability of some arguments. In the early stages the program uses the available arguments to generate, at run time, the code for the late stages. The late stages may then be explicitly evaluated when app ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
Staging is a programming technique for dividing the computation in order to exploit the early availability of some arguments. In the early stages the program uses the available arguments to generate, at run time, the code for the late stages. The late stages may then be explicitly evaluated when appropriate. A type system for staging should ensure that only welltyped expressions are generated, and that only expressions with no free variables are permitted for evaluation.