Scala – Pattern Matching to check if string is null or empty

pattern matchingscala

Is it possible to check if string is null or empty using match?

I'm trying to do something like:

def sendToYahoo(message:Email) ={
  val clientConfiguration = new ClientService().getClientConfiguration()
  val messageId : Seq[Char] = message.identifier
  messageId match {
    case messageId.isEmpty => validate()
    case !messageId.isEmpty => //blabla
  }
}

But i have a compile error.

Thank in advance.

Best Answer

You can write a simple function like:

def isEmpty(x: String) = Option(x).forall(_.isEmpty)

def isEmpty(x: String) = x == null || x.isEmpty

You might also want to trim the string, if you consider " " to be empty as well.

def isEmpty(x: String) = x == null || x.trim.isEmpty

and then use it

val messageId = message.identifier
messageId match {
  case id if isEmpty(id) => validate()
  case id => // blabla
}

or without a match

if (isEmpty(messageId)) {
  validate()
} else {
  // blabla
}

or even

object EmptyString {
  def unapply(s: String): Option[String] =
    if (s == null || s.trim.isEmpty) Some(s) else None
}

message.identifier match {
  case EmptyString(s) => validate()
  case _ => // blabla
}

Related Solutions

Scala – Using comparison operators in Scala’s pattern matching system

You can add a guard, i.e. an if and a boolean expression after the pattern:

a match {
    case 10 => println("ten")
    case x if x > 10 => println("greater than ten")
    case _ => println("less than ten")
}

Edit: Note that this is more than superficially different to putting an if after the =>, because a pattern won't match if the guard is not true.

Scala – Pattern Matching tuples in Scala

Hopefully a few things to clear up your confusion:

Matching in scala follows this general template:

x match {
  case SomethingThatXIs if(SomeCondition) => SomeExpression
  // rinse and repeat
  // note that `if(SomeCondition)` is optional
}

It looks like you may have attempted to use the match/case expression as more of an if/else if/else kind of block, and as far as I can tell, the x doesn't really matter within said block. If that's the case, you might be fine with something like

case _ if (d(counter)._1 == key) => d(counter)._2

BUT

Some info on Lists in scala. You should always think of it like a LinkedList, where indexed lookup is an O(n) operation. Lists can be matched with a head :: tail format, and Nil is an empty list. For example:

val myList = List(1,2,3,4)
myList match {
  case first :: theRest => 
    // first is 1, theRest is List(2,3,4), which you can also express as
    // 2 :: 3 :: 4 :: Nil
  case Nil =>
    // an empty list case
}

It looks like you're constructing a kind of ListMap, so I'll write up a more "functional"/"recursive" way of implementing your get method.

I'll assume that d is the backing list, of type List[(String, Any)]

def get(key: String): Option[Any] = {
  def recurse(key: String, list: List[(String, Any)]): Option[Any] = list match {
    case (k, value) :: _ if (key == k) => Some(value)
    case _ :: theRest => recurse(key, theRest)
    case Nil => None
  }
  recurse(key, d)
}

The three case statements can be explained as follows:

1) The first element in list is a tuple of (k, value). The rest of the list is matched to the _ because we don't care about it in this case. The condition asks if k is equal to the key we are looking for. In this case, we want to return the value from the tuple.

2) Since the first element didn't have the right key, we want to recurse. We don't care about the first element, but we want the rest of the list so that we can recurse with it.

3) case Nil means there's nothing in the list, which should mark "failure" and the end of the recursion. In this case we return None. Consider this the same as your counter > acc condition from your question.

Please don't hesitate to ask for further explanation; and if I've accidentally made a mistake (won't compile, etc), point it out and I will fix it.

Best Answer

Related Solutions

Scala – Using comparison operators in Scala’s pattern matching system

Scala – Pattern Matching tuples in Scala

Related Topic