On Tue, 17 Oct 2023 08:05:09 GMT, Per Minborg <pminb...@openjdk.org> wrote:
> This PR proposes to add a number of "capturing factories" in classes in the > `java.util.function` package. > > The PR additionally (an optionally) proposes to add a new function > `UnaryOperator::andThenUnary` to allow composition while retaining the > `UnaryOperator` type. > > With the new changes, it is possible to write code like this (example from > `java.util.function.Function`): > > > // Resolve ambiguity > var function = Function.of(String::isEmpty); // Function<String, Boolean> > var predicate = Predicate.of(String::isEmpty); // Predicate<String> > > // Fluent composition > var chained = Function.of(String::length) // Function<String, Integer> > .andThen(Integer::byteValue); // Function<String, > Byte> > > > Please see the original bug report for a comprehensive description of these > proposed changes. > > Note: It is not the objective to promote `var` declaration or to prevent > previous ways of capturing lambdas and method references. The comments in the > code above is for explaining the binding and once that becomes obvious, such > comments are likely to not appear in real code. Users that prefers having a > normal type declaration can still do that. > > Note: Functional interfaces of primitives have not been considered (in this > round). Otherwise, functional interfaces that might be ambiguous or that > supports composition have been included. Hence, `Supplier` did not get a > factory method. Maybe we should add a section to the java docs where we explain the implication if using a method reference and an overload is added later? ------------- PR Comment: https://git.openjdk.org/jdk/pull/16213#issuecomment-1766335165
