7,078 research outputs found
Dependent Merges and First-Class Environments
In most programming languages a (runtime) environment stores all the definitions that are available to programmers. Typically, environments are a meta-level notion, used only conceptually or internally in the implementation of programming languages. Only a few programming languages allow environments to be first-class values, which can be manipulated directly in programs. Although there is some research on calculi with first-class environments for statically typed programming languages, these calculi typically have significant restrictions.
In this paper we propose a statically typed calculus, called ?_i, with first-class environments. The main novelty of the ?_i calculus is its support for first-class environments, together with an expressive set of operators that manipulate them. Such operators include: reification of the current environment, environment concatenation, environment restriction, and reflection mechanisms for running computations under a given environment. In ?_i any type can act as a context (i.e. an environment type) and contexts are simply types. Furthermore, because ?_i supports subtyping, there is a natural notion of context subtyping. There are two important ideas in ?_i that generalize and are inspired by existing notions in the literature. The ?_i calculus borrows disjoint intersection types and a merge operator, used in ?_i to model contexts and environments, from the ?_i calculus. However, unlike the merges in ?_i, the merges in ?_i can depend on previous components of a merge. From implicit calculi, the ?_i calculus borrows the notion of a query, which allows type-based lookups on environments. In particular, queries are key to the ability of ?_i to reify the current environment, or some parts of it. We prove the determinism and type soundness of ?_i, and show that ?_i can encode all well-typed ?_i programs
Explicit Substitutions for Contextual Type Theory
In this paper, we present an explicit substitution calculus which
distinguishes between ordinary bound variables and meta-variables. Its typing
discipline is derived from contextual modal type theory. We first present a
dependently typed lambda calculus with explicit substitutions for ordinary
variables and explicit meta-substitutions for meta-variables. We then present a
weak head normalization procedure which performs both substitutions lazily and
in a single pass thereby combining substitution walks for the two different
classes of variables. Finally, we describe a bidirectional type checking
algorithm which uses weak head normalization and prove soundness.Comment: In Proceedings LFMTP 2010, arXiv:1009.218
Inhabitation for Non-idempotent Intersection Types
The inhabitation problem for intersection types in the lambda-calculus is
known to be undecidable. We study the problem in the case of non-idempotent
intersection, considering several type assignment systems, which characterize
the solvable or the strongly normalizing lambda-terms. We prove the
decidability of the inhabitation problem for all the systems considered, by
providing sound and complete inhabitation algorithms for them
A Graphical Approach to Progress for Structured Communication in Web Services
We investigate a graphical representation of session invocation
interdependency in order to prove progress for the pi-calculus with sessions
under the usual session typing discipline. We show that those processes whose
associated dependency graph is acyclic can be brought to reduce. We call such
processes transparent processes. Additionally, we prove that for well-typed
processes where services contain no free names, such acyclicity is preserved by
the reduction semantics.
Our results encompass programs (processes containing neither free nor
restricted session channels) and higher-order sessions (delegation).
Furthermore, we give examples suggesting that transparent processes constitute
a large enough class of processes with progress to have applications in modern
session-based programming languages for web services.Comment: In Proceedings ICE 2010, arXiv:1010.530
A type system for components
In modern distributed systems, dynamic reconfiguration, i.e.,
changing at runtime the communication pattern of a program, is chal-
lenging. Generally, it is difficult to guarantee that such modifications will
not disrupt ongoing computations. In a previous paper, a solution to this
problem was proposed by extending the object-oriented language ABS
with a component model allowing the programmer to: i) perform up-
dates on objects by means of communication ports and their rebinding;
and ii) precisely specify when such updates can safely occur in an object
by means of critical sections. However, improper rebind operations could
still occur and lead to runtime errors. The present paper introduces a
type system for this component model that extends the ABS type system
with the notion of ports and a precise analysis that statically enforces
that no object will attempt illegal rebinding
The exp-log normal form of types
Lambda calculi with algebraic data types lie at the core of functional
programming languages and proof assistants, but conceal at least two
fundamental theoretical problems already in the presence of the simplest
non-trivial data type, the sum type. First, we do not know of an explicit and
implemented algorithm for deciding the beta-eta-equality of terms---and this in
spite of the first decidability results proven two decades ago. Second, it is
not clear how to decide when two types are essentially the same, i.e.
isomorphic, in spite of the meta-theoretic results on decidability of the
isomorphism.
In this paper, we present the exp-log normal form of types---derived from the
representation of exponential polynomials via the unary exponential and
logarithmic functions---that any type built from arrows, products, and sums,
can be isomorphically mapped to. The type normal form can be used as a simple
heuristic for deciding type isomorphism, thanks to the fact that it is a
systematic application of the high-school identities.
We then show that the type normal form allows to reduce the standard beta-eta
equational theory of the lambda calculus to a specialized version of itself,
while preserving the completeness of equality on terms. We end by describing an
alternative representation of normal terms of the lambda calculus with sums,
together with a Coq-implemented converter into/from our new term calculus. The
difference with the only other previously implemented heuristic for deciding
interesting instances of eta-equality by Balat, Di Cosmo, and Fiore, is that we
exploit the type information of terms substantially and this often allows us to
obtain a canonical representation of terms without performing sophisticated
term analyses
Logical relations for coherence of effect subtyping
A coercion semantics of a programming language with subtyping is typically
defined on typing derivations rather than on typing judgments. To avoid
semantic ambiguity, such a semantics is expected to be coherent, i.e.,
independent of the typing derivation for a given typing judgment. In this
article we present heterogeneous, biorthogonal, step-indexed logical relations
for establishing the coherence of coercion semantics of programming languages
with subtyping. To illustrate the effectiveness of the proof method, we develop
a proof of coherence of a type-directed, selective CPS translation from a typed
call-by-value lambda calculus with delimited continuations and control-effect
subtyping. The article is accompanied by a Coq formalization that relies on a
novel shallow embedding of a logic for reasoning about step-indexing
- …