以下命令性代码的最有效功能版本是什么？

Question

I'm learning Scala and I want to know the best way of expressing this imperative pattern using Scala's functional programming capabilities.

def f(l: List[Int]): Boolean = {
  for (e <- l) {
    if (test(e))
      return true
    }
  }
  return false
}

The best I can come up with is along the lines of:

l map { e => test(e) } contains true

But this is less efficient since it calls test() on each element, whereas the imperative version stops on the first element that satisfies test(). Is there a more idiomatic functional programming technique I can use to the same effect? The imperative version seems awkward in Scala.

Answer 1

You can use the exists method:

val listWithEvens = List(1,2,3,4)
val listWithoutEvens = List(1,3,5)
def test(e: Int) = e % 2 == 0

listWithEvens.exists(test(_)) // true
listWithoutEvens.exists(test(_)) // false

// alternative
listWithEvens.exists(_ % 2 == 0)  // true 

If you are not familiar with the _ used like this, it's the equivalent of:

listWithEvens.exists(v => v % 2 == 0)

Answer 2

So, what you want is the exists method ( l.exists(test) ), which says nothing of how you'd implement it. The simplest implementation isn't very efficient:

def f(l: List[Int]): Boolean = l.foldLeft(false)((flag, n) => flag || test(n))

The problem is that it will iterate through all of l , even if the testing stops once flag becomes true. Now, most functional methods of iteration (in strict languages) will not stop iterating until finished through all the collection. The ones that do are actually implemented pretty much like you did, so, in the end, you are just hiding that sort of code, not avoiding it.

However, if I were required to use existing methods, and, of course, not to use exists , and be efficient on top of that, one could do something like this:

def f(l: List[Int]): Boolean = l.dropWhile(!test(_)).nonEmpty

Answer 3

Of course it isn't necessary in this case (and I actually expect the Scala library to use a more imperative version for their own exists – or at least have a map with an explicit break in it) but on a List you can use a simple (tail) recursive function.

import scala.annotation.tailrec

@tailrec
def exists(l: List[Int], p: (Int) => Boolean): Boolean = l match {
  case Nil => false
  case x :: xs => p(x) || exists(xs, p)
}

Because || only evaluates the right side if the left side is false it means you break early.

This, of course, is only efficient if referencing the tail of a collection is cheap.