[ninetyninenine]

I wish there was a language like rust without the borrow checking and lifetimes that was also popular and lives in the same area as go. Because I think go is actually the best language in this category but it’s only the best because there is nothing else. All in all golang is not an elegant language.

[noelwelsh]

O'Caml is similar, now that it has multicore. Scala is also similar, though the native code side (https://scala-native.org/en/stable/) is not nearly as well developed as the JVM side.

[ninetyninenine]

The problem with O'Caml is it won't get popular because people are afraid of FP. But I would be totally down to use it.

[sapiogram]

Rust loses a lot of its nice properties without borrow checking and lifetimes, though. For example, resources no longer get cleaned up automatically, and the compiler no longer protects you against data races. Which in turn makes the entire language memory unsafe.

[SkiFire13]

I believe OP meant to give it a GC like in Go, while keeping other features from Rust from enums/match/generics/traits/etc etc.

This should prevent most of the memory safety issues, though data races could still be tricky (e.g. Go is memory unsafe due to data races)

[throw-the-towel]

OTOH it would still have Rust's sane type system and all the nice features it makes possible.

[nine_k]

OCaml and Haskell already have that nice type system (and even more nice). If OCaml's syntax bothers you, there is Reason [1] which is a different frontend to the same compiler suite.

Also in this space is Gleam [2] which targets Erlang / OTP, if high concurrency and fault tolerance is your cup of tea.

[1]: https://reasonml.github.io/

[2]: https://gleam.run/

[michaelsbradley]

It’s not popular compared to Go/Rust, but many find Nim scratches that itch:

https://nim-lang.org/

[pclmulqdq]

Zig is another popular neo-language in the same rough space.

[duped]

That language is Rust, though.