Results 1  10
of
32
Primitive Recursion for HigherOrder Abstract Syntax
 Theoretical Computer Science
, 1997
"... ..."
(Show Context)
Categorical Models for Local Names
 LISP AND SYMBOLIC COMPUTATION
, 1996
"... This paper describes the construction of categorical models for the nucalculus, a language that combines higherorder functions with dynamically created names. Names are created with local scope, they can be compared with each other and passed around through function application, but that is all. T ..."
Abstract

Cited by 42 (2 self)
 Add to MetaCart
This paper describes the construction of categorical models for the nucalculus, a language that combines higherorder functions with dynamically created names. Names are created with local scope, they can be compared with each other and passed around through function application, but that is all. The intent behind this language is to examine one aspect of the imperative character of Standard ML: the use of local state by dynamic creation of references. The nucalculus is equivalent to a certain fragment of ML, omitting side effects, exceptions, datatypes and recursion. Even without all these features, the interaction of name creation with higherorder functions can be complex and subtle; it is particularly difficult to characterise the observable behaviour of expressions. Categorical monads, in the style of Moggi, are used to build denotational models for the nucalculus. An intermediate stage is the use of a computational metalanguage, which distinguishes in the type system between values and computations. The general requirements for a categorical model are presented, and two specific examples described in detail. These provide a sound denotational semantics for the nucalculus, and can be used to reason about observable equivalence in the language. In particular a model using logical relations is fully abstract for firstorder expressions.
MetaProgramming with Names and Necessity
, 2002
"... Metaprogramming is a discipline of writing programs in a certain programming language that generate, manipulate or execute programs written in another language. In a typed setting, metaprogramming languages usually contain a modal type constructor to distinguish the level of object programs (which ..."
Abstract

Cited by 40 (5 self)
 Add to MetaCart
(Show Context)
Metaprogramming is a discipline of writing programs in a certain programming language that generate, manipulate or execute programs written in another language. In a typed setting, metaprogramming languages usually contain a modal type constructor to distinguish the level of object programs (which are the manipulated data) from the meta programs (which perform the computations). In functional programming, modal types of object programs generally come in two flavors: open and closed, depending on whether the expressions they classify may contain any free variables or not. Closed object programs can be executed at runtime by the meta program, but the computations over them are more rigid, and typically produce less e#cient residual code. Open object programs provide better inlining and partial evaluation, but once constructed, expressions of open modal type cannot be evaluated.
Mutable abstract datatypes  or  how to have your state and munge it too
, 1992
"... 1 Introduction It's been said many times before: "Functional languages are great, but they can't deal with state! " to which functional programmers often reply: "But a compiler that's great, will eliminate state!" Although recent advances in compile ..."
Abstract

Cited by 16 (3 self)
 Add to MetaCart
(Show Context)
1 Introduction It's been said many times before: &quot;Functional languages are great, but they can't deal with state! &quot; to which functional programmers often reply: &quot;But a compiler that's great, will eliminate state!&quot; Although recent advances in compiler optimization techniques have eliminated many concerns over efficiency, optimizations have their own set of problems: (1) they are often expensive (in terms of compilation resources), (2) they aren't always good enough, (3) they are often hard to reason about, and (4) they are implementation dependent (and thus programs that depend on them are not portable). Perhaps more importantly, compiler optimizations aren't explicit, and in this sense are not &quot;expressive &quot; enough.
Objects, Interference, and the Yoneda Embedding
, 1995
"... We present a new semantics for Algollike languages that combines methods from two prior lines of development: ffl the objectbased approach of [21,22], where the meaning of an imperative program is described in terms of sequences of observable actions, and ffl the functorcategory approach initiat ..."
Abstract

Cited by 16 (7 self)
 Add to MetaCart
