Scalable Scala

      @tailrec
      def distanceByRow(rnum: Int, r0: Array[Int], r1: Array[Int]): Int = {
        if (rnum >= length) r0(limit)
        else {

          // first element of r1 = delete (i+1) chars from target to match empty 'word'
          r1(0) = rnum + 1

          // use formula to fill in the rest of the row
          for (j <- 0 until limit) {
            val cost = if (word(rnum) == targetText(j)) 0 else 1
            r1(j + 1) = min(r1(j) + 1, r0(j + 1) + 1, r0(j) + cost);
          }

          // recurse with arrays swapped for next row
          distanceByRow(rnum + 1, r1, r0)
        }
      }

      // initialize v0 (prior row of distances) as edit distance for empty 'word'
      for (i <- 0 to limit) v0(i) = i

uses for comprehensions, which actually translate into Range(0 to limit).foreach(...). When I converted these into tail recursive method calls (which Scala translates into the equivalent of Java while loops) the performance went up to par with the Java code.

So why the big difference? If you look into the Scala library code you'll see that the Range.foreach() just does a range check and then executes a simple while loop with a mutable control variable, calling the passed-in closure with the variable value each time through the loop. This is the version in use with the 2.10.3 library (it's changed a bit for 2.11.0, by pulling the range check into this method, but without any noticeable effect on performance):

  @inline final override def foreach[@specialized(Unit) U](f: Int => U) {
    if (validateRangeBoundaries(f)) {
      var i = start
      val terminal = terminalElement
      val step = this.step
      while (i != terminal) {
        f(i)
        i += step
      }
    }
  }

The call to foreach() is a one-time thing, so this shouldn't effect the overall time. Looking at the generated bytecode for the closures also doesn't show anything that leaps out at me — here's the closure (i.e., anonymous inner class in Java terms) method called by for (i <- 0 to limit) v0(i) = i:

       public void apply$mcVI$sp(int);
    Code:
       0: aload_0       
       1: getfield      #22                 // Field v0$3:[I
       4: iload_1       
       5: iload_1       
       6: iastore       
       7: return        

So as far as I can see, the only big difference is that this code is being called from the same Range.foreach method that's also being called in many other places, and because of this shared call site the JVM doesn't end up inlining it. That's a shame if so — I'd like the JVM to be smart enough to see it should inline the Range.foreach method at the point of use, and then inline the method from the closure.