Saturday, January 8, 2011

Lambdas v.008, usable Now! Forward compatible with Java 1.7

I released Java Lambdas v.008 which allows for forward compatibility with the new Lambda implementation coming down the pike for Java 7

The idea is this. Create methods that receive a Function[0-9] or Action[0-9], and then create that lambda with either my current lambda implementation F[0-9] or A[0-9] now, or when Java 7 finally implements lambdas in the syntax, simply convert them to that official syntax #{a->a}

Let's look at an example:
Get all the people over 35 years old
To do this, we want to use the method

Query.where(ListFunction1<T, Boolean>)

S1 implements Function1, so we can write the following in Java 6

 List<Person> people =
      Query.where(getStudents()new S1<Person>(a){{ret(a.getAge() > 35);}});

However, once Java 7 releases the official Lambdas, we can convert this to the much simpler call

List<Person> people = 
      Query.where(getStudents(),#{a -> a.getAge() > 35});

Because Function1 is a SAM interface (single abstract method)

Why Use Lambdas?
Hopefully this will make it easier to start using lambdas in your production code. Lambdas(Closures) are all about using the open/closed principal . They are a bit tricky to use at 1st. But soon they will become essential to you. I think of them as the next step in subroutines. 

In simpler languages, you could create a subroutine, but not pass variables in. If you wanted to have a function 


you could, but you could not have 

People.where(int MimimumAge 
and call

Parameters allowed you to reduce duplication by saying "this variable can be different for each call".
Lambdas do the same thing, but with duplicate code. Now you can say

People.where(Function1 whereClause 
and call
People.where(#{p -> p.age > 21})

Note: For the record, I dislike the currently proposed (1/8/2011) Java 1.7 lambda syntax, and vastly prefer the C# syntax
People.where(p => p.age > 21)


No comments: