Still lots of kotlin-features I don't see land in java soon. My favorite is passing a lambda in brackets when it's the last argument to a function. Makes it easy to make semi-dsls and nice-looking code. So instead of

  myFun(someVar, { it.something() }) 

it can be written like

  myFun(someVar) {
    it.something()
  }

or if no parameters to the function other than the lambda like

  myFun {
   it.something()
  } 

making the function almost look and behave like a language keyword. I also use extension-functions a lot. Especially for libraries or legacy-java code we wont touch. Where I work we now use Kotlin for all new backend code. And we don't do any Android.

I abuse the hell out of this and @DSLMarker. Such a small but amazing feature.

I do that too, but a real macro facility would be a lot nicer. There are a lot of things that cannot nicely be implemented using the existing syntax.

Yep, wish we had that. I had to satisfy myself with annotations and kotlinpoet for now.

Very Groovy.

is that modeled on ruby ?

This is a very common idiom in Scala. Function definition is slightly different, but usage is the same.

Any example ? or an idiom name I can google ?

Groovy also does it. I have no idea what the name is though: https://mrhaki.blogspot.com/2009/11/groovy-goodness-passing-...

Not sure about the exact name. But kotlin also has "function with receiver" that together with this makes it very easy to write almost a custom domain language on top of kotlin.

Can't edit, but here's an explanation https://kotlinlang.org/docs/reference/type-safe-builders.htm...

Swift calls it trailing closure syntax

Ok so it's an explicit parameter, the function is just ~curried so you can just write it nicely.

Not at all, it is very common in ML languages, Smalltalk, and even Groovy already had it.

I never saw that idiom in any ml classes.. I'm honestly surprised

It is a common idiom for dealing with deterministic resource management, and takes advantage that in ML all functions are single parameter actually.

So you can partially specialize, and then the lambda gets the already allocated/opened resource, thus acting as region/arena resource allocator.

And you can combine it with currying to apply the concept to multiple kind of parameters.

I don't know, but you can do the exact same thing in Swift.

Spring sells to everyone, I am old enough to have seen that playbook with Groovy as main actor.

Groovy was good in what it set out to do, i.e. bringing Python freshness into the vast Java ecosystem.

I loved Grape for single-file scripts. Does any language have similar single-file dependency manager? I guess Go, but then, you have to compile Go, so it might not be as useful, because you distribute binaries anyways.

Scala does, thanks to Ammonite:

https://ammonite.io/#import$ivy

>I believe pattern matching might land in Java sooner than in Kotlin

Depends on what you call pattern matching. Kotlin had pattern matching from day one, but it's just one level, Java might have it recursive by java 19

Calling Kotlin's when pattern matching is a stretch. Even the official documentation doesn't call it like that anywhere.

Well, fr sealed classes it's quite good, but yeah, nothing like the scalas and haskells of this life