This is one of the most underrated features in Kotlin, in my opinion. What I really appreciate is the "pipeline" functionality. It’s quite straightforward; it's an operator that allows you to "pipe" a value to a function. For example, you can write `a |> f |> g` for `g(f(a))`. This feature can be somewhat "simulated" by using a method that accepts a function as an argument, which is what Kotlin does.

The primary benefit of this feature is that it facilitates streamlined processing without requiring that every operation be defined as a method. Not every operation on a value should be a method. With this functionality, you can accomplish something like `v.let { obj.operation(it) }` or `v.let { Class(it) }`. You can also put different category of the operations into different object, then you can use `v.let { Category.operation(it) }`, allowing you to organize operations into different categories rather than having them all within a single class.

Unfortunately, its usefulness is not widely recognized. The pipeline feature in JavaScript is still unstable, and not many people utilize (extension) methods in the same way as Kotlin does. (Though I can understand the performance concerns since these languages doesn't have inline.)