Избегание бокса/распаковки внутри функции

Ответ 1

Поскольку вы упомянули макросы как возможное решение, мне пришла идея написать макрос, который использует анонимную функцию, извлекает методы применения и вставляет его в анонимный класс, который расширяет пользовательский признак функции под названием F3. Это довольно длительная реализация.

Характеристика F3

trait F3[@specialized A, @specialized B, @specialized C, @specialized D] {
  def apply(a:A, b:B, c:C):D
}

Макрос

  implicit def function3toF3[A,B,C,D](f:Function3[A,B,C,D]):F3[A,B,C,D] = macro impl[A,B,C,D]

  def impl[A,B,C,D](c:Context)(f:c.Expr[Function3[A,B,C,D]]):c.Expr[F3[A,B,C,D]] = {
    import c.universe._
    var Function(args,body) = f.tree
    args = args.map(c.resetAllAttrs(_).asInstanceOf[ValDef])
    body = c.resetAllAttrs(body)
    val res = 
      Block(
        List(
          ClassDef(
            Modifiers(Flag.FINAL),
            newTypeName("$anon"),
            List(),
            Template(
              List(
                AppliedTypeTree(Ident(c.mirror.staticClass("mcro.F3")),
                  List(
                    Ident(c.mirror.staticClass("scala.Int")),
                    Ident(c.mirror.staticClass("scala.Int")),
                    Ident(c.mirror.staticClass("scala.Double")),
                    Ident(c.mirror.staticClass("scala.Double"))
                  )
                )
              ),
              emptyValDef,
              List(
                DefDef(
                  Modifiers(),
                  nme.CONSTRUCTOR,
                  List(),
                  List(
                    List()
                  ),
                  TypeTree(),
                  Block(
                    List(
                      Apply(
                        Select(Super(This(newTypeName("")), newTypeName("")), newTermName("<init>")),
                        List()
                      )
                    ),
                    Literal(Constant(()))
                  )
                ),
                DefDef(
                  Modifiers(Flag.OVERRIDE),
                  newTermName("apply"),
                  List(),
                  List(args),
                  TypeTree(),
                  body
                )
              )
            )
          )
        ),
        Apply(
          Select(
            New(
              Ident(newTypeName("$anon"))
            ),
            nme.CONSTRUCTOR
          ),
          List()
        )
      )




    c.Expr[F3[A,B,C,D]](res)
  }

Поскольку я определил макрос как неявный, его можно использовать следующим образом:

def foo(f:F3[Int,Int,Double,Double]) = {
  println(f.apply(1,2,3))
}

foo((a:Int,b:Int,c:Double)=>a+b+c)

До вызова foo макрос вызывается, потому что foo ожидает экземпляр F3. Как и ожидалось, вызов foo выводит "6.0". Теперь посмотрим на разборку метода foo, чтобы убедиться, что нет бокса/распаковки:

public void foo(mcro.F3);
  Code:
   Stack=6, Locals=2, Args_size=2
   0:   getstatic       #19; //Field scala/Predef$.MODULE$:Lscala/Predef$;
   3:   aload_1
   4:   iconst_1
   5:   iconst_2
   6:   ldc2_w  #20; //double 3.0d
   9:   invokeinterface #27,  5; //InterfaceMethod mcro/F3.apply$mcIIDD$sp:(IID)D
   14:  invokestatic    #33; //Method scala/runtime/BoxesRunTime.boxToDouble:(D)Ljava/lang/Double;
   17:  invokevirtual   #37; //Method scala/Predef$.println:(Ljava/lang/Object;)V
   20:  return

Единственный бокс, который делается здесь, - это вызов println. Ура!

Последнее замечание: в своем текущем состоянии макрос работает только для частного случая Int,Int,Double,Double, но это легко может быть исправлено. Я оставляю это как упражнение для читателя.

Ответ 2

Что касается анонимного класса, который расширяет Function3 (байт-код которого вы показываете), сгенерированный Scalac, то невозможно вызвать перегруженное apply с примитивными параметрами из b.update, потому что этот метод update принимает Function3, который не имеет apply с примитивными параметрами.

Из байт-кода Function3 применяется только apply:

public abstract java.lang.Object apply(java.lang.Object, java.lang.Object, java.lang.Object);

Вместо этого вы можете использовать Function2[Long, Double], которая специализируется на этих типах, и кодировать 2 целых числа x и y в long как (x.toLong << 32) + y, и декодировать их как v & 0xffffffff и (v >> 32) & 0xffffffff.

Ответ 3

Поскольку Function1 является специализированным, возможным решением является использование currying и изменение вашего метода обновления на:

def update( f: Int => Int => Double => Double ): Unit = {...}

и соответственно измените встроенную функцию. с вашим примером (update был слегка изменен, чтобы быстро протестировать его):

scala> def update( f: Int => Int => Double => Double ): Double = f(1)(2)(3.0)
update: (f: Int => (Int => (Double => Double)))Double

scala> update(i => j => _ => if (i == 0 && j == 0) 1.0 else 0.5)
res1: Double = 0.5

Изменить: Ase объяснено в комментариях, это не совсем помогает, так как первый параметр по-прежнему в коробке. Я оставляю ответ, чтобы следить за ним.