Question

I wish to find a match within a List and return values dependant on the match. The CollectFirst works well for matching on the elements of the collection but in this case I want to match on the member swEl of the element rather than on the element itself.

abstract class CanvNode (var swElI: Either[CSplit, VistaT])
{         
  private[this] var _swEl: Either[CSplit, VistaT] = swElI
  def member = _swEl
  def member_= (value: Either[CSplit, VistaT] ){ _swEl = value; attach}
  def attach: Unit
  attach

  def findVista(origV: VistaIn): Option[Tuple2[CanvNode,VistaT]] = member match
  {
    case Right(v) if (v == origV) => Option(this, v) 
    case _ => None
  }
}

def nodes(): List[CanvNode] = topNode :: splits.map(i => List(i.n1, i.n2)).flatten

//Is there a better way of implementing this? 
val temp: Option[Tuple2[CanvNode, VistaT]] = 
  nodes.map(i => i.findVista(origV)).collectFirst{case Some (r) => r}

Do I need a View on that, or will the collectFirst method ensure the collection is only created as needed?

It strikes me that this must be a fairly general pattern. Another example could be if one had a List member of the main List’s elements and wanted to return the fourth element if it had one. Is there a standard method I can call? Failing that I can create the following:

implicit class TraversableOnceRichClass[A](n: TraversableOnce[A])
{
  def findSome[T](f: (A) => Option[T]) = n.map(f(_)).collectFirst{case Some (r) => r}
}    

And then I can replace the above with:

val temp: Option[Tuple2[CanvNode, VistaT]] = 
  nodes.findSome(i => i.findVista(origV))

This uses implicit classes from 2.10, for pre 2.10 use:

class TraversableOnceRichClass[A](n: TraversableOnce[A])
{
  def findSome[T](f: (A) => Option[T]) = n.map(f(_)).collectFirst{case Some (r) => r}
}

implicit final def TraversableOnceRichClass[A](n: List[A]):
  TraversableOnceRichClass[A] = new TraversableOnceRichClass(n)

Answer 1

As an introductory side node: The operation you’re describing (return the first Some if one exists, and None otherwise) is the sum of a collection of Options under the “first” monoid instance for Option. So for example, with Scalaz 6:

scala> Stream(None, None, Some("a"), None, Some("b")).map(_.fst).asMA.sum
res0: scalaz.FirstOption[java.lang.String] = Some(a)

Alternatively you could put something like this in scope:

implicit def optionFirstMonoid[A] = new Monoid[Option[A]] {
  val zero = None
  def append(a: Option[A], b: => Option[A]) = a orElse b
}

And skip the .map(_.fst) part. Unfortunately neither of these approaches is appropriately lazy in Scalaz, so the entire stream will be evaluated (unlike Haskell, where mconcat . map (First . Just) $ [1..] is just fine, for example).

---

Edit: As a side note to this side note: apparently Scalaz does provide a sumr that’s appropriately lazy (for streams—none of these approaches will work on a view). So for example you can write this:

Stream.from(1).map(Some(_).fst).sumr

And not wait forever for your answer, just like in the Haskell version.

---

But assuming that we’re sticking with the standard library, instead of this:

n.map(f(_)).collectFirst{ case Some(r) => r }

I’d write the following, which is more or less equivalent, and arguably more idiomatic:

n.flatMap(f(_)).headOption

For example, suppose we have a list of integers.

val xs = List(1, 2, 3, 4, 5)

We can make this lazy and map a function with a side effect over it to show us when its elements are accessed:

val ys = xs.view.map { i => println(i); i }

Now we can flatMap an Option-returning function over the resulting collection and use headOption to (safely) return the first element, if it exists:

scala> ys.flatMap(i => if (i > 2) Some(i.toString) else None).headOption
1
2
3
res0: Option[java.lang.String] = Some(3)

So clearly this stops when we hit a non-empty value, as desired. And yes, you’ll definitely need a view if your original collection is strict, since otherwise headOption (or collectFirst) can’t reach back and stop the flatMap (or map) that precedes it.

In your case you can skip findVista and get even more concise with something like this:

val temp = nodes.view.flatMap(
  node => node.right.toOption.filter(_ == origV).map(node -> _)
).headOption

Whether you find this clearer or just a mess is a matter of taste, of course.