Add augmentation

[rmuir]

This adds the ability to have additional methods to whitelisted classes. These are just static methods taking the receiver as the first parameter. There isn't a performance hit or anything.

I added a few of groovy's enhancements to the collections api (e.g. maps n lists) to make those easier to work with. These are things such as each, collect, and so on that can be less verbose than java streams apis. Closure parameters were just swapped out for the appropriate java functional interface.

We may want to do more of them, candidates IMO would be around CharSequence/String/Pattern, to make manipulation easier for update scripts/ingest/etc.

This replaces the previous aliases functionality (which didn't work quite right in some cases) and ensures that these methods work in all situations (e.g. target of a method reference and so on). The aliases are just accomplished this way instead.

[nik9000]

CharSequence/String/Pattern

Indeed! I can have a look at some of those once this is in. Lots of them aren't really good, but a few will be helpful.

[nik9000]

static method disguised as virtual?

[rmuir]

also for the map apis, we should make a choice whether they should be BiFunction/BiPredicate like i have them here, or just Function/Predicate but taking the Map.Entry.

Its the difference between:

map.collect((key,value) -> key + value)

and

map.collect(entry -> entry.key + entry.value)

I really have no strong opinions, but in the scripting api its nearly impossible for me to tell what is a map and what is a list. By requiring lambdas on maps to take two parameters (key, value), if things are wrong it will be very clear. This is also consistent with the apis java has on Map. On the other hand it means parentheses...

[jdconrad]

LGTM! @rmuir Thanks for doing this!

[nik9000]

I prefer the BiFunction version because it has you name the key and value something interesting and you rarely ever need a Map.Entry from one of those.

[rmuir]

ok lets stick with it. we can always change it. The BiFunction has the advantage of providing the clearest error messages and least confusion, because arity gives us that (even if types are murky).