CODEWITHSUNDEEP
scala
Dylan
Dylan

Reputation: 13922

Combine multiple extractor objects to use in one match statement

Is it possible to run multiple extractors in one match statement?

object CoolStuff {
  def unapply(thing: Thing): Option[SomeInfo] = ...
}
object NeatStuff {
  def unapply(thing: Thing): Option[OtherInfo] = ...
}

// is there some syntax similar to this?
thing match {
  case t @ CoolStuff(someInfo) @ NeatStuff(otherInfo) => process(someInfo, otherInfo)
  case _ => // neither Cool nor Neat
}

The intent here being that there are two extractors, and I don't have to do something like this:

object CoolNeatStuff {
  def unapply(thing: Thing): Option[(SomeInfo, OtherInfo)] = thing match {
    case CoolStuff(someInfo) => thing match {
      case NeatStuff(otherInfo) => Some(someInfo -> otherInfo)
      case _ => None // Cool, but not Neat
    case _ => None// neither Cool nor Neat
  }
}

Upvotes: 5

Views: 618

Answers (3)

Andrey Tyukin
Andrey Tyukin

Reputation: 44957

I've come up with a very similar solution, but I was a bit too slow, so I didn't post it as an answer. However, since @userunknown asks to explain how it works, I'll dump my similar code here anyway, and add a few comments. Maybe someone finds it a valuable addition to cchantep's minimalistic solution (it looks... calligraphic? for some reason, in a good sense).

So, here is my similar, aesthetically less pleasing proposal:

object && {
  def unapply[A](a: A) = Some((a, a))
}

// added some definitions to make your question-code work
type Thing = String
type SomeInfo = String
type OtherInfo = String

object CoolStuff {
  def unapply(thing: Thing): Option[SomeInfo] = Some(thing.toLowerCase)
}
object NeatStuff {
  def unapply(thing: Thing): Option[OtherInfo] = Some(thing.toUpperCase)
}

def process(a: SomeInfo, b: OtherInfo) = s"[$a, $b]"

val res = "helloworld" match {
  case CoolStuff(someInfo) && NeatStuff(otherInfo) =>
     process(someInfo, otherInfo)
  case _ =>
}

println(res)

This prints

[helloworld, HELLOWORLD]

The idea is that identifiers (in particular, && and ~ in cchantep's code) can be used as infix operators in patterns. Therefore, the match-case

case CoolStuff(someInfo) && NeatStuff(otherInfo) =>

will be desugared into

case &&(CoolStuff(someInfo), NeatStuff(otherInfo)) =>

and then the unapply method method of && will be invoked which simply duplicates its input.

In my code, the duplication is achieved by a straightforward Some((a, a)). In cchantep's code, it is done with fewer parentheses: Some(t -> t). The arrow -> comes from ArrowAssoc, which in turn is provided as an implicit conversion in Predef. This is just a quick way to create pairs, usually used in maps:

Map("hello" -> 42, "world" -> 58)

Another remark: notice that && can be used multiple times:

case Foo(a) && Bar(b) && Baz(c) => ...

So... I don't know whether it's an answer or an extended comment to cchantep's answer, but maybe someone finds it useful.

Upvotes: 5

kasur
kasur

Reputation: 1590

For those who might miss the details on how this magic actually works, just want to expand the answer by @cchantep anf @Andrey Tyukin (comment section does not allow me to do that).

Running scalac with -Xprint:parser option will give something along those lines (scalac 2.11.12)

def too(t: String) = t match {
    case $tilde(CoolStuff((a @ _)), NeatStuff((b @ _))) => $qmark$qmark$qmark
}

This basically shows you the initial steps compiler does while parsing source into AST.

Important Note here is that the rules why compiler makes this transformation are described in Infix Operation Patterns and Extractor Patterns. In particular, this allows you to use any object as long as it has unapply method, like for example CoolStuff(a) AndAlso NeatStuff(b). In previous answers && and ~ were picked up as also possible but not the only available valid identifiers.

If running scalac with option -Xprint:patmat which is a special phase for translating pattern matching one can see something similar to this

def too(t: String): Nothing = {
  case <synthetic> val x1: String = t;
  case9(){
    <synthetic> val o13: Option[(String, String)] = main.this.~.unapply[String](x1);
    if (o13.isEmpty.unary_!)
      {
        <synthetic> val p3: String = o13.get._1;
        <synthetic> val p4: String = o13.get._2;
        {
          <synthetic> val o12: Option[String] = main.this.CoolStuff.unapply(p3);
          if (o12.isEmpty.unary_!)
            {
              <synthetic> val o11: Option[String] = main.this.NeatStuff.unapply(p4);
              if (o11.isEmpty.unary_!)
                matchEnd8(scala.this.Predef.???)

Here ~.unapply will be called on input parameter t which will produce Some((t,t)). The tuple values will be extracted into variables p3 and p4. Then, CoolStuff.unapply(p3) will be called and if the result is not None NeatStuff.unapply(p4) will be called and also checked if it is not empty. If both are not empty then according to Variable Patterns a and b will be bound to returned results inside corresponding Some.

Upvotes: 2

cchantep
cchantep

Reputation: 9168

Can try

object ~ {
  def unapply[T](that: T): Option[(T,T)] = Some(that -> that)
}

def too(t: Thing) = t match {
  case CoolStuff(a) ~ NeatStuff(b) => ???
}

Upvotes: 8

Related Questions