1.1. Motivation

The following source:

static double reduce(final double[] ds, double initial, final #double(double, double) reducer) {
  for (final double d : ds) { initial = reducer.callPrimitive(initial, d); }
  return initial;
}

static <T> T reduce(final T[] ts, T initial, final #T(T, T) reducer) {
  for (final T t : ts) { initial = reducer.call(initial, t); }
  return initial;
}

static <T> void time(final #T() c) {
  final long start = System.currentTimeMillis();
  final T result = c.call();
  final long finish = System.currentTimeMillis();
  System.out.println(c + " took " + (finish - start) + " ms and returned " + result);
}

static void timeTest() {
  final int size = 1024 * 1024;
  final double[] ds = new double[size];
  final Double[] ts = new Double[size];
  for (int i = 0; i < size; i++) { ts[i] = ds[i] = i; }
  final #double(double, double) sumDs = #double(final double a1, final double a2) { return a1 + a2; };
  time(new #double() { // Not supported in this proposal as yet
    @Override public double callPrimitive() { return reduce(ds, 0, sumDs); }
    @Override public String toString() { return "double[] test"; }
  });
  final #Double(Double, Double) sumTs = new #Double(final Double a1, final Double a2) { return a1 + a2; };
  time(new #Double() { // Not supported in this proposal as yet
    @Override public Double call() { return reduce(ts, 0.0, sumTs); } // note 0.0 - annoying inference bug!
    @Override public String toString() { return "Double[] test"; }
  });
}

Is translated to:

static double reduce(final double[] ds, double initial, final _Callable_double_double_double reducer) {
  for (final double d : ds) { initial = reducer.callPrimitive(initial, d); }
  return initial;
}

static <T> T reduce(final T[] ts, T initial, final _Callable_2<? extends T, ? super T, ? super T> reducer) {
  for (final T t : ts) { initial = reducer.call(initial, t); }
  return initial;
}

static <T> void time(final _Callable_0<T> c) {
  final long start = System.currentTimeMillis();
  final T result = c.call();
  final long finish = System.currentTimeMillis();
  System.out.println(c + " took " + (finish - start) + " ms and returned " + result);
}

static void timeTest() {
  final int size = 1024 * 1024;
  final double[] ds = new double[size];
  final Double[] ts = new Double[size];
  for (int i = 0; i < size; i++) { ts[i] = ds[i] = i; }
  final _Callable_double_double_double sumDs = new _Callable_double_double_double() {
    @Override public double callPrimitive(final double a1, final double a2) { return a1 + a2; }
  };
  time(new _Callable_double() {
    @Override public double callPrimitive() { return reduce(ds, 0, sumDs); }
    @Override public String toString() { return "double[] test"; }
  });
  final _Callable_Dble_Dble_Dble sumTs = new _Callable_Dble_Dble_Dble() { // Compiler bug! Should be Double not Dble
    @Override public Double call(final Double a1, final Double a2) { return a1 + a2; }
  };
  time(new _Callable_Dble() { // Compiler bug! Should be Double not Dble
    @Override public Double call() { return reduce(ts, 0.0, sumTs); } // note 0.0 - annoying inference bug!
    @Override public String toString() { return "Double[] test"; }
  });
}

And when run on my laptop gives:

double[] test took 20 ms and returned 5.497552896E11
Double[] test took 588 ms and returned 5.497552896E11

Which demonstrates the considerable performance increase reified lambdas offer (erased lambdas would perform similarly to the Double case above).

2.1. Issues specific to this specification

Type name mangling

