Your SlideShare is downloading. ×
0
Implementing Closuresin Java (and on the JVM)Ben Evans, TeamSparq, LJC, JavaSE Exec Committee, etc
What do we mean by Closures Anyway?• An age-old argument.• Here’s what I mean by it (YMMV):• A unit of deferred execution•...
Inner Classes• One trick we see a lot of in Java is the “tiny anonymous inner class”• Used in CallbackHandlers, Runnables ...
A Simple Example• Very simple example...• So I won’t need to spend very much time on it at all...
Aside: Did You Spot The Important Word?•   The important word is “final”•   This means that captured variables are immutab...
Oh, OK Then...• Now it should be quite a bit clearer what’s going on.• How are we going to represent our new Closures / fu...
Function Types• Function<X, Y> looks like a good bet  for a function type• This is an example of a structural type• Howeve...
SAM Types and Auto-Conversion• Function types have some problems• We don’t want to introduce structural typing• What else ...
Grammar & SyntaxFor the BNF Grammar-hounds:lambda = ArgList Arrow Body  ArgList = Identifier        | NilaryArgList       ...
Syntax Example - java.util.concurrent• Eclipse doesn’t like the syntax yet• We have a lambda standing in as a Runnable (an...
Syntax•   Eclipse still doesn’t like the syntax•   In fact, Eclipse doesn’t really like the Java 7 <> syntax yet•   Note t...
Backwards Compatibility & Interfaces• Java is always very keen not to break backwards compatibility• There are no map(), f...
Default and Extension Methods• Idea: Weave a default implementation into classes which are  missing their own at class loa...
Work In Progress - Come and Help Out•   All this work is happening now•   OpenJDK 8 is rolling along•   Java 8 is now targ...
Thank You – Questions?http://www.teamsparq.net                 Twitter: @kittylyst                             http://www....
Bonus – Retrofitting the implementation• In Java 8, Closures are SAM types• They can’t be anything else – there isn’t anyt...
Bonus - Beyond Closures•   Coroutines•   Producer / consumer shares•   Collaborating threadpool•   Continuations•   Tuples...
Upcoming SlideShare
Loading in...5
×

Java Closures

3,869

Published on

A quick presentation given at Soho School Nights talking about Closures in Java 8 and the JVM

Published in: Technology, News & Politics
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
3,869
On Slideshare
0
From Embeds
0
Number of Embeds
4
Actions
Shares
0
Downloads
44
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • Transcript of "Java Closures"

    1. 1. Implementing Closuresin Java (and on the JVM)Ben Evans, TeamSparq, LJC, JavaSE Exec Committee, etc
    2. 2. What do we mean by Closures Anyway?• An age-old argument.• Here’s what I mean by it (YMMV):• A unit of deferred execution• A bit of code that can be passed around like a value• Can be used as the RHS of an assignment statement• Capture the relevant part of the lexical environment they were created in
    3. 3. Inner Classes• One trick we see a lot of in Java is the “tiny anonymous inner class”• Used in CallbackHandlers, Runnables and all sorts of other situations.• These are a way to implement Lambdas / Closures – Objects are values – Classes can capture local state – They can do deferred execution• Let’s take a look at an example (and not a standard CallbackHandler or Runnable)
    4. 4. A Simple Example• Very simple example...• So I won’t need to spend very much time on it at all...
    5. 5. Aside: Did You Spot The Important Word?• The important word is “final”• This means that captured variables are immutable• Some people don’t like this• But there are interactions with multithreaded code to worry about• You can always defeat it with the array-of-1 trick• But that doesn’t mean that you should• Mutable state is often the enemy. We shouldn’t be encouraging it
    6. 6. Oh, OK Then...• Now it should be quite a bit clearer what’s going on.• How are we going to represent our new Closures / function- like units of code? Is this a good way?
    7. 7. Function Types• Function<X, Y> looks like a good bet for a function type• This is an example of a structural type• However, what about Type Erasure?• Java is a strongly-typed language – Closures & lambdas have to be strongly-typed• What about Reified Generics?• Can we represent our Function-like objects in a different way?• Groundwork for some of this was laid in Java 7 – most of this is due in 8 though
    8. 8. SAM Types and Auto-Conversion• Function types have some problems• We don’t want to introduce structural typing• What else can we do?• Enter the SAM type – Single Abstract Method• One way of thinking about a lambda / closure is as an implementation of a interface with just 1 method (method signature matters, though)• If the type signature is compatible, shouldn’t we be able to auto- convert between two different SAM types?• We also need method literals, e.g. Object#toString• What should the syntax look like?
    9. 9. Grammar & SyntaxFor the BNF Grammar-hounds:lambda = ArgList Arrow Body ArgList = Identifier | NilaryArgList | "(" Identifier [ "," Identifier ]* ")" | "(" Type Identifier [ "," Type Identifier ]* ")" Body = Expression | "{" [ Statement ";" ]+ "}“This is pretty much identical to the C# and Scala syntaxThere are good and bad things about this – no syntax is perfect, and this one hasits share of downsides.However, this is the syntax, so get used to it & move on
    10. 10. Syntax Example - java.util.concurrent• Eclipse doesn’t like the syntax yet• We have a lambda standing in as a Runnable (and closing over hndl)• So far, just retrofitting to existing APIs
    11. 11. Syntax• Eclipse still doesn’t like the syntax• In fact, Eclipse doesn’t really like the Java 7 <> syntax yet• Note the type inference of x• Classic example of “slightly functional programming”• The map() takes a function which maps Integer -> Integer• The filter() takes a function which maps Integer -> boolean• However, there’s something wrong with the above...
    12. 12. Backwards Compatibility & Interfaces• Java is always very keen not to break backwards compatibility• There are no map(), filter() etc methods on the Java collections today• Adding them to the core collections interfaces would break backwards compatibility.• Pre-8 class files would no longer be able to link against new code• This would be very bad• But we want our Lambdas / Closures!• Need to do something different / smarter
    13. 13. Default and Extension Methods• Idea: Weave a default implementation into classes which are missing their own at class load time• Add a synthetic method which is wired in using invokedynamic and Method Handles• Called “public defender” or Miranda methods• New Java language keywords: – “extension” indicates that a method in an interface does not need to be implemented – “default” indicates which method should be used as the fall-back • Use the AbstractFoo implementation class of Foo (if it exists) • Or specify another method (probably as a method reference)
    14. 14. Work In Progress - Come and Help Out• All this work is happening now• OpenJDK 8 is rolling along• Java 8 is now targeted at Summer 2013• jdk8-dev is the mailing list• As of yesterday, the pre-built developer preview is out:• http://jdk8.java.net/download.html• Get involved and have a play• Block, Mapper, Predicate and their friends in java.util.functions are waiting for you... •
    15. 15. Thank You – Questions?http://www.teamsparq.net Twitter: @kittylyst http://www.java7developer.com
    16. 16. Bonus – Retrofitting the implementation• In Java 8, Closures are SAM types• They can’t be anything else – there isn’t anything for them to be.• Everything is either a ref type (ie an object) or a primitive type.• But we can imagine a future version of Java (maybe 9) which had new VM structures• “Typesafe function pointer primitives”• The spec for lambdas is being written to allow for possible future, non-class-based implementations• This would also be important to bring this tech to Java ME-like platforms
    17. 17. Bonus - Beyond Closures• Coroutines• Producer / consumer shares• Collaborating threadpool• Continuations• Tuples• Could some of these make Java 8 (or 9) ?• Active group involved in working in this space - contact me for more details
    1. A particular slide catching your eye?

      Clipping is a handy way to collect important slides you want to go back to later.

    ×