(Show Context)
We present a new semantics for Algollike languages that combines methods from two prior lines of development: ffl the objectbased approach of [21,22], where the meaning of an imperative program is described in terms of sequences of observable actions, and ffl the functorcategory approach initiated by Reynolds [24], where the varying nature of the runtime stack is explained using functors from a category of store shapes to a category of cpos. The semantics
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 11 (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.
Structural Recursion with Locally Scoped Names
"... This paper introduces a new recursion principle for inductively defined data modulo αequivalence of bound names that makes use of Oderskystyle local names when recursing over bound names. It is formulated in simply typed λcalculus extended with names that can be restricted to a lexical scope, tes ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
(Show Context)
This paper introduces a new recursion principle for inductively defined data modulo αequivalence of bound names that makes use of Oderskystyle local names when recursing over bound names. It is formulated in simply typed λcalculus extended with names that can be restricted to a lexical scope, tested for equality, explicitly swapped and abstracted. The new recursion principle is motivated by the nominal sets notion of “αstructural recursion”, whose use of names and associated freshness sideconditions in recursive definitions formalizes common practice with binders. The new calculus has a simple interpretation in nominal sets equipped with name restriction operations. It is shown to adequately represent αstructural recursion while avoiding the need to verify freshness sideconditions in definitions and computations. The paper is a revised and expanded version of (Pitts, 2010). 1
Simple nominal type theory
"... Abstract. Nominal logic is an extension of firstorder logic with features useful for reasoning about abstract syntax with bound names. For computational applications such as programming and formal reasoning, it is desirable to develop constructive type theories for nominal logic which extend standa ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Nominal logic is an extension of firstorder logic with features useful for reasoning about abstract syntax with bound names. For computational applications such as programming and formal reasoning, it is desirable to develop constructive type theories for nominal logic which extend standard type theories for propositional, first or higherorder logic. This has proven difficult, largely because of complex interactions between nominal logic’s nameabstraction operation and ordinary functional abstraction. This difficulty already arises in the case of propositional logic and simple type theory. In this paper we show how this difficulty can be overcome, and present a simple nominal type theory which enjoys properties such as type soundness and strong normalization, and which can be soundly interpreted using existing nominal set models of nominal logic. We also sketch how recursion combinators for languages with binding structure can be provided. This is an important first step towards understanding the constructive content of nominal logic and incorporating it into existing logics and type theories. 1
An Object Calculus with Ownership and Containment (Extended Abstract)
, 2001
"... Object ownership and the nesting between objects are arguably important but under appreciated aspects of objectoriented programming. They are also prominent in many alias management schemes. We model object ownership in an extension to Abadi and Cardelli's object calculus [1]. Object owners, ca ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
Object ownership and the nesting between objects are arguably important but under appreciated aspects of objectoriented programming. They are also prominent in many alias management schemes. We model object ownership in an extension to Abadi and Cardelli's object calculus [1]. Object owners, called contexts, can be created during evaluation allowing ownership on a per object basis. Contexts are partialordered to capture the containment relationship between objects.
A Confluent Relational Calculus for HigherOrder Programming with Constraints
 Proc. 1st Int. Conference on Constraints in Computational Logics (CCL'94
, 1994
"... . We present the aecalculus, a relational calculus parametrized with a logical constraint system. The aecalculus provides for higherorder relational programming with firstorder constraints, and subsumes higherorder functional programming as a special case. It captures important aspects of the co ..."
Abstract

Cited by 6 (4 self)
 Add to MetaCart
. We present the aecalculus, a relational calculus parametrized with a logical constraint system. The aecalculus provides for higherorder relational programming with firstorder constraints, and subsumes higherorder functional programming as a special case. It captures important aspects of the concurrent constraint programming language Oz. We prove the uniform confluence of the aecalculus. Uniform confluence implies that all maximal derivations issuing from a given expression have equal length. But even confluence of a nonfunctional calculus modelling computation with partial information is interesting on its own right. 1 Introduction We present the aecalculus, a relational calculus parametrized by a logical constraint system. The aecalculus provides for higherorder relational programming with firstorder constraints. The aecalculus captures interesting aspects of the concurrent constraint programming language Oz [3]. It is a minimalistic subcalculus of the OzCalculus [12] wh...