Add Consumer1<Tuple[N]<T1, ..., TN>> Tuple.consumer(Consumer[N]<T1, ..., TN>) and Function1<Tuple[N]<T1, ..., TN>> Tuple.function(Function[N]<T1, ..., TN>)

[lukens]

Does anything like the following currently exist in jOOL, or would there be any appetite for adding something like it? I created my own, as I couldn't find anything.

public class Tuple2Lambdas {

    public static <A, B> Predicate<Tuple2<A, B>> predicate(BiPredicate<A, B> predicate) {

        return (tuple) -> predicate.test(tuple.v1, tuple.v2);

    }

    public static <A, B, R> Function<Tuple2<A, B>, R> function(BiFunction<A, B, R> function) {

        return (tuple) -> function.apply(tuple.v1, tuple.v2);

    }

    public static <A, B> Consumer<Tuple2<A, B>> consumer(BiConsumer<A, B> consumer) {

        return (tuple) -> consumer.accept(tuple.v1, tuple.v2);

    }

}

This allows the following:

        Seq.seq(tuple2List)
            .filter(predicate(this::validHit))
            .map(function(this::getDisplayMatch))
            .forEach(consumer(this::processResult));

or:

        Seq.seq(tuple2List)
            .filter(predicate((hit, property) -> hit.getId().equals("blah")))
            .map(function((hit, property) -> tuple(hit.explanation(), property.getId())))

rather than the more long winded:

        Seq.seq(tuple2List)
            .filter(tuple -> validHit(tuple.v1, tuple.v2))
            .map(tuple -> getDisplayMatch(tuple.v1, tuple.v2))
            .forEach(tuple -> processResult(tuple.v1, tuple.v2));

or more opaque:

        Seq.seq(tuple2List)
            .filter((tuple) -> tuple.v2.getId().equals("blah"))
            .map((tuple) -> tuple(tuple.v1.explanation(), tuple.v2.getId())

Most times when I've rolled my own solutions to Java's lambda limitations I then find jOOL has beaten me to it, but I couldn't find anything in this case.

[lukens]

Something like the following allows it to other TupleNs (though consumers are trickier, and would probably require ConsumerNs to match the FunctionNs [and the predicates are a little hacky]):

public class TupleLambdas {

    public static <A, B> Predicate<Tuple2<A, B>> predicate2(Function2<A, B, Boolean> predicate) {

        return (tuple) -> predicate.apply(tuple.v1, tuple.v2);

    }

    public static <A, B, R> Function<Tuple2<A, B>, R> function2(Function2<A, B, R> function) {

        return (tuple) -> function.apply(tuple.v1, tuple.v2);

    }

    public static <A, B, C> Predicate<Tuple3<A, B, C>> predicate3(Function3<A, B, C, Boolean> predicate) {

        return (tuple) -> predicate.apply(tuple.v1, tuple.v2, tuple.v3);

    }

    public static <A, B, C, R> Function<Tuple3<A, B, C>, R> function3(Function3<A, B, C, R> function) {

        return (tuple) -> function.apply(tuple.v1, tuple.v2, tuple.v3);

    }

...

}

[lukaseder]

Thank you very much for your suggestion. There are some good ideas here, and there's definitely appetite for it.

There's no need explicitly add the degree to function methods. Overload resolution will be non-ambiguous when the lambda argument types differ in arity. I'm not quite sure what caveat you've spotted with consumers, though.

Note, this could go both ways. There is also potential of adding, e.g.

interface Tuple2<T1, T2> {
    static BiPredicate<T1, T2> biPredicate(Predicate<? super Tuple2<T1, T2>> predicate);
    static <R> BiFunction<T1, T2, R> biFunction(Function<? super Tuple2<T1, T2>, ? extends R> function);
}

The question is, where to put these methods...

[lukens]

I wasn't sure if it would be necessary to add the degree to the methods, I thought probably not, but erred on the side of caution (as Java always likes to pretend that it's worse at implicit resolutions than it actually is).

The issue with consumers was that there is no consumer above 2nd degree, I tried to get around this by using a Function3 instead, but the problem is then that the lambda you are wrapping has to return something (even if just null), which isn't very nice.

So, you'd have something like:

    public static <A, B, C> Consumer<Tuple3<A, B, C>> consumer(Function3<A, B, C, Void> function) {
        return (tuple) -> function.apply(tuple.v1, tuple.v2, tuple.v3);
    }

But then to use it would need to do something like:

        Seq.of(tuple(1, 'a', "hello"), tuple(1, 'a', "hello")).forEach(consumer((i, c, s) -> {
            System.out.println(i + " - " + c + " - " + s);
            return null;
        }));

If there was a Consumer3 we wouldn't need to do this.

I may be missing a solution to this problem though, or something else in the toolbox that could be used.

[lukaseder]

I see. We can certainly add those consumers: #215. C# has actions between degrees 1 and 16, too.

[lukaseder]

Consumer1 .. Consumer16 are now available via #215.

[lukaseder]

I've added your original suggestion for Function and Consumer. Still a bit reluctant about Predicate (and other primitive type specialisations) for now.

My own suggestion will be treated in a separate issue

[lukaseder]

Thanks again for your suggestion. I think this will be very useful! If you have any other ideas, just shoot, always happy to discuss