Gradual parametricity, revisited

Handlers of algebraic effects aspire to be a practical and robust programming construct that allows one to define, use, and combine different computational effects. Interestingly, a critical problem that still bars the way to their popular adoption is how to combine different uses of the same effect in a program, particularly in a language with a static type-and-effect system. For example, it is rudimentary to define the "mutable memory cellž effect as a pair of operations, put and get, together with a handler, but it is far from obvious how to use this effect a number of times to operate a number of memory cells in a single context. In this paper, we propose a solution based on lexically scoped effects in which each use (an "instancež) of an effect can be singled out by name, bound by an enclosing handler and tracked in the type of the expression. Such a setting proves to be delicate with respect to the choice of semantics, as it depends on the explosive mixture of effects, polymorphism, and reduction under binders. Hence, we devise a novel approach to Kripke-style logical relations that can deal with open terms, which allows us to prove the desired properties of our calculus. We formalise our core results in Coq, and introduce an experimental surface-level programming language to show that our approach is applicable in practice.

Section: Logical Relations For Generative Semanticsmentioning

confidence: 99%

Binders by day, labels by night: effect instances via lexically scoped handlers

Biernacki

Piróg

Polesiuk

et al. 2019

“…6 GDTL: RUNTIME SEMANTICS With the type system for GDTL realized, we turn to its dynamic semantics. Following the approaches of and Toro et al [2018b], we let the syntactic type-safety proof for the static SDTL drive its design. In place of a cast calculus, gradual terms carry evidence that they match their type, and computation steps evolve that evidence incrementally.…”

Section: Properties Of Approximate Normalizationmentioning

confidence: 99%

“…It mirrors the syntax for gradual terms, with two main changes. In place of type ascriptions, we have a special form for terms augmented with evidence, following Toro et al [2018b]. We also have err, an explicit term for runtime type errors.…”

Section: Properties Of Approximate Normalizationmentioning

confidence: 99%

Approximate normalization for gradual dependent types

Eremondi

Tanter

García

2019

Self Cite

Dependent types help programmers write highly reliable code. However, this reliability comes at a cost: it can be challenging to write new prototypes in (or migrate old code to) dependently-typed programming languages. Gradual typing makes static type disciplines more flexible, so an appropriate notion of gradual dependent types could fruitfully lower this cost. However, dependent types raise unique challenges for gradual typing. Dependent typechecking involves the execution of program code, but gradually-typed code can signal runtime type errors or diverge. These runtime errors threaten the soundness guarantees that make dependent types so attractive, while divergence spoils the type-driven programming experience.This paper presents GDTL, a gradual dependently-typed language that emphasizes pragmatic dependentlytyped programming. GDTL fully embeds both an untyped and dependently-typed language, and allows for smooth transitions between the two. In addition to gradual types we introduce gradual terms, which allow the user to be imprecise in type indices and to omit proof terms; runtime checks ensure type safety. To account for nontermination and failure, we distinguish between compile-time normalization and run-time execution: compile-time normalization is approximate but total, while runtime execution is exact, but may fail or diverge. We prove that GDTL has decidable typechecking and satisfies all the expected properties of gradual languages. In particular, GDTL satisfies the static and dynamic gradual guarantees: reducing type precision preserves typedness, and altering type precision does not change program behavior outside of dynamic type failures. To prove these properties, we were led to establish a novel normalization gradual guarantee that captures the monotonicity of approximate normalization with respect to imprecision.

“…Gradual typing allows exploratory programming and prototyping to be done in a forgiving, dynamically typed style, while later that code can be typed to ease readability and refactoring. Due to this appeal, there has been a great deal of research on extending gradual typing [37,34] to numerous language features such as parametric polymorphism [21,2,16,40], effect tracking [3], typestate [44], session types [15], refinement types [18] and security types [39]. Almost all work on gradual typing is based solely on operational semantics, and recent work such as [33] has codified some of the central design principles of gradual typing in an operational setting.…”

Section: Introductionmentioning

confidence: 99%

Gradual type theory

New

Licata

Ahmed

2019

We present gradual type theory, a logic and type theory for call-by-name gradual typing. We define the central constructions of gradual typing (the dynamic type, type casts and type error) in a novel way, by universal properties relative to new judgments for gradual type and term dynamism. These dynamism judgments build on prior work in blame calculi and on the "gradual guarantee" theorem of gradual typing. Combined with the ordinary extensionality (η) principles that type theory provides, we show that most of the standard operational behavior of casts is uniquely determined by the gradual guarantee. This provides a semantic justification for the definitions of casts, and shows that non-standard definitions of casts must violate these principles. Our type theory is the internal language of a certain class of preorder categories called equipments. We give a general construction of an equipment interpreting gradual type theory from a 2-category representing non-gradual types and programs. This construction is a semantic analogue of the interpretation of gradual typing using contracts, and use it to build some concrete domain-theoretic models of gradual typing. CC Creative Commons 7:2 M.S. New and D.R. Licata Vol. 16:1"strictly less than", and similarly for other terms such as "greater than", "more dynamic", etc. 7:4 M.S. New and D.R. Licata Vol. 16:1 7:6 M.S. New and D.R. Licata Vol. 16:1 7:8 M.S. New and D.R. Licata Vol. 16:1 2.2. PTT Signatures. While gradual type theory proves that most operational rules of gradual typing are equivalences, some must be added as axioms. Compare Moggi's monadic metalanguage [22]: since it is a general theory of monads, it is not provable that an effect is 7:12 M.S. New and D.R. Licata Vol. 16:1