Javaslang VS Kategory

If you want to cut down on code verbosity in Java, I recommend instead looking into using Java 17 (records), and/or the Vavr library (port of some Scala standard library approaches to Java). https://github.com/vavr-io/vavr

If I managed to gain you interest you can take a look at one of the following libraries like cats, scalaz for scala and vavr for java which contain type class definitions and implementations for common types.

I'm aware not everyone likes it, but vavr has these.

https://github.com/vavr-io/vavr/releases showed Vavr 0.10.4 from July 2021 as latest release. 🤷

I would like to see a more fully-functional tool set available in Java itself. (Functors, Applicatives, Monads, Arrows, and more) Vavr is kind of doing that, but also kind of not really. Scala has all of that, and Scala is fun for sure, but it brings in a lot of baggage for interop. (Sometimes that's not a great choice, e.g. for an old legacy project)

Functional Programming is becoming more and more popular. Spring provides a couple of DSLs for the Kotlin language. For example, the Beans DSL and the Routes DSL allow for a more functional approach toward Spring configuration. On the type side, Vavr (previously Javaslang) is pretty popular in Java, while Kotlin has Arrow.

Or perhaps they could implement it like String. String has mutators but they don’t change the original value. To get the modified one, assign it to another variable. Another example is the collection framework of vavr.

Yeah, it has nice funcional capabilities and libraries (like Arrow[0]).

[0]: https://arrow-kt.io

Last but not least, Scala is currently the language with one of the best effect systems in my opinion (https://zio.dev/). Kotlin for example has copied the approach with https://arrow-kt.io/ which I think is great actually. But when comparing Scala and Kotlin here, Scala wins by a large margin, it is a completely different world. It's like building a highly concurrent system in Erlang vs C.

Of course, if you don't want to learn things like union types, traits/typeclasses and effects (similar to async/await but more powerful) you will be annoyed by Scala. But once you learned them, you can never go back.

In my own code, I started to use explicit error handling. I'm currently experimenting with Result (from https://github.com/michaelbull/kotlin-result) and Raise (from https://arrow-kt.io/).

Are there any more-or-less established functional crates in Rust (similar to Kotlin’s Arrow)?

I wonder how the community sees adding Arrow besides standard Kotlin language features. Is it something that's still considered useful or just redundant and causing more confusion?

You can define a function like context(EitherEffect) suspend fun MyType.bind(path: String)like the ones in https://github.com/arrow-kt/arrow/blob/b608a054a5318fe57d7055c35bb64a5effb053b6/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/computations/either.kt