Atif Shahzad - 1 year ago 94
Scala Question

# Scala : Code for pattern match

I have a code written by some one else. Can you help me to understand this piece of code?

`````` def sameCodeForTwoYears(list: List[(LocalDate, String)]):  List[(LocalDate, String)] = {
list match {
case x :: Nil => List.empty
case x :: xs => if (xs.head._1.minusYears(2).isAfter(x._1) && x._2 == xs.head._2) {
} else sameCodeForTwoYears(xs)
case Nil => List.empty
}
}
``````

Scalas `List[+T]` is an abstract class, implemented by two concrete classes:

1. `Nil` - Representing an empty list
2. `Cons` (`::`) - Represents a linked list with a `head` of type `T` and a `tail` of type `List[+T]`.

The pattern match you see here basically represents these two constructs. Let's do a by case analysis:

``````case x :: Nil => List.empty
``````

Means "if `head` is non empty and `tail` is an empty list, return an `List.empty`", which returns an empty list.

``````case x :: xs => if (xs.head._1.minusYears(2).isAfter(x._1) && x._2 == xs.head._2) {
``````

Means "if both `head` and `tail` are non-empty". The predicates following the match basically look into the tuple stored inside the `List[(LocalDateTime, String)]` where `_1` represents the first element and `_2` represents the second element. We dig a little deeper into the meaning if the condition:

``````xs.head._1.minusYears(2).isAfter(x._1)
``````

Means "take the first element from tail (`xs`, it's head), look into the first element in the tuple and subtract it by 2 years. If the first element in `x`s tuple (which is a `LocalDateTime`) is after that time.

And

``````x._2 == xs.head._2
``````

Means "look into the heads (`x`) second element, which is a `String`, and match it to the next element which is the tails (`xs`) first element (`xs.head`) and match both strings for equality.

Finally:

``````case Nil => List.empty
``````

Means "if the list is empty", return an empty list.

Recommended from our users: Dynamic Network Monitoring from WhatsUp Gold from IPSwitch. Free Download