kotlinx.collections.immutable VS scala-cli

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 .

That has not much to do with the JVM. See Scala CLI[1] for instance, the developer experience is pretty similar to Cargo.

The thing is, with any non-trivial project, zero to hello world isn't a very useful metric. Gradle (and Maven, sbt, ...) do a lot more than Cargo, and their usage is primarily optimized for complex multi-modules projects.

[1] https://scala-cli.virtuslab.org

Scala CLI v1.0.5 was released. https://github.com/VirtusLab/scala-cli/releases/tag/v1.0.5 This includes:

The new official Scala build tool / compiler front end (scala-cli) is amazing,

https://scala-cli.virtuslab.org/

The thing that really struck me after years of python is how it lets you out dependencies directly in a comment on top of a script and it will download and run with them automatically, without poisoning any system settings. It's so simple!

sbt can indeed be a bit harsh for beginners. If your aim is not to build a big project, you might want to use scala-cli instead : no complex build script, only command line goodness to run, test, compile and package your code. Yes it supports dockerization. No need for a dockerfile.

Imo the tooling has to become way more user friendly. The Scala community has picked up on this and made Scala-CLI the official running tool for Scala. It's a great tool for single module projects and makes everything from adding dependencies to building fat jars very easy, also the runner comes as a native image. The reason I'm mentioning is because sometimes we forget how hard it can be as a beginner, especially when younger people are used to simpler CLIs from newer languages.

We even have a ticket for something similar right here. Feel free to upvote and/or comment on it.

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

Code gens are not that far away: https://github.com/VirtusLab/scala-cli/issues/610

Check out Scala CLI as it will very soon be the one true and sanctioned way to get started.