Represent a match as a formula in propositional logic that encodes whether the match matches (abstractly: we only consider types)
Interface with user-defined match monad?
if there's a __match
in scope, we use this as the match strategy, assuming it conforms to MatchStrategy as defined below:
Interface with user-defined match monad?
if there's a __match
in scope, we use this as the match strategy, assuming it conforms to MatchStrategy as defined below:
type Matcher[P[_], M[+_], A] = { def flatMap[B](f: P[A] => M[B]): M[B] def orElse[B >: A](alternative: => M[B]): M[B] } abstract class MatchStrategy[P[_], M[+_]] { // runs the matcher on the given input def runOrElse[T, U](in: P[T])(matcher: P[T] => M[U]): P[U] def zero: M[Nothing] def one[T](x: P[T]): M[T] def guard[T](cond: P[Boolean], then: => P[T]): M[T] }
P and M are derived from one's signature (def one[T](x: P[T]): M[T]
)
if no __match
is found, we assume the following implementation (and generate optimized code accordingly)
object __match extends MatchStrategy[({type Id[x] = x})#Id, Option] { def zero = None def one[T](x: T) = Some(x) // NOTE: guard's return type must be of the shape M[T], where M is the monad in which the pattern match should be interpreted def guard[T](cond: Boolean, then: => T): Option[T] = if(cond) Some(then) else None def runOrElse[T, U](x: T)(f: T => Option[U]): U = f(x) getOrElse (throw new MatchError(x)) }
Compute the type T implied for a value v
matched by a pattern pat
(with expected type pt
).
Compute the type T implied for a value v
matched by a pattern pat
(with expected type pt
).
Usually, this is the pattern's type because pattern matching implies instance-of checks.
However, Stable Identifier and Literal patterns are matched using ==
,
which does not imply a type for the binder that binds the matched value.
See SI-1503, SI-5024: don't cast binders to types we're not sure they have
TODO: update spec as follows (deviation between **
):
A pattern binder x@p consists of a pattern variable x and a pattern p. The type of the variable x is the static type T **IMPLIED BY** the pattern p. This pattern matches any value v matched by the pattern p **Deleted: , provided the run-time type of v is also an instance of T, ** and it binds the variable name to that value.
Addition:
A pattern p
_implies_ a type T
if the pattern matches only values of the type T
.