Efficient scalar map / for idiom in Scala? - scala

Question

What is the most concise and bytecode efficient way to access a scalar expression multiple times from deep within another expression?
All of the functions in the following code (exc. scalar4) function as desired. But only bytecoder emits efficient bytecode (although it ends badly with ISTORE 2 ILOAD 2), the others each generate a half dozen INVOKE's.
This idiom is also handy for passing arbitrary parts of a tuple as parameters:
for (a_tuple) { f(_._3, _._1) + g(_._2) } // caution NOT legal Scala
In this example intro represents an expensive function that should only be called once.
object Hack extends App
{
#inline final def fur[T, V](x :T)(f :T => V) :V = f(x)
#inline final def pfor[T, V](x :T)(pf :PartialFunction[T, V]) = pf(x)
#inline final def cfor[T, V](x :T)(f :T => V) :V = x match { case x => f(x) }
def intro :Int = 600 // only one chance to make a first impression
def bytecoder = intro match { case __ => __ + __ / 600 }
def functional = fur(intro) (x => x + x / 600)
def partial = pfor(intro) { case __ => __ + __ / 600 }
def cased = cfor(intro) ($ => $ + $ / 600)
def optional = Some(intro).map(? => ? + ? / 600).get
def folder = Some(intro).fold(0)(? => ? + ? / 600)
// the for I wish for
def scalar4 = for(intro) (_ + _ / 600) // single underline!
println(bytecoder, functional, partial, cased, optional, folder)
}
public bytecoder()I
ALOAD 0
INVOKEVIRTUAL com/_601/hack/Hack$.intro ()I
ISTORE 1
ILOAD 1
ILOAD 1
SIPUSH 600
IDIV
IADD
ISTORE 2
ILOAD 2
IRETURN

Answer 1

Just create a local block with a temporary val. Seriously. It's compact: just one character longer than "idiomatic" pipe
{ val x = whatever; x * x / 600 }
whatever match { case x => x * x / 600 }
whatever |> { x => x * x / 600 }
It's efficient: minimum bytecode possible.
// def localval = { val x = whatever; x * x / 600 }
public int localval();
Code:
0: aload_0
1: invokevirtual #18; //Method whatever:()I
4: istore_1
5: iload_1
6: iload_1
7: imul
8: sipush 600
11: idiv
12: ireturn
The only thing it doesn't do is act as a postfix operator, and you have match for that when you really need that form and can't tolerate extra bytecode.

Answer 2

// Canadian scalar "for" expression
#inline final case class four[T](x: T)
{
#inline def apply(): T = x
#inline def apply[V](f: Function1[T, V]): V = f(x)
#inline def apply[V](f: Function2[T, T, V]): V = { val $ = x; f($, $) }
#inline def apply[V](f: Function3[T, T, T, V]): V = { val $ = x; f($, $, $) }
#inline def apply[V](f: Function4[T, T, T, T, V]): V = { val $ = x; f($, $, $, $) }
// ...
}
// Usage
val x = System.currentTimeMillis.toInt % 1 + 600
def a = four(x)() + 1
def b = four(x)(_ + 1)
def c = four(x)(_ + _ / x)
def d = four(x)(_ + _ / _)
def e = four(x)(_ + _ / _ - _) + 600
println(a, b, c, d, e)
With this four(){}, bytecode and performance is sacrificed in favour of style.
Also, this dangerously breaks from tradition, that underlines are used only once per parameter.