MatchMonadInterface

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] def isSuccess[T, U](x: P[T])(f: P[T] => M[U]): P[Boolean] // used for isDefinedAt }

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)) def isSuccess[T, U](x: T)(f: T => Option[U]): Boolean = !f(x).isEmpty }