Focusing on pattern matching

Krishnaswami, Neelakantan R.

doi:10.1145/1480881.1480927

Cited by 23 publications

(9 citation statements)

References 20 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Previously, focusing has been applied to pattern matching [Zeilberger 2008a;Krishnaswami 2009] and evaluation order [Zeilberger 2009;Curien and Herbelin 2000]. Closest to our work from a theoretical point of view is the work by Licata, Zeilberger and Harper [2008] where a language based on the sequent calculus is described which supports mixing LF types with computation-level types.…”

Section: Related Workmentioning

confidence: 98%

Copatterns

Abel

Pientka

Thibodeau

et al. 2013

Proceedings of the 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Inductive datatypes provide mechanisms to define finite data such as finite lists and trees via constructors and allow programmers to analyze and manipulate finite data via pattern matching. In this paper, we develop a dual approach for working with infinite data structures such as streams. Infinite data inhabits coinductive datatypes which denote greatest fixpoints. Unlike finite data which is defined by constructors we define infinite data by observations. Dual to pattern matching, a tool for analyzing finite data, we develop the concept of copattern matching, which allows us to synthesize infinite data. This leads to a symmetric language design where pattern matching on finite and infinite data can be mixed.We present a core language for programming with infinite structures by observations together with its operational semantics based on (co)pattern matching and describe coverage of copatterns. Our language naturally supports both call-by-name and call-by-value interpretations and can be seamlessly integrated into existing languages like Haskell and ML. We prove type soundness for our language and sketch how copatterns open new directions for solving problems in the interaction of coinductive and dependent types.

show abstract

Section: Related Workmentioning

confidence: 98%

Copatterns

Abel

Pientka

Thibodeau

et al. 2013

Proceedings of the 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

show abstract

“…The normal form is obtained by a type-directed reification procedure after evaluating the open term to a semantic value, mapping (reflecting) the free variables to corresponding unknowns in the semantics. The literal use of a standard interpreter can be achieved for the pure simply-typed lambda-calculus [8,13] by modelling uninterpreted base types as sets of neutral arXiv:1902.06097v1 [cs.PL] 16 Feb 2019 (aka atomic) terms, or more precisely, as presheaves or sets of neutral term families, in order to facilitate fresh bound variable generation during reification of functions to lambdas. Thanks to η-equality at function types, free variables of function type can be reflected into the semantics as functions applying the variable to their reified argument, forming a neutral term.…”

Section: Introductionmentioning

confidence: 99%

“…Concerning the presentation of polarized lambda calculus, we depart from Zeilberger [25] who employs a priori infinitary syntax, modelling a case tree as a meta-level function mapping well-typed patterns to branches. Instead, we use a graded monad representing complete pattern matching over a newly added hypothesis, which is in spirit akin to Filinski's [14,Section 4] and Krishnaswami's [16] treatment of eager pattern matching using a separate context of variables to be matched on.…”

Section: Introductionmentioning

confidence: 99%

Normalization by Evaluation for Call-By-Push-Value and Polarized Lambda Calculus

Abel

Sattler

2019

Proceedings of the 21st International Symposium on Principles and Practice of Declarative Programming

View full text Add to dashboard Cite

We observe that normalization by evaluation for simply-typed lambda-calculus with weak coproducts can be carried out in a weak bi-cartesian closed category of presheaves equipped with a monad that allows us to perform case distinction on neutral terms of sum type. The placement of the monad influences the normal forms we obtain: for instance, placing the monad on coproducts gives us eta-long beta-pi normal forms where pi refers to permutation of case distinctions out of elimination positions. We further observe that placing the monad on every coproduct is rather wasteful, and an optimal placement of the monad can be determined by considering polarized simple types inspired by focalization. Polarization classifies types into positive and negative, and it is sufficient to place the monad at the embedding of positive types into negative ones. We consider two calculi based on polarized types: pure call-by-push-value (CBPV) and polarized lambda-calculus, the natural deduction calculus corresponding to focalized sequent calculus. For these two calculi, we present algorithms for normalization by evaluation. We further discuss different implementations of the monad and their relation to existing normalization proofs for lambda-calculus with sums. Our developments have been partially formalized in the Agda proof assistant.

show abstract

“…• We present a dependently typed core language with inductive data types, coinductive record types, and an identity type. The language is focused (Andreoli, 1992;Zeilberger, 2008;Krishnaswami, 2009): terms of our language correspond to the non-invertible rules to introduce and eliminate these types, while the invertible rules constitute case trees. • We are the first to present a coverage checking algorithm for fully dependent copatterns.…”

Section: Contributionsmentioning

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

Focusing on pattern matching

Cited by 23 publications

References 20 publications

Copatterns

Copatterns

Normalization by Evaluation for Call-By-Push-Value and Polarized Lambda Calculus

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

Contact Info

Product

Resources

About