Expected distribution of lambda sizes (Re: Syntax poll, take 2)

[Maurizio Cimadamore]

On 15/06/11 14:22, Ben Evans wrote:
> On Tue, Jun 14, 2011 at 8:26 PM, Jack Moxley<jack at moxley.co.uk>  wrote:
>
>> Whatever syntax is chosen remember that it WILL be abused, and some poor
>> sod like me is going to have to find the issue and then teach the
>> perpetrator as to why it was abuse.
>>
>> To sum up, expect the unexpected.
>>
>>
> This is precisely why we need a syntax containing a "Yoo-hoo, I'm a lambda"
> character.
>
> The syntax should favour the poor maint programmer - who is sooner or later
> going to be us when woken at 0300 and hungover.
>
> As we now seem to be debating alternatives (despite Brian's instructions),
> here's the blog post I wrote about this:
>
> http://www.java7developer.com/blog/?p=326
Hi Ben,
I went through the examples in your blog entry - I think that the syntax 
in your post looks way more verbose than it is in practice; the first 
problem is that your example seems not to be correct, as it uses 
type-variable declaration syntax in a use-site position; i.e. stuff like:

.sort(#(Pair<T, V extends Comparable<T>>  l)(l.get(1)))


Is wrong, as 'V extends' cannot appear here. I think that what you want 
to achieve here is to push up constraints on V at the method declaration 
level, as follows:

<T, V extends Comparable<T>> List<V> schwarz(List<T> x, Function<T, 
Pair<T,V>> f) {
       return map(#{T w -> f.apply(w) }, x)
          .sort(#{Pair<T, V> l -> l.fst()})
          .map(#{Pair<T, V> l -> l.snd()});
    }

This is already way shorter than your version.

Secondly, note that you can take advantage of type-inference for lambda 
parameters, which further reduces your examples to:

<T, V extends Comparable<T>> List<V> schwarz(List<T> x, Function<T, 
Pair<T,V>> f) {
       return map(#{ w -> f.apply(w) }, x)
          .sort(#{ l -> l.fst()})
          .map(#{l -> l.snd()});
    }

Or, with method references:

<T, V extends Comparable<T>> List<V> schwarz(List<T> x, Function<T, 
Pair<T,V>> f) {
       return map(#{ w -> f.apply(w) }, x)
          .sort( Pair<T,V>#fst() )
          .map( Pair<T,V>#snd() );
    }

Maurizio
> Thanks,
>
> Ben
>