Indexed codata types

Thibodeau, David; Cave, Andrew; Pientka, Brigitte

doi:10.1145/2951913.2951929

Cited by 12 publications

(16 citation statements)

References 13 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Krishnaswami (2009) boils the connection to focusing down to usual non-linear types; however, he has no copatterns as he only considers the product type as multiplicative (tensor), not additive. Thibodeau et al (2016) extend the connection to copatterns for indexed record types.…”

Section: Definition 13 a Signaturementioning

confidence: 99%

Elaborating dependent (co)pattern matching: No pattern left behind

Cockx¹,

Abel²

2020

J. Funct. Prog.

View full text Add to dashboard Cite

In a dependently typed language, we can guarantee correctness of our programmes by providing formal proofs. To check them, the typechecker elaborates these programs and proofs into a low-level core language. However, this core language is by nature hard to understand by mere humans, so how can we know we proved the right thing? This question occurs in particular for dependent copattern matching, a powerful language construct for writing programmes and proofs by dependent case analysis and mixed induction/coinduction. A definition by copattern matching consists of a list of clauses that are elaborated to a case tree, which can be further translated to primitive eliminators. In previous work this second step has received a lot of attention, but the first step has been mostly ignored so far. We present an algorithm elaborating definitions by dependent copattern matching to a core language with inductive data types, coinductive record types, an identity type, and constants defined by well-typed case trees. To ensure correctness, we prove that elaboration preserves the first-match semantics of the user clauses. Based on this theoretical work, we reimplement the algorithm used by Agda to check left-hand sides of definitions by pattern matching. The new implementation is at the same time more general and less complex, and fixes a number of bugs and usability issues with the old version. Thus, we take another step towards the formally verified implementation of a practical dependently typed language.

show abstract

Section: Definition 13 a Signaturementioning

confidence: 99%

Elaborating dependent (co)pattern matching: No pattern left behind

Cockx¹,

Abel²

2020

J. Funct. Prog.

View full text Add to dashboard Cite

show abstract

“…Specifying pre-and post-conditions of protocols, which is available in some object systems [14], is straightforward with indexed, recursive codata types, i.e. objects with guarded methods [40].…”

Section: The Many Faces Of Codatamentioning

confidence: 99%

“…This additional expressiveness simplifies applications that rely on a type index to guard observations. Thibodeau et al [40] give examples of such programs, including an automaton specification where its transitions correspond to an observation that changes a pre-and post-condition in its index, and a fair resource scheduler where the observation of several resources is controlled by an index tracking the number of times they have been accessed. For concreteness, let's use an indexed codata type to specify safe protocols as in the following example from an object-oriented language with guarded methods: [14], where they present an extension to C constraining the pre-and post-conditions for method calls.…”

Section: Representing Pre-and Post-conditionsmentioning

confidence: 99%

“…using copatterns. This line of work further developed the functionality of codata types in dependently typed languages by adding indexed codata types [40] and dependent copattern matching [11], which enabled the specification of bisimulation proofs and encodings of productive infinite objects in Agda. We build on these foundations by developing codata in practical languages.…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Codata in Action

Downen

Sullivan

Ariola

et al. 2019

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Computer scientists are well-versed in dealing with data structures. The same cannot be said about their dual: codata. Even though codata is pervasive in category theory, universal algebra, and logic, the use of codata for programming has been mainly relegated to representing infinite objects and processes. Our goal is to demonstrate the benefits of codata as a general-purpose programming abstraction independent of any specific language: eager or lazy, statically or dynamically typed, and functional or object-oriented. While codata is not featured in many programming languages today, we show how codata can be easily adopted and implemented by offering simple intercompilation techniques between data and codata. We believe codata is a common ground between the functional and object-oriented paradigms; ultimately, we hope to utilize the Curry-Howard isomorphism to further bridge the gap.

show abstract

“…Setzer et al [2014] give an algorithm for elaborating a definition by mixed (co)pattern matching to a nested case expression, yet only for a simply typed language. Thibodeau et al [2016] present a language with deep (co)pattern matching and a restricted form of dependent types. In their language, types can only depend on a user-defined domain with decidable equality and the types of record fields cannot depend on each other, thus, a self value is not needed for checking projections.…”

Section: Related Workmentioning

confidence: 99%

Elaborating dependent (co)pattern matching

Cockx

Abel

2018

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

In a dependently typed language, we can guarantee correctness of our programs by providing formal proofs. To check them, the typechecker elaborates these programs and proofs into a low level core language. However, this core language is by nature hard to understand by mere humans, so how can we know we proved the right thing? This question occurs in particular for dependent copattern matching, a powerful language construct for writing programs and proofs by dependent case analysis and mixed induction/coinduction. A definition by copattern matching consists of a list of clauses that are elaborated to a case tree, which can be further translated to primitive eliminators. In previous work this second step has received a lot of attention, but the first step has been mostly ignored so far. We present an algorithm elaborating definitions by dependent copattern matching to a core language with inductive datatypes, coinductive record types, an identity type, and constants defined by well-typed case trees. To ensure correctness, we prove that elaboration preserves the first-match semantics of the user clauses. Based on this theoretical work, we reimplement the algorithm used by Agda to check left-hand sides of definitions by pattern matching. The new implementation is at the same time more general and less complex, and fixes a number of bugs and usability issues with the old version. Thus we take another step towards the formally verified implementation of a practical dependently typed language.

show abstract

Indexed codata types

Cited by 12 publications

References 13 publications

Elaborating dependent (co)pattern matching: No pattern left behind

Elaborating dependent (co)pattern matching: No pattern left behind

Codata in Action

Elaborating dependent (co)pattern matching

Contact Info

Product

Resources

About