Generic zero-cost reuse for dependent types

Diehl, Larry; Firsov, Denis; Stump, Aaron

doi:10.1145/3236799

Cited by 9 publications

(9 citation statements)

References 19 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The ϕ axiom of equality allows us to define a type constructor Cast which internalizes the notion that the set of all elements of some type S is contained within the set of all elements of type T (note that Curry-style typing makes this relation nontrivial). We describe its axiomatic summary presented in Figure 2; for the full derivation, see Jenkins and Stump [16] (also Diehl et al [11]). The introduction form intrCast takes two erased term arguments, a function t 1 : S → T , and a proof that t 1 behaves extensionally as the identity function on its domain.…”

Section: Type Inclusionsmentioning

confidence: 99%

Simulating Large Eliminations in Cedille

Marmaduke¹,

Stump²

2021

Preprint

Self Cite

View full text Add to dashboard Cite

Large eliminations provide an expressive mechanism for arity-and type-generic programming. However, as large eliminations are closely tied to a type theory's primitive notion of inductive type, this expressivity is not expected within polymorphic lambda calculi in which datatypes are encoded using impredicative quantification. We report progress on simulating large eliminations for datatype encodings in one such type theory, the calculus of dependent lambda eliminations (CDLE). Specifically, we show that the expected computation rules for large eliminations, expressed using a derived type of extensional equality of types, can be proven within CDLE. We present several case studies, demonstrating the adequacy of this simulation for a variety of generic programming tasks, and a generic formulation of the simulation allowing its use for any datatype. All results have been mechanically checked by Cedille, an implementation of CDLE.

show abstract

Section: Type Inclusionsmentioning

confidence: 99%

Simulating Large Eliminations in Cedille

Marmaduke¹,

Stump²

2021

Preprint

Self Cite

View full text Add to dashboard Cite

show abstract

“…Such definitions often guide type-class resolution [Brady 2013;Devriese and Piessens 2011;Sozeau and Oury 2008], so precise control over their unfolding is important. Cedille includes zero-cost coercions [Diehl et al 2018] and Idris has recently added experimental support for typecase 5 . Because the design considerations of these languages differ from that of GHC, we compare our treatment of roles to modal dependent type theory in Section 8.…”

Section: Contributionmentioning

confidence: 99%

“…We adopted a Curry-style language design in this paper, where the syntax of terms includes only computationally relevant terms. This style of language makes a lot of sense for reasoning about representational equivalence [Diehl et al 2018]. It also simplifies our design process as we need not worry about propagating annotations at the same time as developing the semantics.…”

Section: St-coercementioning

confidence: 99%

“…On the other hand, roles are used to implement the safe-coercions, an advanced feature of GHC, and are subject to the design considerations described in Section 2.5. Diehl et al [2018] studies the possibility of zero-cost conversions in a Curry-style, dependently typed language. However, that work allows these conversions only when two types differ in their irrelevant parameters only.…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

A role for dependent types in Haskell

Weirich

Choudhury

Voizard

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Modern Haskell supports zero-cost coercions, a mechanism where types that share the same run-time representation may be freely converted between. To make sure such conversions are safe and desirable, this feature relies on a mechanism of roles to prohibit invalid coercions. In this work, we show how to incorporate roles into dependent types systems and prove, using the Coq proof assistant, that the resulting system is sound. We have designed this work as a foundation for the addition of dependent types to the Glasgow Haskell Compiler, but we also expect that it will be of use to designers of other dependently-typed languages who might want to adopt Haskell's safe coercions feature. A newtype in Haskell 1 is a user-defined algebraic datatype with exactly one constructor; that constructor takes exactly one argument. Here is an example: newtype HTML = MkHTML StringThis declaration creates a generative abstraction; the HTML type is new in the sense that it is not equal to any existing type. We call the argument type (String) the representation type. Because a newtype is isomorphic to its representation type, the Haskell compiler uses the same in-memory format for values of these types. Thus, creating a value of a newtype (i.e., calling MkHTML) is free at runtime, as is unpacking it (i.e., using a pattern-match).However, the Haskell type checker treats the newtype and its representation type as wholly distinct, meaning programmers cannot accidentally confuse HTML objects with String objects. We thus call newtypes a zero-cost abstraction: a convenient compile-time distinction with no cost 1 In this paper, we use łHaskellž to refer to the language implemented by the Glasgow Haskell Compiler (GHC), version 8.6.

show abstract

“…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]. The main metatheoretic property proved in previous work is logical consistency: there are types which are not inhabited.…”

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

Generic zero-cost reuse for dependent types

Cited by 9 publications

References 19 publications

Simulating Large Eliminations in Cedille

Simulating Large Eliminations in Cedille

A role for dependent types in Haskell

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

Contact Info

Product

Resources

About