![\"lambda\"](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2014\/01\/lambda.jpg\")
<\/a>What\u2019s interesting about Lambda expressions is that from the JVM\u2019s perspective they\u2019re completely invisible. It has no notion of what an anonymous function or a Lambda expression is. It only knows bytecode which is a strict OO specification. It\u2019s up to the makers of the language and its compiler to work within these constraints to create newer, more advanced language elements.<\/p>\nWe first encountered this when we were working on adding Scala support to Takipi<\/a> and had to dive deep into the Scala compiler. With Java 8 right around the corner, I thought it would be interesting to see how the Scala and Java compilers implement Lambda expressions. The results were pretty surprising.<\/p>\n To get things going I took a simple Lambda expression that converts a list of Strings to a list of their lengths.<\/p>\n In Java –<\/p>\n In Scala –<\/p>\n Don\u2019t be tricked its simplicity \u2013 behind the scenes some complex stuff is going on.<\/p>\n I used javap to view the bytecode contents of the .class produced by the Scala compiler. Let\u2019s look at the result bytecode (this is what the JVM will actually execute).<\/p>\n Next, things gets more interesting \u2013 a new instance of a synthetic class generated by the compiler is created and initialized. This is the object that from the JVM\u2019s perspective holds the Lambda method. It\u2019s funny that while the Lambda is defined as an integral part of our method, in reality it lives completely outside of our class.<\/p>\n But hold on \u2013 what\u2019s going on inside that Lambda object? The Lambda class is derived from scala.runtime.AbstractFunction1<\/em>. Through this the map<\/em>() function can polymorphically invoke the overridden apply() whose code is below –<\/p>\n The actual code to perform the .length<\/em>() operation is nested in that additional apply method which simply returns the length of the String as we expected.<\/p>\n Phew.. it was quite a long way to get here!<\/p>\n For a line as simple as we write above, quite a lot of bytecode is generated \u2013 an additional class and a bunch of new methods. This of course isn\u2019t meant to dissuade us from using Lambdas (we\u2019re writing in Scala, not C). It just goes to show the complexity behind these constructs. Just think of the amount of code and complexity that goes into compiling complex chains of Lambda expressions!<\/p>\n I was quite expecting Java 8 to implement this the same way, but was quite surprised to see that they took another approach completely.<\/p>\n The bytecode here is a bit shorter but does something rather surprising. It begins quite simply by loading the names<\/em> var and invokes its .stream<\/em>() method, but then it does something quite elegant. Instead of creating a new object that will wrap the Lambda function, it uses the new invokeDynamic<\/em> instruction which was added in Java 7 to dynamically link this call site to the actual Lambda function.<\/p>\n InvokeDynamic magic<\/strong>. This JVM instruction was added in Java 7 to make the JVM less strict, and allows dynamic languages to bind symbols at run-time, vs. doing all the linkage statically when the code is compiled by the JVM.<\/p>\n Dynamic Linking<\/strong>. If you look at the actual invokedynamic<\/em> instruction you\u2019ll see there\u2019s no reference of the actual Lambda function (called lambda$0). The answer lies in the way invokedynamic is designed (which in itself deserves a full post), but the short answer is the name and signature of the Lambda, which in our case is –<\/p>\n are stored in an entry in a separate table in the .class to which the #0 parameter passed to the instruction points. This new table actually changed the structure of the bytecode specification for the first time after a good few years, requiring us to adapt Takipi\u2019s<\/a> error analysis engine to it as well.<\/p>\n This is the code for the actual Lambda\u00a0expression. It\u2019s very cookie-cutter \u2013 simply load the String parameter, call length<\/em>() and box the result. Notice it was compiled as a static<\/em> function to avoid having to pass an additional this<\/em> object to it like we saw in Scala.<\/p>\n This is another advantage of the invokedynamic<\/em> approach, as it allows us to invoke the method in a way which is polymorphic from the .map() function\u2019s perspective, but without having to allocate a wrapper object or invoke a virtual override method. Pretty cool!<\/p>\n It\u2019s fascinating to see how Java, the most \u201cstrict\u201d of modern languages is now using dynamic linkage to power its new Lambda expressions. It\u2019s also an efficient approach, as no additional class loading and compilation is needed \u2013 the Lambda method is simply another private method in our class.<\/p>\n Java 8 has really done a very elegant job in using new technology introduced in Java 7 to implement Lambda expressions in what is a very straightforward way. It\u2019s pleasant in a way to see that even a \u201cvenerable\u201d lady such as Java can teach us all some new tricks Lambda expressions have taken the programming world by storm in the last few years. Most modern languages have adopted them as a fundamental part of functional programming. JVM based languages such as Scala, Groovy and Clojure have integrated them as key part of the language. And now, Java 8 is (finally) joining in on the …<\/p>\n","protected":false},"author":529,"featured_media":227,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[20],"tags":[197],"class_list":["post-20787","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scala","tag-lambdas"],"yoast_head":"\nList names = Arrays.asList(\"1\", \"2\", \"3\");\r\nStream lengths = names.stream().map(name -> name.length());<\/pre>\n
val names = List(\"1\", \"2\", \"3\")\r\nval lengths = names.map(name => name.length)<\/pre>\n
Let\u2019s start with Scala<\/h2>\n
<\/a><\/p>\nThe Code<\/h4>\n
\/\/ this loads the names var into the stack (the JVM thinks\r\n\/\/ of it as variable #2).\r\n\/\/ It\u2019s going to stay there for a while till it gets used\r\n\/\/ by the <em>.map<\/em> function.\r\n\r\naload_2<\/pre>\n
new myLambdas\/Lambda1$$anonfun$1 \/\/instantiate the Lambda object\r\ndup \/\/put it into the stack again\r\n\r\n\/\/ finally, invoke the c\u2019tor. Remember - it\u2019s just a plain object\r\n\/\/ from the JVM\u2019s perspective.\r\ninvokespecial myLambdas\/Lambda1$$anonfun$1\/()V\r\n\r\n\/\/ these two (long) lines loads the immutable.List CanBuildFrom factory\r\n\/\/ which will create the new list. This factory pattern is a part of\r\n\/\/ Scala\u2019s collections architecture\r\ngetstatic scala\/collection\/immutable\/List$\/MODULE$\r\nLscala\/collection\/immutable\/List$;\r\ninvokevirtual scala\/collection\/immutable\/List$\/canBuildFrom()\r\nLscala\/collection\/generic\/CanBuildFrom;\r\n\r\n\/\/ Now we have on the stack the Lambda object and the factory.\r\n\/\/ The next phase is to call the .<em>map<\/em>() function. \r\n\/\/ If you remember, we loaded the <em>names<\/em> var onto \r\n\/\/ the stack in the beginning. Now it\u2019ll gets used as the \r\n\/\/ this for the .<em>map<\/em>() call, which will also \r\n\/\/ accept the Lambda object and the factory to produce the \r\n\/\/ new list of lengths.\r\n\r\ninvokevirtual scala\/collection\/immutable\/List\/map(Lscala\/Function1;\r\nLscala\/collection\/generic\/CanBuildFrom;)Ljava\/lang\/Object;<\/pre>\n
The Lambda object<\/h4>\n
\/\/ this code loads this and the target object on which to act,\r\n\/\/ checks that it\u2019s a String, and then calls another apply overload\r\n\/\/ to do the actual work and boxes its return value.\r\naload_0 \/\/load this\r\naload_1 \/\/load the string arg\r\ncheckcast java\/lang\/String \/\/make sure it\u2019s a String - we got an Object\r\n\r\n\/\/ call another apply() method in the synthetic class\r\ninvokevirtual myLambdas\/Lambda1$$anonfun$1\/apply(Ljava\/lang\/String;)I\r\n\r\n\/\/box the result\r\ninvokestatic scala\/runtime\/BoxesRunTime\/boxToInteger(I)Ljava\/lang\/Integer\r\nareturn<\/pre>\n
aload_1\r\ninvokevirtual java\/lang\/String\/length()I\r\nireturn<\/pre>\n
Java 8 \u2013 A new approach<\/h2>\n
<\/a><\/p>\naload_1 \/\/load the names var\r\n\r\n\/\/ call its stream() func\r\ninvokeinterface java\/util\/List.stream:()Ljava\/util\/stream\/Stream;\r\n\r\n\/\/invokeDynamic magic!\r\ninvokedynamic #0:apply:()Ljava\/util\/function\/Function;\r\n\r\n\/\/call the map() func\r\ninvokeinterface java\/util\/stream\/Stream.map:\r\n(Ljava\/util\/function\/Function;)Ljava\/util\/stream\/Stream;<\/pre>\n
\/\/ a function named lamda$0 that gets a String and returns an Integer\r\nlambdas\/Lambda1.lambda$0:(Ljava\/lang\/String;)Ljava\/lang\/Integer;<\/pre>\n
The Lambda code<\/h4>\n
aload_0\r\ninvokevirtual java\/lang\/String.length:()\r\ninvokestatic java\/lang\/Integer.valueOf:(I)Ljava\/lang\/Integer;\r\nareturn<\/pre>\n
Summary<\/h2>\n
\n <\/p>\n