Is there any reason that these cannot exist side-by-side as extension methods?
If they are safe to co-exist, then you can create each of the alternatives in
turn within a sample project and try them out. The extension method mechanism
is open and available.
public static <S,T> List<T> collect(Iterable<S> self,
@ClosureParams(FirstParam.FirstGenericType.class) Closure<T> transform)
public static <S,T> List<T> collect(Iterable<S> self, Function<? super
S, ? extends T> transform)
Otherwise, I think the going advice is to use Java streams if you want a
lambda/method reference friendly API. There is an ticket in JIRA about making
streams a bit more "groovy": https://issues.apache.org/jira/browse/GROOVY-10026
-----Original Message-----
From: Christopher Smith <[email protected]>
Sent: Tuesday, April 27, 2021 6:37 PM
To: [email protected]
Subject: GDK retrofit for Java functional interfaces
Since Paul is now threatening us with a 4.0 beta, I wanted to float an idea
that I've been thinking over for a bit now that might be best to add there
(though maybe it would be okay in 3 still, with the Java 8 baseline).
A large number of the GDK extension methods (particularly stuff like `with`,
`collect`, and similar) have signatures that rely explicitly on Closure for
their strategies. This means that there are interoperability problems with
libraries that provide strategy implementations as functional types; e.g.,
imagine this trivial
example:
```
public UnaryOperator<Integer> multiplier(int multiplicand) {
return x -> x * multiplicand;
}
```
I can't say `[1, 2, 3].collect(multiplier(2))`, because `collect` takes only a
Closure.
I would like to (ideally) alter the signatures of the methods in
DefaultGroovyMethods and similar to replace Closure with the "more static"
interfaces where possible; most of these cases would end up being Function,
Consumer, and some of the other usual suspects, with some of the extension
methods being duplicated to account for the cases where the GDK currently does
runtime magic like arity detection.
In the alternative, at least adding overrides for these would support
language-level interoperability.
What is the opinion regarding making this change, and what kinds of
compatibility problems might result from replacing Closure with (e.g.) Function
rather than adding a new override?
