Quantified class constraints

Bottu, Gert-Jan; Karachalias, Georgios; Schrijvers, Tom; Oliveira, Bruno C. d. S.; Wadler, Philip

doi:10.1145/3122955.3122967

Cited by 18 publications

(16 citation statements)

References 27 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We cannot illustrate this with COCHIS as, to keep its definition small, it is not equipped with higher-kinded types. The interested reader can find examples in the work of Bottu et al (2017).…”

Section: An Overview Of Cochismentioning

confidence: 99%

“…Nevertheless, if retaining global uniqueness is desired, that can be modelled by the subset of COCHIS without local declarations. In fact, based on the resolution algorithm of an early version of COCHIS, the Glasgow Haskell compiler (GHC) has been recently extended with quantified class constraints (Bottu et al, 2017;GHC, 2017b). Quantified class constraints enable higher-order rules in a setting with global scoping.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

COCHIS: Stable and coherent implicits

Schrijvers¹,

Oliveira

Wadler³

et al. 2019

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

Implicit programming (IP) mechanisms infer values by type-directed resolution, making programs more compact and easier to read. Examples of IP mechanisms include Haskell’s type classes, Scala’s implicits, Agda’s instance arguments, Coq’s type classes and Rust’s traits. The design of IP mechanisms has led to heated debate: proponents of one school argue for the desirability of strong reasoning properties, while proponents of another school argue for the power and flexibility of local scoping or overlapping instances. The current state of affairs seems to indicate that the two goals are at odds with one another and cannot easily be reconciled. This paper presents COCHIS, the Calculus Of CoHerent ImplicitS, an improved variant of the implicit calculus that offers flexibility while preserving two key properties: coherence and stability of type substitutions. COCHIS supports polymorphism, local scoping, overlapping instances, first-class instances and higher-order rules, while remaining type-safe, coherent and stable under type substitution. We introduce a logical formulation of how to resolve implicits, which is simple but ambiguous and incoherent, and a second formulation, which is less simple but unambiguous, coherent and stable. Every resolution of the second formulation is also a resolution of the first, but not conversely. Parts of the second formulation bear a close resemblance to a standard technique for proof search called focusing. Moreover, key for its coherence is a rigorous enforcement of determinism.

show abstract

Section: An Overview Of Cochismentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

COCHIS: Stable and coherent implicits

Schrijvers¹,

Oliveira

Wadler³

et al. 2019

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

show abstract

“…30 However, the combined role-/type-checking does not help with this problem. Fortunately, the new QuantifiedConstraints extension [Bottu et al 2017], available in GHC 8.6, provides a new solution, 31 resolving the problem in a much less invasive way.…”

Section: An Explicit Coerce Termmentioning

confidence: 99%

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

“…FunctorF, FoldableF, and TraversableF (see Figure 4), which are generalizations of their -F-less counterparts, demonstrate that an indexed type is respectively functorial, foldable, or traversable at each possible index. Some of the typeclasses in parameterized-utils are higherkinded generalizations of classes in the Haskell prelude that only assert a uniform operation at all indices, such as EqF, ShowF, and HashableF; the recent introduction of quantified constraints to Haskell [Bottu et al 2017] could obviate the need for these classes. Other typeclasses, such as TestEquality and OrdF, allow comparisons of terms with different argument types and produce evidence of type equality, so they will still be necessary.…”

Section: Some Parameterized Utilitiesmentioning

confidence: 99%

Dependently typed Haskell in industry (experience report)

Christiansen

Diatchki

Dockins

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Recent versions of the Haskell compiler GHC have a number of advanced features that allow many idioms from dependently typed programming to be encoded. We describe our experiences using this "dependently typed Haskell" to construct a performance-critical library that is a key component in a number of verification tools. We have discovered that it can be done, and it brings significant value, but also at a high cost. In this experience report, we describe the ways in which programming at the edge of what is expressible in Haskell's type system has brought us value, the difficulties that it has imposed, and some of the ways we coped with the difficulties.

show abstract

Quantified class constraints

Cited by 18 publications

References 27 publications

COCHIS: Stable and coherent implicits

COCHIS: Stable and coherent implicits

A role for dependent types in Haskell

Dependently typed Haskell in industry (experience report)

Contact Info

Product

Resources

About