Handles de méthode Java: propager des arguments non liés entre les fonctions

Question

Je voudrais créer un handle de méthode qui me permette de transmettre en argument une valeur qui sera liée à un espace réservé dans l'arbre de la poignée de la méthode.

Figure, quelque chose comme ceci: f(x) = plus(minus(x, 2), 3) où x est passé à Invoke, et 2 et 3 sont des constantes MethodHandles qui reviennent toujours 2 ou 3.

Je suis en cours d'exécution dans un problème que je ne comprends pas :

import java.lang.invoke.MethodHandle; 
import java.lang.invoke.MethodHandles; 
import java.lang.invoke.MethodType; 

public class TTest { 

    public static double plus(double a, double b) { return a + b; } 
    public static double minus(double a, double b) { return a - b; } 

    public static void main(String[] args) throws Throwable { 


     MethodHandle mh_minus = MethodHandles.lookup().findStatic(TTest.class, "minus", MethodType.methodType(double.class, double.class, double.class)); 
     MethodHandle mh_plus = MethodHandles.lookup().findStatic(TTest.class, "plus", MethodType.methodType(double.class, double.class, double.class)); 


     // f(x) = plus(minus(x, 2), 3) 
     MethodHandle doubleInvoker = MethodHandles.exactInvoker(MethodType.methodType(double.class)); 

     // mh_minus takes 2 doubles as input. The second one needs to take a MethodHandle that returns a constant: 
     MethodHandle minus_2 = MethodHandles.filterArguments(mh_minus, 1, doubleInvoker); 
     minus_2 = MethodHandles.insertArguments(minus_2, 1, MethodHandles.constant(double.class, 2)); 

     // mh_plus takes 2 doubles as input. The second one needs to take a MethodHandle that returns a constant: 
     MethodHandle plus_3 = MethodHandles.filterArguments(mh_plus, 1, doubleInvoker); 
     plus_3 = MethodHandles.insertArguments(plus_3, 1, MethodHandles.constant(double.class, 3)); 

     // the first arg of plus_3 is minus_2, but minus_2 is a MethodHandle that takes a double and returns a double, so we need to filter the first arg of plus_3 by an exact invoker 

     // EXCEPTION HERE: 
     plus_3 = MethodHandles.filterArguments(plus_3, 0, MethodHandles.exactInvoker(MethodType.methodType(double.class, double.class))); 
     MethodHandle comp = plus_3.bindTo(minus_2); 
     double res = (double)comp.invokeExact(3.0); // performs (3 - 2) + 3 
    } 
} 

Cela renvoie une exception en essayant de filtrer plus_3:

Exception in thread "main" java.lang.IllegalArgumentException: target and filter types do not match: (double)double, (MethodHandle,double)double 
    at java.lang.invoke.MethodHandleStatics.newIllegalArgumentException(MethodHandleStatics.java:145) 
    at java.lang.invoke.MethodHandles.filterArgumentChecks(MethodHandles.java:2631) 
    at java.lang.invoke.MethodHandles.filterArgument(MethodHandles.java:2608) 
    at java.lang.invoke.MethodHandles.filterArguments(MethodHandles.java:2601) 
    at TTest.main(TTest.java:31) 

Ce que je ne comprends pas, comment je peux composer plus avec moins, w ici moins a un argument qui n'est pas encore rempli.

Pouvez-vous m'aider?

Answer 1

Pour ceux qui sont intéressés, l'astuce ici est: MethodHandles::collectArguments.

Le code ressemble à ceci maintenant:

public static void withCollectArguments() throws Throwable { 

     MethodHandle mh_minus  = MethodHandles.lookup().findStatic(
       TTest.class, 
       "minus", 
       MethodType.methodType(
         double.class, // output 
         double.class, // arg1 
         double.class // arg2 
       ) 
     ); 

     MethodHandle mh_plus  = MethodHandles.lookup().findStatic(
       TTest.class, 
       "plus", 
       MethodType.methodType(
         double.class, 
         double.class, 
         double.class 
       ) 
     ); 

     // this guys here is used in filters to do a MethodHandle.invoke() -> double conversion 
     MethodHandle doubleInvoker = MethodHandles.exactInvoker(
       MethodType.methodType(
         double.class 
       ) 
     ); 

     // I want: f(x) = plus(minus(x, 2.0), 3.0) === (x - 2.0) + 3.0 

     // mh_minus takes 2 doubles as input. The second one needs to 
     // take a MethodHandle that returns a constant, so we filter 
     MethodHandle x_minus_2 = MethodHandles.filterArguments(
       mh_minus, 
       1, 
       doubleInvoker 
     ); 

     x_minus_2 = MethodHandles.insertArguments(
       x_minus_2, 
       1, 
       MethodHandles.constant(double.class, 2) 
     ); 

     // this here is the magic: we collect arguments of mh_plus (double, double), 
     // starting at argument index 0,and the collector is minus_2 (double) : 
     // we will "eat" the first arg of mh_plus and replace it with minus_2 
     MethodHandle x_minus_2_plus_y = MethodHandles.collectArguments(
       mh_plus, 
       0, 
       x_minus_2 
     ); 

     // we then curry x_minus_2_plus_y with a constant as 2nd argument: y => 3 
     MethodHandle x_minus_2_plus_3 = MethodHandles.filterArguments(
       x_minus_2_plus_y, 
       1, 
       doubleInvoker 
     ); 

     // "(x - 2) + y" becomes "(x - 2) + 3" 
     x_minus_2_plus_3 = MethodHandles.insertArguments(
       x_minus_2_plus_3, 
       1, 
       MethodHandles.constant(
         double.class, 
         3 
       ) 
     ); 

     // we now have a method handle that takes 1 argument and dispatches it to minus 
     double res = (double)x_minus_2_plus_3.invokeExact(1.0); // performs (x=1.0 - 2.0) + 3.0 
     Assert.assertEquals(res, 2.0); 

     res = (double)x_minus_2_plus_3.invokeExact(5.0); // performs (x=5.0 -2.0) + 3.0 
     Assert.assertEquals(res, 6.0); 
    }