1,118 research outputs found
Intersection Types and (Positive) Almost-Sure Termination
Randomized higher-order computation can be seen as being captured by a lambda
calculus endowed with a single algebraic operation, namely a construct for
binary probabilistic choice. What matters about such computations is the
probability of obtaining any given result, rather than the possibility or the
necessity of obtaining it, like in (non)deterministic computation. Termination,
arguably the simplest kind of reachability problem, can be spelled out in at
least two ways, depending on whether it talks about the probability of
convergence or about the expected evaluation time, the second one providing a
stronger guarantee. In this paper, we show that intersection types are capable
of precisely characterizing both notions of termination inside a single system
of types: the probability of convergence of any lambda-term can be
underapproximated by its type, while the underlying derivation's weight gives a
lower bound to the term's expected number of steps to normal form. Noticeably,
both approximations are tight -- not only soundness but also completeness
holds. The crucial ingredient is non-idempotency, without which it would be
impossible to reason on the expected number of reduction steps which are
necessary to completely evaluate any term. Besides, the kind of approximation
we obtain is proved to be optimal recursion theoretically: no recursively
enumerable formal system can do better than that
TreatJS: Higher-Order Contracts for JavaScript
TreatJS is a language embedded, higher-order contract system for JavaScript
which enforces contracts by run-time monitoring. Beyond providing the standard
abstractions for building higher-order contracts (base, function, and object
contracts), TreatJS's novel contributions are its guarantee of non-interfering
contract execution, its systematic approach to blame assignment, its support
for contracts in the style of union and intersection types, and its notion of a
parameterized contract scope, which is the building block for composable
run-time generated contracts that generalize dependent function contracts.
TreatJS is implemented as a library so that all aspects of a contract can be
specified using the full JavaScript language. The library relies on JavaScript
proxies to guarantee full interposition for contracts. It further exploits
JavaScript's reflective features to run contracts in a sandbox environment,
which guarantees that the execution of contract code does not modify the
application state. No source code transformation or change in the JavaScript
run-time system is required.
The impact of contracts on execution speed is evaluated using the Google
Octane benchmark.Comment: Technical Repor
Intersection Types for the Computational lambda-Calculus
We study polymorphic type assignment systems for untyped lambda-calculi with
effects, based on Moggi's monadic approach. Moving from the abstract definition
of monads, we introduce a version of the call-by-value computational
lambda-calculus based on Wadler's variant with unit and bind combinators, and
without let. We define a notion of reduction for the calculus and prove it
confluent, and also we relate our calculus to the original work by Moggi
showing that his untyped metalanguage can be interpreted and simulated in our
calculus. We then introduce an intersection type system inspired to Barendregt,
Coppo and Dezani system for ordinary untyped lambda-calculus, establishing type
invariance under conversion, and provide models of the calculus via inverse
limit and filter model constructions and relate them. We prove soundness and
completeness of the type system, together with subject reduction and expansion
properties. Finally, we introduce a notion of convergence, which is precisely
related to reduction, and characterize convergent terms via their types
Denotational and operational preciseness of subtyping: A roadmap
The notion of subtyping has gained an important role both in theoretical and applicative domains: in lambda and concurrent calculi as well as in object-oriented programming languages. The soundness and the completeness, together referred to as the preciseness of subtyping, can be considered from two different points of view: denotational and operational. The former preciseness is based on the denotation of a type, which is a mathematical object describing the meaning of the type in accordance with the denotations of other expressions from the language. The latter preciseness has been recently developed with respect to type safety, i.e. the safe replacement of a term of a smaller type when a term of a bigger type is expected. The present paper shows that standard proofs of operational preciseness imply denotational preciseness and gives an overview on this subject
Precise subtyping for synchronous multiparty sessions
The notion of subtyping has gained an important role both in theoretical and applicative domains: in lambda and concurrent calculi as well as in programming languages. The soundness and the completeness, together referred to as the preciseness of subtyping, can be considered from two different points of view: operational and denotational. The former preciseness has been recently developed with respect to type safety, i.e. the safe replacement of a term of a smaller type when a term of a bigger type is expected. The latter preciseness is based on the denotation of a type which is a mathematical object that describes the meaning of the type in accordance with the denotations of other expressions from the language. The result of this paper is the operational and denotational preciseness of the subtyping for a synchronous multiparty session calculus. The novelty of this paper is the introduction of characteristic global types to prove the operational completeness
- …