Question

I’m trying to learn Scala (2.10). In this exercise, I have a case class:

case class Entry(name: String, version: String) { }

I have two sequences of such objects sorted by their name attribute:

S1 = E1, E3, E4
S2 = F1, F2, F4

I want to construct a new sequence:

S3 = (E1, F1), (None, F2), (E3, None), (E4, F4)

pairing them by their name attribute, preferrably without having to iterate more than once over each list.

All my solutions for this problem becomes extremely imperative in style (e.g. conditionally incrementing two integers and using .get()). I hope some kind soul can suggest a more functional approach.

Answer 1

You mean by their version attribute, judging from the example?

You can use lists and recursion:

def pair(s1: List[Entry], s2: List[Entry]): List[(Option[Entry], Option[Entry])] =
  (s1, s2) match {
    case (Entry(_, v1) :: _, Entry(_, v2) :: _) if v1 == v2 =>
      (Some(s1.head), Some(s2.head)) :: pair(s1.tail, s2.tail)
    case (Entry(_, v1) :: s1t, Entry(_, v2) :: s2t) =>
      if (v1 < v2) (Some(s1.head), None) :: pair(s1.tail, s2)
      else (None, Some(s2.head)) :: pair(s1, s2.tail)
    case (Nil, s2) => s2.map(entry => (None, Some(entry))
    case (s1, Nil) => s1.map(entry => (Some(entry), None)
  }

Essentially, you progress to the list comparing their heads, and taking both heads if the version is the same, or taking only the smaller one. You then recursively do the same for the tail of the lists. If one of the lists turns out to be empty, you just map the remaining elements of the other list into pairs of None and the entry.