6

I'd like to be able to use a single variable multiple times within one pattern, so that it will only match if the same value is present in all places, such as

list match {
  case x :: x :: xs => // recurse
}

which would match List(1,1,2) but would not match List(1,2,1). But this does not compile with error: x is already defined as value x.

In researching this question, I found out that I can also include a guard in the case clause, so I can do

list match {
  case x1 :: x2 :: xs if x1==x2 => // recurse
}

which seems to work the same way (it does, right?). This is good, but it wouldn't look as clean if I wanted the same value in many places, like

list match {
  case x1::x2::x3::x4::xs if x1==x2 && x2==x3 && x3==x4 => // recurse
}

Is there any more elegant way I can do this?

A few notes: Yes, I am just learning scala, if that wasn't clear, so I'm not sure this is something I'd ever really want to do, but I'm just interested in what's possible. In that regard, I'm not really looking for a completely different solution, like takeWhile or filter or something, but more so am specifically interested in pattern matching.

Improve this question

3 Answers 3

Reset to default
8

Scala doesn't provide quite that much flexibility with its matches (which may be a good thing, as one has to be aware of errors arising from unintentional variable re-use).

If you have a large number of identical items, you might want to consider a nested match (but note that you won't fail out of the inner match to be completed later down the outer match, so you have to handle everything locally):

list match {
  case x :: rest => rest match {
    case `x` :: `x` :: `x` :: xs => println("Four of the same")
    case _ => println("Well, nonempty at least")
  }
  case _ => println("Boring, there's nothing here!")
}

Note the backticks which mean "we've already got this variable, check against it, don't set it!".

Alternatively, if you have specialized functionality that you use repeatedly, you can create a custom matcher:

object FourOf {
  def unapplySeq(xs: List[Int]): Option[(Int, List[Int])] = xs match {
    case x :: y :: z :: a :: rest if x==y && y==z && z==a => Some((x,rest))
    case _ => None
  }
}

and then use it whenever you need that complicated pattern:

list match {
  case FourOf(x,rest) => println("four of the same")
  case x :: more => println("Nonempty")
  case _ => println("Yawn")
}

Neither of these are quite as tidy and flexible as what you were apparently hoping for, but then again, I'm not sure flipping between assigning and testing the same variable in a match statement is a good way to write clear code anyway.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Thanks! I wasn't expecting something perfectly clean, but was just really interested in other options so this is perfect! I didn't know about the backtick operator at all previously.
Actually, the backtick operator means "literally what's inside" and can be used to enclose anything as a variable name, e.g. `def`. Pattern matching assigns variables that start with a lower case letter, and backtick is not a lower case letter, so it just works out that way.
5

For many repeats you might use stable identifiers to do a comparison (instead of catching a value): 

val x = list.head 
list match {
  case `x`::`x`::`x`::`x`::xs => ....
}

But note that this won't work on empty list (you just cannot get head of it).

Improve this answer

3 Comments

For the record, I totally respect om going up against Rex.
nice answer. Are you missing a case though? Tried to make an edit but that work out.
@Faiz yep, I missed the case. Thanks for noting
3

I think Rex's answer rocks. I am a fan of unapplySeq. But here's a not-so-clever-and-maybe-wasteful alternative, if your main bother is just with the sequence of =='s in each guard. So in the TMTOWTDI spirit:

def same[A](xs: A*) = xs forall (xs.head==)

// Then in your pattern match,

list match {
  // case x1::x2::x3::x4::xs if x1==x2 && x2==x3 && x3==x4 => // recurse
  case x1::x2::x3::x4::xs if same(x1,x2,x3,x4) => // recurse
}

I like Om's answer as well, so here's an adaptation:

 list.headOption map (x => list match { 
   case `x`::`x`::`x`::`x`::xs => //...; 
   case _ => // ... 
 }) getOrElse {
   // do what you'd have done for an empty list...
 }
Improve this answer

3 Comments

Thanks for all the different ideas! I hadn't thought about headOption at all.
the middle one doesn't seem, i think you need to bind x to something or make an x val first as the other examples show
Your right. Which means, unfortunately, no net gain in succinctness for that one....

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.