Scala (o JVM) non ottimizza mai gli oggetti (Funzione)?

Question

In molti casi con Scala, come semplici richiami di funzioni con ambito locale, si può immaginare che sarebbe spesso teoricamente eliminare completamente l'oggetto funzione. Ma AFAIK, la JVM non sa come farlo, e non penso nemmeno che Scala faccia. Corretta?

Gli oggetti funzione anonimi sono sempre sigillati? In caso contrario, c'è un limite piuttosto difficile su quanto può essere fatto inline. Corretta?

Qualcuno è a conoscenza di eventuali sforzi pianificati che potrebbero risolvere questo tipo di ottimizzazioni?

Vedi anche la relativa domanda pura-Java: Does a modern JVM optimize simple inline anonymous class allocation?

(canto del "non ottimizzare troppo presto", "non importa", et al è molto ridondante, a questo punto e non utile.)

Answer 1

Inlining e analisi di escape possono fare esattamente questo. È possibile dimostrare questo a te stesso se si utilizza la segnalazione compilazione in JVM 7, o punto di riferimento i seguenti due frammenti di codice:

def rfor(i0: Int, i1: Int)(f: Int => Unit) { 
    var i = i0 
    while (i <= i1) { 
    f(i) 
    i += 1 
    } 
} 

def whiley = { 
    var s = 0 
    var n = 1 
    while (n <= 500000000) { 
    val k = n >> 2 
    var i = 1 
    while (i <= 2) { 
     s += i*k 
     i += 1 
    } 
    n += 1 
    } 
    s 
} 

def rfory = { 
    var s = 0 
    var n = 0 
    while (n <= 500000000) { 
    val k = n >> 2 
    rfor(1, 2){ s += k * _ } 
    n += 1 
    } 
    s 
} 

Sulla mia macchina, il secondo è almeno veloce come il primo (a volte più veloce), nonostante il secondo sembra richiedere la creazione di una funzione ogni altra iterazione.