Utilizzo di funzioni parzialmente applicate, problema di prestazioni

Question

object E7 { 
    def next_prime(primes: List[Int]) = primes match { 
    case ps@(h :: t) => { 


     // Version 1 
     val rpq = ps.reverse.exists _ 

     // Version 2 
     val rpq = ps.reverse.exists(_) 


     (Iterator.from(h + 1).find((v) => ! rpq(v % _ == 0)): @unchecked) match { 
     case Some(v) => v :: ps 
     } 
    } 
    case Nil => List(2) 
    } 

    val primes = Iterator.iterate(List[Int]())(next_prime) 

    def main(args: Array[String]) { 
    println(primes.drop(20001).next.head) 
    } 
} 

La prima versione richiede 3,6 secondi, seconda - 19.3 secondi! Qual è la differenza?

Edit: Scala versione 2.9.2 (Java HotSpot (TM) 64-bit di server VM, Java 1.7.0_21)

Answer 1

Il primo viene interpretato come

{ val temp = ps.reverse; (x: Int) => temp.exists(x) } 

mentre il secondo è interpretato come

(x: Int) => ps.reverse.exists(x) 

Questo spiega la differenza: bisogna invertire ogni volta che nel secondo caso, ma solo una volta nel primo. Non sono sicuro di dove nelle specifiche si dice che questo è ciò che si ottiene in ogni caso (o se lo fa).