Question: I found myself writing something like this quite often:

```
a match {     
  case `b` => // do stuff
  case _ => // do nothing
}

```

Is there a shorter way to check if some value matches a pattern? I mean, in this case I could just write `if (a == b) // do stuff`, but what if the pattern is more complex? Like when matching against a list or any pattern of arbitrary complexity. I'd like to be able to write something like this:

```
if (a matches b) // do stuff

```

I'm relatively new to Scala, so please pardon, if I'm missing something big :)

Answer: 
This might help:

```
class Matches(m: Any) {
    def matches[R](f: PartialFunction[Any, R]) { if (f.isDefinedAt(m)) f(m) }
}
implicit def any2matches(m: Any) = new Matches(m)

scala> 'c' matches { case x: Int => println("Int") }                                

scala> 2 matches { case x: Int => println("Int") }  
Int

```

Now, some explanation on the general nature of the problem. 

Where may a match happen?
-------------------------

There are three places where pattern matching might happen: `val`, `case` and `for`. The rules for them are:

```
// throws an exception if it fails
val pattern = value 

// filters for pattern, but pattern cannot be "identifier: Type",
// though that can be replaced by "id1 @ (id2: Type)" for the same effect
for (pattern <- object providing map/flatMap/filter/withFilter/foreach) ...

// throws an exception if none of the cases match
value match { case ... => ... }

```

There is, however, another situation where `case` might appear, which is function and partial function literals. For example:

```
val f: Any => Unit = { case i: Int => println(i) }
val pf: PartialFunction[Any, Unit] = { case i: Int => println(i) }

```

Both functions and partial functions will throw an exception if called with an argument that doesn't match any of the case statements. However, partial functions also provide a method called `isDefinedAt` which can test whether a match can be made or not, as well as a method called `lift`, which will turn a `PartialFunction[T, R]` into a `Function[T, Option[R]]`, which means non-matching values will result in `None` instead of throwing an exception.

What is a match?
----------------

A match is a combination of many different tests:

```
// assign anything to x
case x

// only accepts values of type X
case x: X

// only accepts values matches by pattern
case x @ pattern

// only accepts a value equal to the value X (upper case here makes a difference)
case X

// only accepts a value equal to the value of x
case `x`

// only accept a tuple of the same arity
case (x, y, ..., z)

// only accepts if extractor(value) returns true of Some(Seq()) (some empty sequence)
case extractor()

// only accepts if extractor(value) returns Some something
case extractor(x)

// only accepts if extractor(value) returns Some Seq or Tuple of the same arity
case extractor(x, y, ...,  z)

// only accepts if extractor(value) returns Some Tuple2 or Some Seq with arity 2
case x extractor y

// accepts if any of the patterns is accepted (patterns may not contain assignable identifiers)
case x | y | ... | z

```

Now, extractors are the methods `unapply` or `unapplySeq`, the first returning `Boolean` or `Option[T]`, and the second returning `Option[Seq[T]]`, where `None` means no match is made, and `Some(result)` will try to match `result` as described above.

So there are all kinds of syntactic alternatives here, which just aren't possible without the use of one of the three constructions where pattern matches may happen. You may able to emulate some of the features, like value equality and extractors, but not all of them.
The best I can come up with is this:

```
def matches[A](a:A)(f:PartialFunction[A, Unit]) = f.isDefinedAt(a)

if (matches(a){case ... =>}) {
    //do stuff
}

```

This won't win you any style points though.