Parametricity and dependent types

Bernardy, Jean-Philippe; Jansson, Patrik; Paterson, Ross

doi:10.1145/1932681.1863592

Cited by 35 publications

(67 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Proving resolution coherence in a dependently typed setting requires significant extension of our calculi, as dependent types collapse the term and type levels into a single level and thus enable more powerful type signatures for classes and instances. Furthermore, our logical relation needs to be extended to support dependent types [Bernardy et al 2012] as well. Fortunately, the essence of our proof strategy still applies.…”

Section: Discussion Of Possible Extensionsmentioning

confidence: 99%

Coherence of type class resolution

Bottu

Xie

Marntirosian

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Elaboration-based type class resolution, as found in languages like Haskell, Mercury and PureScript, is generally nondeterministic: there can be multiple ways to satisfy a wanted constraint in terms of global instances and locally given constraints. Coherence is the key property that keeps this sane; it guarantees that, despite the nondeterminism, programs still behave predictably. Even though elaboration-based resolution is generally assumed coherent, as far as we know, there is no formal proof of this property in the presence of sources of nondeterminism, like superclasses and flexible contexts.This paper provides a formal proof to remedy the situation. The proof is non-trivial because the semantics elaborates resolution into a target language where different elaborations can be distinguished by contexts that do not have a source language counterpart. Inspired by the notion of full abstraction, we present a two-step strategy that first elaborates nondeterministically into an intermediate language that preserves contextual equivalence, and then deterministically elaborates from there into the target language. We use an approach based on logical relations to establish contextual equivalence and thus coherence for the first step of elaboration, while the second step's determinism straightforwardly preserves this coherence property.

show abstract

Section: Discussion Of Possible Extensionsmentioning

confidence: 99%

Coherence of type class resolution

Bottu

Xie

Marntirosian

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…A pure type system (PTS) is given by a triple (S, A, R), where S is a set of sorts and A a set of typing relations s 1 : s 2 with s 1 , s 2 ∈ S. The set R consists of triples (s 1 , s 2 , s 3 ), where s 1 , s 2 , s 3 ∈ R. This set, in combination with the typing rule T-Pi in Figure 1 controls the dependencies of terms and types. The PTS for CCω [7] is given by:…”

Section: Calculus Of Constructionsmentioning

confidence: 99%

Dependently Typed Programming Based on Automated Theorem Proving

Armstrong

Foster

Struth

2012

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Mella is a minimalistic dependently typed programming language and interactive theorem prover implemented in Haskell. Its main purpose is to investigate the effective integration of automated theorem provers in a pure and simple setting. Such integrations are essential for supporting program development in dependently typed languages. We integrate the equational theorem prover Waldmeister and test it on more than 800 proof goals from the TPTP library. In contrast to previous approaches, the reconstruction of Waldmeister proofs within Mella is quite robust and does not generate a significant overhead to proof search. Mella thus yields a template for integrating more expressive theorem provers in more sophisticated languages.

show abstract

“…A → A will be written (A : ⋆) → A → A. Bernardy et al [2012] have developed a notion of parametricity for Pure Type Systems (PTS) [Barendregt et al 2013] based on a term-level translation function _ : PTS → PTS which translates a PTS term into another PTS term, possibly in a more powerful PTS. (CC can be mapped to itself.)…”

Section: Introductionmentioning

confidence: 99%

Simple noninterference from parametricity

Algehed

Bernardy

2019

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

In this paper we revisit the connection between parametricity and noninterference. Our primary contribution is a proof of noninterference for a polyvariant variation of the Dependency Core Calculus of Abadi et al. in the Calculus of Constructions. The proof is modular: it leverages parametricity for the Calculus of Constructionsand the encoding of data abstraction using existential types.This perspective gives rise to simple and understandable proofs of noninterference from parametricity. All our contributions have been mechanised in the Agda proof assistant.

show abstract

Parametricity and dependent types

Cited by 35 publications

References 21 publications

Coherence of type class resolution

Coherence of type class resolution

Dependently Typed Programming Based on Automated Theorem Proving

Simple noninterference from parametricity

Contact Info

Product

Resources

About