Question

I have an Iterable[String] representing the lines in a file and I’d like to find the first line in that sequence that matches a regular expression and return a numerical value extracted by the regex. The file is big enough that it wouldn’t make sense to load the whole thing into memory and then call toString() or something, so I’ll need to go through it a line at a time.

Here’s what I have (it works):

val RateRegex : Regex = ".....".r

def getRate(source : Source) : Option[Double] = {
  import java.lang.Double._

  for(line <- source.getLines() ) {
    line match {
      case RateRegex(rawRate) => return Some(parseDouble(rawRate))
      case None => ()
    }
  }

  return None
}

This seems ugly to me. It feels very imperative and case None => () might as well be replaced with a comment that says “you’re doing it wrong.”

I think I want something like def findFirstWhereNonNone(p : Function[A,Option[B]]) => Option[B] where the collection’s elements are of type A.

Are there built-in methods that would let me do this in a more functional way? Should I just write that method?

P.S. While I’m at it, is there an alternative to using java.lang.Double.parseDouble? Scala’s Double class doesn’t expose it.

P.P.S I’ve seen a lot of posts on SO suggesting that the Source API shouldn’t be used in production, but they’re all from 2008 and 2009. Is that still the case? If so, what should I use for IO?

Update

I now have:

import util.matching.Regex.Groups

for{line <- source.getLines()
    Groups(rawRate) <- RateRegex.findFirstMatchIn(line)} {
  return Some(parseDouble(rawRate))
}

return None

which feels a lot better to me.

Answer 1

EDIT: This third alternative ia quite neat:

source
.getLines()
.collectFirst{ case RateRegex(x) => x.toDouble}

Not sure if it’s more functional, but you can use the behaviour of foreach/for-comprehensions on Options

def getRate(source : Source) : Option[Double] = {

     for {line    <- source.getLines() 
          rawRate <- RateRegex.findFirstIn(line)}
       return  Some(rawRate toDouble)

  return None
}

This works too (quite similar to EasyAngel’s answer):

source
.getLines()
.map{RateRegex.findFirstMatchIn(_)}
.filter{_.isDefined}
.map{_.get.group(0).toDouble}
.head
.toList
.headOption

The last three are a little ugly. The take(1) is to ensure we only evaluate up to the first match. The toList is to force the evaluation, and the headOption to extract the first value as Some() or None if there is none. Is there a more idiomatic way of doing this?