Pattern matching lists of certain size or greater/less

Question

Is there a way to specify a pattern that matches a List with a size greater (or less) or equal a certain value in Scala?

For example, if I want to apply the same action to all lists of size 3 or less:

list match {
    case Nil => op(list) 
    case x :: Nil => op(list)
    case x :: y :: Nil => op(list)
    case x :: y :: z :: Nil => op(list)
    case x :: tail => other(list)
} 

Is there a way to reduce this to two cases?

Answer 1

Yes, although you'll need to reverse the order of the cases:

list match {
  case l @ (_ :: _ :: _ :: _) => other(l)
  case l => op(l)
}

Note that I've bound a new variable l to the list in the pattern instead of referring to list, and that I've used _ when I don't need a variable. I'd suggest sticking to both of these practices, but the answer would work exactly the same without them.

Answer 2

If you insist on using a pattern match (maybe you want to include more match cases?), you can use a guard condition for it:

list match {
    case l if(l.size <= 3) => op(l)
    case l => other(l)
}

Answer 3

What's wrong with a plain old if / else??

if (list.length >= minimumLength)
  longer(list)
else
  shorter(list)

Answer 4

You can also do it with:

list.splitAt(len) match {
   case (xs, Nil) => other(xs)
   case (_, _) => op(list)
}

Also the complexity is O(len) thus even if list if long, len is deciding factor.

The above calls op if list.size < len else calls other