Abstract

A compiler should warn if a function defined by pattern matching does not cover its inputs—that is, if there are missing or redundant patterns. Generating such warnings accurately is difficult for modern languages due to the myriad of language features that interact with pattern matching. This is especially true in Haskell, a language with a complicated pattern language that is made even more complex by extensions offered by the Glasgow Haskell Compiler (GHC). Although GHC has spent a significant amount of effort towards improving its pattern-match coverage warnings, there are still several cases where it reports inaccurate warnings. We introduce a coverage checking algorithm called Lower Your Guards, which boils down the complexities of pattern matching into guard trees . While the source language may have many exotic forms of patterns, guard trees only have three different constructs, which vastly simplifies the coverage checking process. Our algorithm is modular, allowing for new forms of source-language patterns to be handled with little changes to the overall structure of the algorithm. We have implemented the algorithm in GHC and demonstrate places where it performs better than GHC’s current coverage checker, both in accuracy and performance.

Highlights

  • A Compositional Pattern-Match Coverage CheckerA compiler should warn if a function defined by pattern matching does not cover its inputsÐthat is, if there are missing or redundant patterns

  • Pattern matching is a tremendously useful feature in Haskell and many other programming languages, but it must be used with care

  • We introduce a coverage checking algorithm called Lower Your Guards, which boils down the complexities of pattern matching into guard trees

Read more

Summary

A Compositional Pattern-Match Coverage Checker

A compiler should warn if a function defined by pattern matching does not cover its inputsÐthat is, if there are missing or redundant patterns. Generating such warnings accurately is difficult for modern languages due to the myriad of language features that interact with pattern matching. This is especially true in Haskell, a language with a complicated pattern language that is made even more complex by extensions offered by the Glasgow Haskell Compiler (GHC). ACM Reference Format: Sebastian Graf, Simon Peyton Jones, and Ryan G.

INTRODUCTION
THE PROBLEM WE WANT TO SOLVE
Guards
Programmable Patterns
Strictness
Type-Equality Constraints
LOWER YOUR GUARDS: A NEW COVERAGE CHECKER
A R annotated trees
Desugaring to Guard Trees
Checking Guard Trees
Generating Inhabitants of a Refinement Type
Expanding a Normalised Refinement Type to a Pattern
Normalising a Refinement Type
Testing for Inhabitation
A Note on Precision
EXTENSIONS
Long-Distance Information
Empty Case
View Patterns
Pattern Synonyms
COMPLETE Pragmas
IMPLEMENTATION
Interleaving U and A
Throttling for Graceful Degradation
Maintaining Residual COMPLETE Sets
Reporting Uncovered Patterns
EVALUATION
Performance Tests
GHC Issues
Comparison with GADTs Meet Their Match
Comparison with Similar Coverage Checkers
Other Representations of Constraints
Positive and Negative Information
Strict Fields in Inhabitation Testing
CONCLUSION
Full Text
Paper version not known

Talk to us

Join us for a 30 min session where you can share your feedback and ask us any queries you have

Schedule a call