The calculus of dependent lambda eliminations

Stump, Aaron

doi:10.1017/s0956796817000053

Cited by 23 publications

(16 citation statements)

References 50 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We briefly summarize the type theory, the Calculus of Lambda Eliminations (CDLE), that the results of this paper depend on. For full details on CDLE, including semantics and soundness results, please see the previous papers [Stump 2017[Stump , 2018a. The main metatheoretic property proved in the previous work is logical consistency: there are types which are not inhabited.…”

Section: The Type Theory (Cdle)mentioning

confidence: 99%

See 1 more Smart Citation

Generic zero-cost reuse for dependent types

Diehl

Firsov

Stump

2018

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

Dependently typed languages are well known for having a problem with code reuse. Traditional non-indexed algebraic datatypes (e.g. lists) appear alongside a plethora of indexed variations (e.g. vectors). Functions are often rewritten for both non-indexed and indexed versions of essentially the same datatype, which is a source of code duplication.We work in a Curry-style dependent type theory, where the same untyped term may be classified as both the non-indexed and indexed versions of a datatype. Many solutions have been proposed for the problem of dependently typed reuse, but we exploit Curry-style type theory in our solution to not only reuse data and programs, but do so at zero-cost (without a runtime penalty). Our work is an exercise in dependently typed generic programming, and internalizes the process of zero-cost reuse as the identity function in a Curry-style theory.

show abstract

Section: The Type Theory (Cdle)mentioning

confidence: 99%

“…• Section 8: We go over extensions that we have already made to our work, not covered herein, as well as planned future work. All of our results have been formalized in Cedille [Stump 2017[Stump , 2018a, a dependently typed language implementing the theory we work in (covered in Section 2.1). 2…”

Section: Introductionmentioning

confidence: 99%

Generic zero-cost reuse for dependent types

Diehl

Firsov

Stump

2018

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

show abstract

“…Church encodings allow for some induction, but are strictly less powerful than proper inductive types. Additionally, induction principles, along with basic facts like 0 1, cannot be proven in the purely negative Calculus of Constructions [Stump 2017]. However, we can type such a term if we introduce inductive types with eliminators, and allow types to be defined in terms of such eliminations.…”

Section: Extension: Inductive Typesmentioning

confidence: 99%

Approximate normalization for gradual dependent types

Eremondi

Tanter

García

2019

Proc. ACM Program. Lang.

View full text Add to dashboard 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.

show abstract

“…We briefly summarize the type theory of Cedille, called the Calculus of Lambda Eliminations (CDLE). The system has evolved from an initial version [26], to its current form [28]. Several other works demonstrate applications of the theory to derivation of inductive datatypes [6,7,27], and to zero-cost coercions between related datatypes [5].…”

Section: Cedille and Its Type Theorymentioning

confidence: 99%

A Weakly Initial Algebra for Higher-Order Abstract Syntax in Cedille

Stump

2019

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

Cedille is a relatively recent tool based on a Curry-style pure type theory, without a primitive datatype system. Using novel techniques based on dependent intersection types, inductive datatypes with their induction principles are derived. One benefit of this approach is that it allows exploration of new or advanced forms of inductive datatypes. This paper reports work in progress on one such form, namely higher-order abstract syntax (HOAS). We consider the nature of HOAS in the setting of pure type theory, comparing with the traditional concept of environment models for lambda calculus. We see an alternative, based on what we term Kripke function-spaces, for which we can derive a weakly initial algebra in Cedille. Several examples are given using the encoding.

show abstract

The calculus of dependent lambda eliminations

Cited by 23 publications

References 50 publications

Generic zero-cost reuse for dependent types

Generic zero-cost reuse for dependent types

Approximate normalization for gradual dependent types

A Weakly Initial Algebra for Higher-Order Abstract Syntax in Cedille

Contact Info

Product

Resources

About