flix VS Kategory

you can use Datalig within Flix https://flix.dev/

> recently added support for package management

Are there any [plans for] supply chain attack mitigations?

Naively searching, I find https://github.com/flix/flix/issues/4380#issuecomment-123641... (Proposed Principle: A package can be declared as "safe") and https://github.com/flix/flix/issues/2837 (Add capability-safety to polymorphic effects?) the latter closed with working on something related to this https://github.com/flix/flix/issues/3000 (The Road to Algebraic Effects).

I don't know that it's one-to-one in terms of features, but I've been impressed with the Flix language, also on the jvm: https://flix.dev/ .

You might be interested in Flix which has first-class Datalog program values:

https://flix.dev/

https://doc.flix.dev/fixpoints.html

(I am one of the developers of Flix)

I like it. Modern languages that distinguish between pure and impure programs like Flix, Koka, and Effekt do so on the type level instead of syntactically. This has three advantages:

I work almost 100% in Scala because it has the most advanced functional features (proper pattern matching, higher-kinded types, typeclasses, ...) and very powerful metaprogramming abilities, while being compatible with the Java OO model as long as you consume Java libraries (the other way around can be tricky, Kotlin is much better there). Only Flix takes it further but it's still an immature project.

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