Name of lambda parameters

[Tim Peierls]

On Tue, Jan 8, 2013 at 3:14 AM, Remi Forax <forax at univ-mlv.fr> wrote:

> On 01/07/2013 07:16 PM, Brian Goetz wrote:
>
>> I think this goes into the general bucket of "you can't do reflection
>> below the method level in Java", and lambda expressions are expressions and
>> therefore below the method level.  Is lambda somehow special here?
>>
>> On Mon, Jan 7, 2013 at 5:33 PM, Remi Forax <forax at univ-mlv.fr <mailto:
> forax at univ-mlv.fr>> wrote:
>
>> Lambda are anonymous functions, so yes, they are special. They can be
>> called, have parameters, like methods so reflection should work otherwise
>> you can't specify meta-protocol using lambdas and having JEE being able to
>> use lambdas seems a good idea.
>>
>> On 01/08/2013 12:16 AM, Tim Peierls wrote:
>
>> What does "you can't specify meta-protocol using lambdas" mean, and why
>> is it a reason to add further complexity?
>>
>
> In JEE context, a meta-protocols is specified usually by adding
> annotations classes or methods or method parameters to add dependency
> injection, SQL query mapping, JSON mapping, etc.
>
> By example, with lambdas you can write an easy to use API that let you
> decode JSON in a 'streamy' way,

If I want to parse: [...some JSON with firstName, age, phoneNumber, etc.
> ...]
> JSONStream stream = ...  (outputStream);
> stream.parse((String firstName, int age, JSONStream phoneNumber) -> {
>   System.out.println(firstName + " " + age);
>   phoneNumber.parse((String type, String number) -> {
>      System.out.println(number);
>   }
> });
>
> for that, you need a way to do reflection on parameter names (and
> annotations).
>

If Java had function types, this would make more sense. Sounds like you
want reflection to help address what you think of as a deficiency of the
language.

It's OK if there are still some things that can't be written more compactly
with lambdas. You can already implement something like this in Java 7:

stream.parse(new Object() {
    String firstName;
    int age;
    void parse(JSONStream phoneNumber) {
        System.out.println(firstName + " " + age);
        phoneNumber.parse(new Object() {
            String type;
            String number;
            void parse() {
                System.out.println(number);
            }
        });
    }
});

I don't think the added complexity of specifying reflection for lambdas
justifies the marginal (at best) improvement in readability that lambdas
provide in this example.

--tim
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mail.openjdk.java.net/pipermail/lambda-libs-spec-experts/attachments/20130108/96f5d806/attachment-0001.html