Package net.hydromatic.morel.compile

Class PatternCoverageChecker

java.lang.Object

net.hydromatic.morel.compile.PatternCoverageChecker

class PatternCoverageChecker
extends Object

Checks whether patterns are exhaustive and/or redundant.

The algorithm converts a list of patterns into a boolean formula with several variables, then checks whether the formula is satisfiable (that is, whether there is a combination of assignments of boolean values to the variables such that the formula evaluates to true).

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	PatternCoverageChecker.DataTypeSlot	Payload of a Sat.Variable that is an algebraic type.
private static class	PatternCoverageChecker.ElideList<E>	List that removes one particular element from a backing list.
private static class	PatternCoverageChecker.Path	Identifies a point in a nested pattern.
private static class	PatternCoverageChecker.SubPath	Path that is a child of a given parent path.

Field Summary

Fields

Modifier and Type	Field	Description
(package private) Map<PatternCoverageChecker.Path,PatternCoverageChecker.DataTypeSlot>	pathSlots
(package private) Sat	sat
(package private) TypeSystem	typeSystem

Constructor Summary

Constructors

Modifier	Constructor	Description
private	PatternCoverageChecker(TypeSystem typeSystem)	Creates a PatternCoverageChecker.

Method Summary

Modifier and Type	Method	Description
private void	addConsTerms(PatternCoverageChecker.Path path, List<Sat.Term> terms, Core.TuplePat tuplePat)
boolean	isCoveredBy(Core.Pat pat, List<Core.Pat> patList)	Returns whether a pattern is covered by a list of patterns.
(package private) static boolean	isCoveredBy(TypeSystem typeSystem, List<Core.Pat> prevPatList, Core.Pat pat)	Returns whether every possible value that could be matched by pattern pat would already have been matched by one or more of prevPatList.
(package private) static boolean	isExhaustive(TypeSystem typeSystem, List<Core.Pat> patList)	Returns whether a list of patterns covers every possible value.
private Core.Pat	listToCons(Core.ListPat listPat)	Converts a list pattern into a pattern made up of the CONS and NIL constructors of the built-in datatype list.
private Core.Pat	listToConsRecurse(DataType listDataType, List<Core.Pat> args)
private Sat.Term	toTerm(Core.Pat pat)	Converts a pattern to a logical term.
private void	toTerm(Core.Pat pat, PatternCoverageChecker.Path path, List<Sat.Term> terms)
private Sat.Variable	typeConstructorTerm(PatternCoverageChecker.Path path, String con)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

typeSystem

final TypeSystem typeSystem

sat

final Sat sat

pathSlots

final Map<PatternCoverageChecker.Path,PatternCoverageChecker.DataTypeSlot> pathSlots

Constructor Detail

PatternCoverageChecker

private PatternCoverageChecker(TypeSystem typeSystem)

Creates a PatternCoverageChecker.

Method Detail

isCoveredBy

static boolean isCoveredBy(TypeSystem typeSystem,
                           List<Core.Pat> prevPatList,
                           Core.Pat pat)

Returns whether every possible value that could be matched by pattern pat would already have been matched by one or more of prevPatList.

For example, the pattern "(1, b: bool)" is covered by "[(1, true), (_, false)]" but not by "[(1, true)]" or "[(_, false)]".

isExhaustive

static boolean isExhaustive(TypeSystem typeSystem,
                            List<Core.Pat> patList)

Returns whether a list of patterns covers every possible value. If so, any pattern added to this list would be redundant.

toTerm

private Sat.Term toTerm(Core.Pat pat)

Converts a pattern to a logical term.

toTerm

private void toTerm(Core.Pat pat,
                    PatternCoverageChecker.Path path,
                    List<Sat.Term> terms)

listToCons

private Core.Pat listToCons(Core.ListPat listPat)

Converts a list pattern into a pattern made up of the CONS and NIL constructors of the built-in datatype list.

For example, converts: "[]" to "NIL", "[x]" to "CONS (x, NIL)", "[x, y]" to "CONS (x, CONS (y, NIL))", etc.

listToConsRecurse

private Core.Pat listToConsRecurse(DataType listDataType,
                                   List<Core.Pat> args)

addConsTerms

private void addConsTerms(PatternCoverageChecker.Path path,
                          List<Sat.Term> terms,
                          Core.TuplePat tuplePat)

typeConstructorTerm

private Sat.Variable typeConstructorTerm(PatternCoverageChecker.Path path,
                                         String con)

isCoveredBy

public boolean isCoveredBy(Core.Pat pat,
                           List<Core.Pat> patList)

Returns whether a pattern is covered by a list of patterns.

A pattern pat is said to be covered by a list of patterns patList if any possible value would be caught by one of the patterns in patList before reaching pat. Thus pat is said to be redundant in that context, and could be removed without affecting behavior.