Safe zero-cost coercions for Haskell

Breitner, Joachim; Eisenberg, Richard A.; Jones, Simon Peyton; Weirich, Stephanie

doi:10.1017/s0956796816000150

Cited by 18 publications

(40 citation statements)

References 22 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…3 Generic lambda encoding for codata Figures 4,5,and 6 give the complete derivation of coinductive data in Cedille. This derivation is generic, in that it works for any monotone type scheme F of kind (I → ⋆) → I → ⋆ (where monotonicity is expressed as evidence cm of type Mono · I · F).…”

Section: Coalgebras and Coiteration Schemesmentioning

confidence: 99%

Efficient lambda encodings for Mendler-style coinductive types in Cedille

Jenkins¹,

Stump²,

Diehl³

2020

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

In the calculus of dependent lambda eliminations (CDLE), it is possible to define inductive datatypes via lambda encodings that feature constant-time destructors and a course-of-values induction scheme. This paper begins to address the missing derivations for the dual, coinductive types. Our derivation utilizes new methods within CDLE, as there are seemingly fundamental difficulties in adapting previous known approaches for deriving inductive types. The lambda encodings we present implementing coinductive types feature constant-time constructors and a course-of-values corecursion scheme. Coinductive type families are also supported, enabling proofs for many standard coinductive properties such as stream bisimulation. All work is mechanically verified by the Cedille tool, an implementation of CDLE.

show abstract

Section: Coalgebras and Coiteration Schemesmentioning

confidence: 99%

Efficient lambda encodings for Mendler-style coinductive types in Cedille

Jenkins¹,

Stump²,

Diehl³

2020

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

show abstract

“…Though this language has full-spectrum dependent types, it is not a standard dependent type theory: it admits logical inconsistency and the ⋆ : ⋆ axiom, along with support for equality assumptions and type erasure. System DR extends System D with roles, based on the existing design [Breitner et al 2016] as it must be realizable in GHC.…”

Section: Contributionmentioning

confidence: 99%

“…Inside the defining module, a newtype is a translucent abstraction: you can see through it with effort. The safe coercions [Breitner et al 2016] extension to the Glasgow Haskell Compiler (GHC) reduces this effort through the availability of the coerce primitive. For example, as HTML and String are represented by the same bits in memory, so are the lists [HTML] and [String].…”

mentioning

confidence: 99%

A role for dependent types in Haskell

Weirich

Choudhury

Voizard

et al. 2019

Proc. ACM Program. Lang.

Self Cite

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

“…Before describing the novelty of CFC, we take a quick tour of the grounds. Novel components are indicated in the following discussion; the rest of System CFC follows previous work (e.g., (Breitner et al 2016;).…”

Section: System Cfcmentioning

confidence: 99%

Constrained type families

Morris

Eisenberg

2017

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

We present an approach to support partiality in type-level computation without compromising expressiveness or type safety. Existing frameworks for type-level computation either require totality or implicitly assume it. For example, type families in Haskell provide a powerful, modular means of de ning type-level computation. However, their current design implicitly assumes that type families are total, introducing nonsensical types and signi cantly complicating the metatheory of type families and their extensions. We propose an alternative design, using quali ed types to pair type-level computations with predicates that capture their domains. Our approach naturally captures the intuitive partiality of type families, simplifying their metatheory. As evidence, we present the rst complete proof of consistency for a language with closed type families.

show abstract

Safe zero-cost coercions for Haskell

Cited by 18 publications

References 22 publications

Efficient lambda encodings for Mendler-style coinductive types in Cedille

Efficient lambda encodings for Mendler-style coinductive types in Cedille

A role for dependent types in Haskell

Constrained type families

Contact Info

Product

Resources

About