flatMap signature

[Remi Forax]

On 04/02/2013 02:44 PM, Boaz Nahum wrote:
> Stream:
> -----------------------------------------------------------------------------------------------------------
> As Brian correct me:
> <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>>
> mapper);
>
> instead of:
> <R> Stream<R> flatMap(Function<T, Stream<? extends R>> mapper);
>
> -----------------------------------------------------------------------------------------------------------
> T reduce(T identity, BinaryOperator<T> accumulator);
> and
>   Optional<T> reduce(BinaryOperator<T> accumulator);
>
> Can't be fixed because they used 'BinaryOperator', But if 'BiFunction' is
> used then we have more flexibility
> ------------------------------------------------------------------------------------------------------------
> <U> U reduce(U identity,
>                       BiFunction<? super U, ? super T, ? extends U>
> accumulator,
>                       BinaryOperator<U> combiner)
>
> Instead of:
>
>    <U> U reduce(U identity,
>                   BiFunction<U, ? super T, U> accumulator,
>                   BinaryOperator<U> combiner);
>
> Same comment regarding 'BinaryOperator'
>
> ------------------------------------------------------------------------------------------------------------
> <R> R collect(Supplier<R> resultFactory,
>                        BiConsumer<? super R, ? super T> accumulator,
>                        BiConsumer<? super R, ? super R> combiner)
>
> Instead of:
>
>      <R> R collect(Supplier<R> resultFactory,
>                    BiConsumer<R, ? super T> accumulator,
>                    BiConsumer<R, R> combiner);
>
>
> I tested all my suggestions with examples and pseudo implementation,
> example:
>
> default <U> U reduce(U identity,
>                       BiFunction<? super U, ? super T, ? extends U>
> accumulator,
>                       BinaryOperator<U> combiner) {
>
>              Collection<T> _this = ....
>
>              U result = identity;
>
>              for (T element : _this)
>                     result = accumulator.apply(result, element);
>
>              return combiner.apply(identity, result);
>
>          }
>
> If you find my comments useful, I will be more than glad to continue on
> other API.

It's very useful.
I don't want to forget one wildcard, so several eyeballs are better than 
just mine.

BinaryOperator will not be replaced by BiFunction even if, as you said,
it introduce more flexibility, a BinaryOperator ask that the two parameters
and the return type to be the same so it has conceptually more weight
(the EG already votes on that).

I also think that all Supplier<T> should be Supplier<? extends T>.

  Rémi

>
>
>
> On Mon, Apr 1, 2013 at 1:32 PM, Remi Forax <forax at univ-mlv.fr> wrote:
>
>> On 03/31/2013 05:10 PM, Boaz Nahum wrote:
>>> I have some problems when compiling with flatMap,
>>>
>>> *Maybe* the signature should be:
>>>
>>> <R> Stream<R> flatMap(Function<? super T, Stream<? extends R>> mapper);
>>>
>>> Instead of:
>>>
>>> <R> Stream<R> flatMap(Function<T, Stream<? extends R>> mapper);
>>>
>> yes, probably,
>> I will do a pass on the whole API to fix all wildcards,
>> if you or anybody on this list want to help me,
>> it would be great.
>>
>> cheers,
>> Rémi
>>
>>
>>