Explicit convertibility proofs in pure type systems

Doorn, Floris van; Geuvers, Herman; Wiedijk, Freek

doi:10.1145/2503887.2503890

Cited by 10 publications

(8 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Explicit equality proofs In concurrent related work, van Doorn, Geuvers and Wiedijk (Geuvers and Wiedijk 2004;van Doorn et al 2013) develop a variant of pure type systems that replaces implicit conversions with explicit convertibility proofs. There are strong connections to this paper: they too use heterogeneous equality and must significantly generalize the statement of a lifting lemma (which they call "equality of substitutions").…”

Section: Discussion and Related Workmentioning

confidence: 99%

System FC with explicit kind equality

Weirich

Hsu

Eisenberg

2013

Proceedings of the 18th ACM SIGPLAN International Conference on Functional Programming

View full text Add to dashboard Cite

System FC, the core language of the Glasgow Haskell Compiler, is an explicitly-typed variant of System F with first-class type equality proofs called coercions. This extensible proof system forms the foundation for type system extensions such as type families (typelevel functions) and Generalized Algebraic Datatypes (GADTs). Such features, in conjunction with kind polymorphism and datatype promotion, support expressive compile-time reasoning.However, the core language lacks explicit kind equality proofs. As a result, type-level computation does not have access to kindlevel functions or promoted GADTs, the type-level analogues to expression-level features that have been so useful. In this paper, we eliminate such discrepancies by introducing kind equalities to System FC. Our approach is based on dependent type systems with heterogeneous equality and the "Type-in-Type" axiom, yet it preserves the metatheoretic properties of FC. In particular, type checking is simple, decidable and syntax directed. We prove the preservation and progress theorems for the extended language.

show abstract

Section: Discussion and Related Workmentioning

confidence: 99%

System FC with explicit kind equality

Weirich

Hsu

Eisenberg

2013

Proceedings of the 18th ACM SIGPLAN International Conference on Functional Programming

View full text Add to dashboard Cite

show abstract

“…This is a standard typing rule but it looks strange as a syntactic constructor. See [17] for a discussion of syntax with explicit conversions. We could give a dynamics for this syntax as a small-step reduction relation but the conv case is problematic.…”

Section: Termsmentioning

confidence: 99%

System F in Agda, for Fun and Profit

Chapman¹,

Kireev²,

Nester

et al. 2019

Lecture Notes in Computer Science

View full text Add to dashboard Cite

System F, also known as the polymorphic λ-calculus, is a typed λcalculus independently discovered by the logician Jean-Yves Girard and the computer scientist John Reynolds. We consider F ωµ , which adds higher-order kinds and iso-recursive types. We present the first complete, intrinsically typed, executable, formalisation of System F ωµ that we are aware of. The work is motivated by verifying the core language of a smart contract system based on System F ωµ. The paper is a literate Agda script [14].

show abstract

“…PITS trades the convenience of implicit type conversion that is afforded in most dependently typed calculi by a simple metatheory that allows for decidable type-checking. Closely related to our work is PTS with explicit convertibility proofs (PTS f ) (van Doorn et al, 2013), which is a variant of PTS. PTS f replaces the conversion rule by embedding explicit conversion steps into terms.…”

Section: Comparing the Three Variants Of Pits And Pts Fmentioning

confidence: 99%

“…Surprisingly, there are not so many designs that attempt to support unified syntax and general recursion with decidable type-checking. Notable exceptions are dependently typed Haskell (Weirich et al, 2017) and PTSs with explicit convertibility proofs (PTS f ) (van Doorn et al, 2013). However, these works are still quite involved due to the need of a separate language for building equality proof terms.…”

Section: Introductionmentioning

confidence: 99%

Pure iso-type systems

Yang¹,

Oliveira²

2019

J. Funct. Prog.

View full text Add to dashboard Cite

Traditional designs for functional languages (such as Haskell or ML) have separate sorts of syntax for terms and types. In contrast, many dependently typed languages use a unified syntax that accounts for both terms and types. Unified syntax has some interesting advantages over separate syntax, including less duplication of concepts, and added expressiveness. However, integrating unrestricted general recursion in calculi with unified syntax is challenging when some level of type-level computation is present, since properties such as decidable type-checking are easily lost. This paper presents a family of calculi called pure iso-type systems (PITSs), which employs unified syntax, supports general recursion and preserves decidable type-checking. PITS is comparable in simplicity to pure type systems (PTSs), and is useful to serve as a foundation for functional languages that stand in-between traditional ML-like languages and fully blown dependently typed languages. In PITS, recursion and recursive types are completely unrestricted and type equality is simply based on alpha-equality, just like traditional ML-style languages. However, like most dependently typed languages, PITS uses unified syntax, naturally supporting many advanced type system features. Instead of implicit type conversion, PITS provides a generalization of iso-recursive types called iso-types. Iso-types replace the conversion rule typically used in dependently typed calculus and make every type-level computation explicit via cast operators. Iso-types avoid the complexity of explicit equality proofs employed in other approaches with casts. We study three variants of PITS that differ on the reduction strategy employed by the cast operators: call-by-name, call-by-value and parallel reduction. One key finding is that while using call-by-value or call-by-name reduction in casts loses some expressive power, it allows those variants of PITS to have simple and direct operational semantics and proofs. In contrast, the variant of PITS with parallel reduction retains the expressive power of PTS conversion, at the cost of a more complex metatheory.

show abstract

Explicit convertibility proofs in pure type systems

Cited by 10 publications

References 16 publications

System FC with explicit kind equality

System FC with explicit kind equality

System F in Agda, for Fun and Profit

Pure iso-type systems

Contact Info

Product

Resources

About