In this weblog simple type names are used, e.g. Integer, in practice a fully qualified name is required, e.g. java.lang.Integer. Unfortunately you cannot have '.' in a type name, therefore java\,lang\,Integer could be used instead. Similarly array types need to be specified and '[' and ']' are also problematic in type names and therefore int[] could become int\{\}. These character translations, and more, are suggested by John Rose (http://blogs.sun.com/jrose/entry/symbolic_freedom_in_the_vm). '_', which I have used to separate parts of type names, is not appropriate because it is already used for inner classes; in practice you could use '+' instead (to indicate an automatically generated/added type). Thanks to Maurizio Cimadamore (http://mail.openjdk.java.net/pipermail/lambda-dev/2010-January/000258.html) for reminding me of the NextGen compiler that uses a similar solution and to Alex Blewitt (private email) for specifically pin pointing the problem.

Contravariantly-overriding wrapping

To support type safe operations like #Object(String) sO = #String(Object s) (s.toString()); lambdas are automatically wrapped (also see below but one for a separate use of contravariantly-overriding wrapping). However Java doesn't ordinarily support contravariantly-overriding, e.g. interface OS { Object m(String s); } ... interface SO extends I { @Override String m(Object o); } is illegal. Should contravariant-overriding be supported?

Contravariantly-overriding arrays of lambdas

As the specification stands you can write #Object(String)[] sOs = new #String()[] {#String(Object s) (s.toString())};. However in Java you can't say long[] ls = new int[] {1};. Should this be allowed for lambdas?

Lambda cast

The contravariantly-overriding wrapping is also used in a similar manner to promoting-conversions applied automatically to primitives, e.g. promoting int to long. For primitives there is also a reverse operation via a down-cast, e.g. i = (int)l;. Currently there is no equivalent down-cast, there should be!

2.2. Issues that might influence implementation choice

Serialization

Cannot serialize a lambda, use a named-inner class. (Serialization is hard to do for something anonymous and therefore best not supported.)

Class implementing a lambda or extending a lambda

Cannot write class CI implements #int(int) or class CE extends #int(int). (This is closely related to the next point, SAMs, and can probably be handled by the same mechanism.)

Single abstract method (SAM)

Cannot write Comparable<Integer> cI = #int(int other) (...);. (I think the From mechanism, described below, can probably be adapted for SAMs. It is desirable that a lambda can be wrapped as a SAM and it is desirable that it can be unwrapped, not supporting unwrapping is like boxing without unboxing!)

2.3. Issues that are largely orthogonal to implementation

Short lambda-call syntax

It would be nice if a lambda could be called like a method, e.g. lambda(...); in this proposal no short-syntax is discussed and the example would be lambda.call(...) for a non-primitive lambda and lambda.callPrimitive(...) for a primitive-lambda. (This may well be the final solution, since a method of calling lambdas with short syntax has yet to be found that does not have undesirable side-effects.)

Lambda syntax

The strawman syntax without type inference is used throughout this specification.

Optimizing lambda creation

If a lambda is used in an inner scope it is natural to define it in an inner scope, however this can be sub-optimal. For example if the lambda does not capture local variables or instance fields it could be defined statically. The compiler could, 'promote', the lambda to an outer-scope static automatically. (Probably OK to leave as is at the moment, since the same comments apply to inner classes and it is up to the programmer to do the 'promoting'.)

Shared writable variables

The strawman discusses the possibility of having shared writable variables, this proposal does not address this issue since it is orthogonal to the implementation. (Could use the Wrapper mechanism described below to allow the variables to be shared, which would require the Wrapper interface to be generic (which is not a problem).)

Exception transparency

Cannot be used, must wrap in an unchecked exception. (Probably OK to leave this out - i.e. it is OK to wrap checked exceptions in an unchecked exception.)

4.1. Generic Callable interfaces

Generic interfaces are used when any types involved are generic and as a base type for the reified types. These interfaces are interfaces that define a generic-abstract call method with n arguments and follow the naming convention _Callable_ n, e.g.:

public interface _Callable_0<R> { R call(); }

public interface _Callable_1<R, A1> { R call(A1 a1); }

When the loader sees in a class file the interface _Callable_ n it first checks to see if it already has this interface and if not generates the appropriate interface. The name _Callable_ n gives the loader all the information it requires (which is simply n, the number of arguments). The name _Callable_ n is unique, since other _Callable_ types (described below) do not contain the integer n since an integer is not a valid type name.

4.2. Reified abstract Callable classes

The following description of dynamic classes uses '...' to indicate part of a name that is dependent upon the type of the lambda, e.g. #Object(String) has types Object and String and '...' is replaced by Object_String.

When the loader sees in a class file the class _Callable_... it first checks to see if it already has this class and if not generates the appropriate abstract class. The name _Callable_... gives the loader all the information it requires (in particular the '...' part encodes the reified types needed). The reified _Callable_... names are distinguished from generic _Callable_ n because n (an integer) is not a type name.

public abstract class _Callable_String extends AbstractCallable implements _Callable_0<String> {}

public abstract class _Callable_Object_String extends AbstractCallable implements _Callable_1<Object, String> {}

public abstract class _Callable_int extends _Callable_Integer {
  @Override public final Integer call() { return callPrimitive(); }
  public abstract int callPrimitive();
}

public abstract class _Callable_int_String extends _Callable_Integer_String {
  @Override public final Integer call(String a1) { return callPrimitive(a1); }
  public abstract int callPrimitive(String a1);
}

public abstract class _Callable_int_int extends _Callable_Integer_Integer {
  @Override public final Integer call(Integer a1) { return callPrimitive(a1); }
  public abstract int callPrimitive(int a1);
}

4.3. From classes

There are two variations of From class and the purpose of both these From classes is to 'convert' one lambda into another. Typically this conversion is achieved by wrapping the first lambda inside itself, but it could in the case of a wrapping and then unwrapping just give back the original lambda. Whether a From... class or a _Callable_... class (the original lambda) results, it is always reified lambda that results from a From conversion.

The reified _Callable_... abstract classes implement the equivalent generic _Callable_ n interface and therefore no 'cast' is needed from a reified lambda to a generic lambda.

The first of the two variations of the From classes are those that go in the reverse direction to their inheritance hierarchy, i.e. from a generic _Callable_ n interface to a the equivalent reified _Callable_... class (reifying From). The second variation of From class is for contravariant overriding of lambdas.

All From classes follow a naming convention: _From_...__To_... where the first '...' are as used in the 'from' _Callable_... and the second '...' are as used in the 'to' _Callable_... names. If the 'from' _Callable_... is a generic interface then the '...' include the _ n as well as the type names.

public final class _From_0_Integer__To_int extends _Callable_int implements Wrapper {
  private final _Callable_0<? extends Integer> f;
  private _From_0_Integer__To_int(final _Callable_0<? extends Integer> f) { this.f = f; }
  public static _Callable_int instance(final _Callable_0<? extends Integer> from) {
    if (from == null) { return null; }
    final _Callable_0<? extends Integer> f = (_Callable_0<? extends Integer>)Wrappers.unWrap(from);
    if (f instanceof _Callable_int) { return (_Callable_int)f; }
    return new _From_0_Integer__To_int(f);
  }
  @Override public int callPrimitive() { return f.call(); }
  @Override public Object getWrappee() { return f; }
  @Override public int hashCode() { return f.hashCode(); }
}

public final class _From_String_Object__To_Object_String extends _Callable_Object_String implements Wrapper {
  private final _Callable_String_Object f;
  private _From_String_Object__To_Object_String(final _Callable_String_Object f) { this.f = f; }
  public _From_String_Object__To_Object_String instance(final _Callable_String_Object from) {
    if (from == null) { return null; }
    final _Callable_String_Object f = (_Callable_String_Object)Wrappers.unWrap(from);
    return new _From_String_Object__To_Object_String(f);
  }
  @Override public Object call(final String a1) { return f.call(a1); }
  @Override public Object getWrappee() { return f; }
  @Override public int hashCode() { return f.hashCode(); }
}

public final class _From_Integer_Long__To_Long_Integer extends _Callable_Long_Integer implements Wrapper {
  private final _Callable_Integer_Long f;
  private _From_Integer_Long__To_Long_Integer(final _Callable_Integer_Long f) { this.f = f; }
  public _From_Integer_Long__To_Long_Integer instance(final _Callable_Integer_Long from) {
    if (from == null) { return null; }
    final _Callable_Integer_Long f = (_Callable_Integer_Long)Wrappers.unWrap(from);
    return new _From_Integer_Long__To_Long_Integer(f);
  }
  @Override public Long call(final Integer a1) { return f.call(a1.longValue()).longValue(); }
  @Override public Object getWrappee() { return f; }
  @Override public int hashCode() { return f.hashCode(); }
}

public final class _From_Integer_Long__To_long_int extends _Callable_long_int implements Wrapper {
  private final _Callable_Integer_Long f;
  private _From_Integer_Long__To_long_int(final _Callable_Integer_Long f) { this.f = f; }
  public _From_Integer_Long__To_long_int instance(final _Callable_Integer_Long from) {
    if (from == null) { return null; }
    final _Callable_Integer_Long f = (_Callable_Integer_Long)Wrappers.unWrap(from);
    return new _From_Integer_Long__To_long_int(f);
  }
  @Override public long callPrimitive(final int a1) { return f.call(Long.valueOf(a1)); }
  @Override public Object getWrappee() { return f; }
  @Override public int hashCode() { return f.hashCode(); }
}

public final static class _From_int_long__To_Long_Integer extends _Callable_Long_Integer implements Wrapper {
  private final _Callable_int_long f;
  private _From_int_long__To_Long_Integer(final _Callable_int_long f) { this.f = f; }
  public _From_int_long__To_Long_Integer instance(final _Callable_int_long from) {
    if (from == null) { return null; }
    final _Callable_int_long f = (_Callable_int_long)Wrappers.unWrap(from);
    return new _From_int_long__To_Long_Integer(f);
  }
  @Override public Long call(final Integer a1) { return Long.valueOf(f.callPrimitive(a1)); }
  @Override public Object getWrappee() { return f; }
  @Override public int hashCode() { return f.hashCode(); }
}

public final static class _From_int_long__To_long_int extends _Callable_long_int implements Wrapper {
  private final _Callable_int_long f;
  private _From_int_long__To_long_int(final _Callable_int_long f) { this.f = f; }
  public _From_int_long__To_long_int instance(final _Callable_int_long from) {
    if (from == null) { return null; }
    final _Callable_int_long f = (_Callable_int_long)Wrappers.unWrap(from);
    return new _From_int_long__To_long_int(f);
  }
  @Override public long callPrimitive(final int a1) { return f.callPrimitive(a1); }
  @Override public Object getWrappee() { return f; }
  @Override public int hashCode() { return f.hashCode(); }
}

4.4. Array_From classes

These classes provide the same functionality as the _From classes above do for individual lambdas but instead operate on arrays of lambdas. All the _Array_From classes create a new array, for the 'to', and convert each element of 'from'. The name of the _Array_From class is the same as the name of the appropriate _From class with '_Array' prepended, e.g:

public final class _Array_From_0_String__To_String {
  public static _Callable_String[] instance(final _Callable_0<? extends String>[] from) {
    if (from == null) { return null; }
    final _Callable_String[] to = new _Callable_String[from.length];
    for (int i = 0; i < from.length; i++) { to[i] = _From_0_String__To_String.instance(from[i]); }
    return to;
  }
}

5.1. Lambda instances

New lambdas are created by the expression #$R$($A$ $N$) ($E$).

If either $R$ or $A$ are generic types then if either $R$ or $A$ are primitive they are converted to the equivalent primitive-wrapper classes and the expansion is:

new _Callable_1<$R$, $A$>() {
  @Overload public final $R$ call($A$ $N$) { return $E$; }
}

Else the expansion is:

new _Callable_$R$_$A$() {
  @Overload public final $R$ call($A$ $N$) { return $E$; }
}

5.2. Lambda types

The type of a lambda is given by #$R$($A$) and this may occur in different contexts as listed below.

_Callable_1<? extends $R$, ? super $A$>

_Callable_$R$_$A$

_Callable_1<? extends $R$, ? super $A$>[] $name$ = (_Callable_1<? extends $R$, ? super $A$>[]) new _Callable_1[$size$];

_Callable_$R$_$A$[] $name$ = new _Callable_$R$_$A$[$size$];

_Callable_$R$_$A$.class

(_Callable_1<$R$, $A$>)

(_Callable_$R$_$A$)

$expression$ instanceof _Callable_$R$_$A$

$genericType$<$optionalWildcardSyntax$ Callable$1<? extends $R$, ? super $A$>>

5.3. Assignments and initializations

To facilitate reifying generic lambdas and contravariant-overriding, 'safe' automatic-conversion via loader-generated From classes are supported for assignment and initialization of variables, method parameters, and array elements (for arrays see next section).

A running example is used below:

$lValue$ = $rExpression$

Where the type, after expansion, of $lValue$ is _Callable_$RL$_$AL$ and the expanded-type of $rExpression$ is either _Callable_1<? extends $RR$, ? super $AR$> or _Callable_$RR$_$AR$ depending on if it is reified or not. Note $lValue$ is reified else no 'conversion' is added by the compiler (it is not an error or a warning for $lValue$ to be generic, it just means that the compiler does not need to add a 'conversion').

In the description below the phrase $R$ "is convertible to" $L$ is used to indicate that $R$ has is the same as $L$, $R$ is a subtype of $L$, or $R$ is a primitive or primitive-wrapper that can be converted to $L$ which is also a primitive or primitive-wrapper. The automatic conversion of primitives and primitive-wrappers is usual in Java, e.g. int to long.

In summary, the possible actions are:

1. If the type of $lValue$ is generic, do nothing.
2. If the type of $rExpression$ is exactly the same as the type of $lValue$, do nothing.
3. If the type of $rExpression$ is generic, possibly insert a reifying conversion (see section 5.3.1).
4. If the type of $rExpression$ is reified, possibly insert a contravariant-overriding conversion (see section 5.3.2).

lValue = _From_1_$RR$_$AR$__To_$RL$_$AL$.instance(rExpression);

lValue = _From_$RR$_$AR$__To_$RL$_$AL$.instance(rExpression);

5.4. Array assignments and initializations

To facilitate reifying arrays of generic-lambdas and contravariant-overriding of lambda arrays, 'safe' automatic-conversion via loader-generated Array_From classes are supported for assignment and initialization of array variables, method parameters, and array-array elements (for none arrays see previous section).

In the following:

$lValue$ = $rExpression$

The expanded type of:

$lValue$

Is _Callable_1_$RL$_$AL$[] (generic) or _Callable_$RL$_$AL$[] (reified)

$rExpression $

Is _Callable_1_$RR$_$AR$[] (generic) or _Callable_$RR$_$AR$[] (reified)

If $RR$ is $RL$ and if $AR$ is $AL$ then no expansion is necessary.

Else if $lValue$ generic and $RL$ "is convertible to" $RR$ and if $AR$ "is convertible to" $AL$ then no expansion is necessary.

Else if ($RR$ "is convertible to" $RL$ and if $AL$ "is convertible to" $AR$) or ($RL$ "is convertible to" $RR$ and if $AR$ "is convertible to" $AL$) then the expansion is one of:

Both $lValue$ and $rExpression $ generic:

lValue = Array_From_1_$RR$_$AR$__To_1_$RL$_$AL$.instance(rExpression);

Generic $lValue$ and reified $rExpression $:

lValue = Array_From_1_$RR$_$AR$__To_$RL$_$AL$.instance(rExpression);

Reified $lValue$ and generic $rExpression $:

lValue = Array_From_$RR$_$AR$__To_1_$RL$_$AL$.instance(rExpression);

Both $lValue$ and $rExpression $ reified:

lValue = Array_From_$RR$_$AR$__To_$RL$_$AL$.instance(rExpression);

Else there is a type error that should be reported.