anchor.diff:  * *Java Reflection is slow.* (*)
   * *Java MethodHandles are slow too.* (*)
   * *Generated code with `javax.tools.JavaCompiler` is fast.* (*)
  -* *LamdbaMetafactory is pretty fast.* (*)
  +* *LambdaMetafactory is pretty fast.* (*)
   
   (*) On the use cases I benchmarked with the workload I used. Your mileage may vary.
   
  
positive.code: ===================================================
  DirectAccess        avgt   60  2.590 ± 0.014  ns/op
  Reflection          avgt   60  5.275 ± 0.053  ns/op
  LamdbaMetafactory   avgt   60  3.453 ± 0.034  ns/op
  ----
  
  When I ran that
  https://www.optaplanner.org/learn/useCases/vehicleRoutingProblem.html[Traveling Salesman Problem]
  again in https://www.optaplanner.org/[OptaPlanner],
  this time using LamdbaMetafactory to access planning variables, _the score calculation speed was 9% faster overall_.
  However, the profiling (using sampling) still shows a lot of `executeGetter()` time, but less than with reflection.
  
  The metaspace cost seems to be about 2kb per lamdba in a non-scientific measurement
  and it gets garbage collected normally.
  
  == Bootstrap cost (update on 2017-01-25)
  
negative.code: MethodHandle        avgt   60  6.100 ± 0.079  ns/op // 136% slower
  StaticMethodHandle  avgt   60  2.635 ± 0.027  ns/op //   2% slower
  JavaCompiler        avgt   60  2.726 ± 0.026  ns/op //   5% slower
  LambdaMetafactory   avgt   60  3.453 ± 0.034  ns/op //  33% slower
  ----
  
  Your mileage may vary.
  