ZIO VS kotlinx.collections.immutable

scala has 2 healthy and pretty complete lib ecosystems : check out typelevel and ZIO. Both are FP oriented, which might not be your cup of tea at first glance but I would encourage you to try em out ! Softest introduction would be to start with the typelevel cats library and build up from there. The excellent Scala with Cats will ease you softly into an FP mindset. It's a bit dated and for scala 2 only but translating to Scala 3 is a very good exercise if you feel so inclined !

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.

ZIO

Links: - https://dotty.epfl.ch/ - https://scala-native.org/en/stable/ - https://www.scala-js.org/ - https://typelevel.org/ - https://zio.dev/ - https://github.com/scala-native/scala-native/pull/3120 - https://github.com/lampepfl/dotty/pull/16517 - https://dotty.epfl.ch/docs/reference/experimental/index.html - https://scala-cli.virtuslab.org/ - https://scalameta.org/metals/ - https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html - https://www.scala-lang.org/blog/2023/04/18/faster-scalajs-development-with-frontend-tooling.html - https://www.scala-lang.org/blog/2022/08/17/long-term-compatibility-plans.html

For the Rx approach, The ZIO framework for Scala has a streaming API that can meet those sorts of requirements. e.g.

This tutorial will introduce how to build from scratch, a REST microservice using the ZIO framework, and examples of ZIO dependency injection, ZIO HTTP, JSON, JDBC, and others from the ZIO environment. The source code is available here

I use ZIO (http://zio.dev) for Scala which makes parallel programming trivial.

Wraps different styles of asynchronicity e.g. callbacks, futures, fibers into one coherent model. And has excellent resource management so you can be sure that when you are forking a task that it will always clean up after itself.

Have yet to see anything that comes close whilst still being practical i.e. you can leverage the very large ecosystem of Java libraries.

The one advantage Rust has over Scala is that it detects data races at compile time, and that's a big time saver if you use low level thread synchronization. However, if you write pure FP code with ZIO or Cats Effect that's basically a non-issue anyway.

In Clojure, it is called an Atom. I created my own via AtomicReference and https://github.com/Kotlin/kotlinx.collections.immutable. It works really well in Kotlin. It works especially well if you use tons of coroutines.

So does Java! Also, kotlinx.collections is still not stable and I don't think they are intending to make it so any time soon.

If you want to have O(1) with prepend you use the LinkedList. You get a lot of functional benefits but also all of the downsides like no random access. You can use the https://github.com/Kotlin/kotlinx.collections.immutable library to get O(log_64(n)). I haven't spent a ton of time on Tries so I might be a little wrong on that bound. BTW, these are persistent immutable data structures. At work, we use them inside of AtomicReference to roll our own Clojure Atoms.

This is why Kotlin refers to List as read-only, and not immutable, and has created a library for truly immutable collections: https://github.com/Kotlin/kotlinx.collections.immutable

What I know is only based on this discussion. It seems that pcollections is really outdated and should not be considered.

If you want true immutable collections, kotlinx.collections.immutable provides them. They will likely be integrated into the language eventually with value classes and better immutability support.

I could see this argument made with Clojure, but I don't really see what makes Scala significantly better at FP than Kotlin. Kotlin has an official persistent data structures library nowadays, and it's got lambdas and higher order functions.

It's not immutable, it's read-only, https://kotlinlang.org/docs/reference/collections-overview.html . I think that's a false assumption. But I get the point - immutable collections are not part of the std - for very good reasons. But we know each other, I assume that you will disagree :) For people who know what they want and know all the implications, there is https://github.com/Kotlin/kotlinx.collections.immutable .