Abstract not found

This paper describes the construction of categorical models for the nu-calculus, a language that combines higher-order 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 nu-calculus 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 higher-order 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 nu-calculus. 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 nu-calculus, and can be used to reason about observable equivalence in the language. In particular a model using logical relations is fully abstract for first-order expressions.

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 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 "expressive " enough.

We present a new semantics for Algol-like languages that combines methods from two prior lines of development: ffl the object-based approach of [21,22], where the meaning of an imperative program is described in terms of sequences of observable actions, and ffl the functor-category approach initiated by Reynolds [24], where the varying nature of the run-time stack is explained using functors from a category of store shapes to a category of cpos. The semantics

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 partial-ordered to capture the containment relationship between objects.

. We present the ae-calculus, a relational calculus parametrized with a logical constraint system. The ae-calculus provides for higherorder relational programming with first-order constraints, and subsumes higher-order functional programming as a special case. It captures important aspects of the concurrent constraint programming language Oz. We prove the uniform confluence of the ae-calculus. 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 ae-calculus, a relational calculus parametrized by a logical constraint system. The ae-calculus provides for higher-order relational programming with first-order constraints. The ae-calculus captures interesting aspects of the concurrent constraint programming language Oz [3]. It is a minimalistic subcalculus of the Oz-Calculus [12] wh...

Abstract. Nominal logic is an extension of first-order 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 higher-order logic. This has proven difficult, largely because of complex interactions between nominal logic’s name-abstraction 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

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 well-typed expressions are generated, and that only expressions with no free variables are permitted for evaluation.

A simple Idealized Algol is considered, based on Reynolds's "essence of Algol." It is shown that observational equivalence in this language conservatively extends observational equivalence in its assignment-free functional sublanguage. 1 Introduction In "The essence of Algol," Reynolds (1981) presents a view of Algol as a call-byname language based on the typed -calculus, with "imperative" primitive types. A central feature of the design is the interaction between assignment and procedures. Side effects are wholly isolated in a primitive type comm of commands, and do not occur when computing a value of functional type. That is to say, side effects in procedures are latent, in the sense that an effect occurs only by evaluating a procedure call as a term of type comm. As a result, function types retain a genuine "functional character." For instance, the full fi and j laws are valid equivalences in Algol-like languages. This functional aspect of Algol has been emphasized strongly by Reyn...

This paper introduces a new recursion principle for inductive data modulo