Menu
We have some pattern matching code where we would expect to be warned by the compiler that the match is not exhaustive, but we get none. Are there some cases where the exhaustiveness check can't be done?
E.g Our example (using scalactic Good+Bad):
(maybeModelIdOrFailure, maybeMake) match {
case (Some(Good(modelId)), Some(makeId)) if modelId >= 0 && taxonomyService.isValidModel(makeId, modelId) =>
Good(Some(MakeModelParameters(makeId, Some(modelId), modelLineId = None, index)))
case (Some(Good(modelLineId)), Some(makeId)) if modelLineId < 0 && taxonomyService.isValidModelLine(makeId, -1 * modelLineId) =>
Good(Some(MakeModelParameters(makeId, modelId = None, modelLineId = Some(-1 * modelLineId), index)))
case (Some(Good(modelOrModelLineId)), Some(makeId)) =>
Bad(One(IdNotFound(modelIdKeyName, modelOrModelLineId)))
case (Some(Good(modelId)), None) if modelId >= 0 =>
Bad(One(IdInvalid(modelIdKeyName, "Model Id without Make Id")))
case (Some(Good(modelLineId)), None) if modelLineId < 0 =>
Bad(One(IdInvalid(modelIdKeyName, "Model Line Id without Make Id")))
case (None, Some(makeId)) => Good(Some(MakeModelParameters(makeId, None, None, index)))
// case (None, None) => Good(None)
// case (Some(Bad(invalidParams)), _) => Bad(One(invalidParams))
}
We commented the last two lines, but the compiler doesn't warn and we didn't disable any checks.
675
Scala's pattern matching statement is most useful for matching on algebraic types expressed via case classes. Scala also allows the definition of patterns independently of case classes, using unapply methods in extractor objects.
Pattern matching is a way of checking the given sequence of tokens for the presence of the specific pattern. It is the most widely used feature in Scala. It is a technique for checking a value against a pattern. It is similar to the switch statement of Java and C.
Pattern matching tests whether a given value (or sequence of values) has the shape defined by a pattern, and, if it does, binds the variables in the pattern to the corresponding components of the value (or sequence of values). The same variable name may not be bound more than once in a pattern.
For example, x* matches any number of x characters, [0-9]* matches any number of digits, and . * matches any number of anything. A regular expression pattern match succeeds if the pattern matches anywhere in the value being tested.
From Jason Zaugg's comment on SI-9232 it seems the guards currently simply disable exhaustiveness checks (or nearly so). If that's the reason, moving the guard conditions inside the branches (e.g. case (Some(Good(modelId)), None) => if (modelId >= 0) ... else ...) should help. Other related issues: https://issues.scala-lang.org/browse/SI-5365, https://issues.scala-lang.org/browse/SI-7631.
124
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
