The Rust I wanted had no future

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

CodeRabbit: AI Code Reviews for Developers
Revolutionize your code reviews with AI. CodeRabbit offers PR summaries, code walkthroughs, 1-click suggestions, and AST-based analysis. Boost productivity and code quality across all major languages with each PR.
coderabbit.ai
featured
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
featured
  1. leptos

    Build fast web applications with Rust.

    > I wish Rust would have someone like Facebook pick it up and build a frontend framework for it

    We have yew, and my personal favourite: leptos (https://leptos.dev/)

  2. CodeRabbit

    CodeRabbit: AI Code Reviews for Developers. Revolutionize your code reviews with AI. CodeRabbit offers PR summaries, code walkthroughs, 1-click suggestions, and AST-based analysis. Boost productivity and code quality across all major languages with each PR.

    CodeRabbit logo
  3. rfcs

    RFCs for changes to Rust

    Interesting that tail calls are mentioned and implied to never come to Rust. I agree with your assessment and actually there is a RFC[1] in the works to support them. (Note that while I'm the author, this RFC is definitely a community effort.)

    [1] https://github.com/rust-lang/rfcs/pull/3407

  4. cppfront

    A personal experimental C++ Syntax 2 -> Syntax 1 compiler

    > - := for assignment is similar enough to what is used in math for definition, so that languages like Pascal use it

    I think its cppfront that is taking the approach of `:=` being a declaration with the type being inferred (ie shorthand for `: Type =`). Reading up on that has made me the most ok with applying this to functions (which I see coming up more these days) but I think i still prefer functions having a more distinct look as I process them differently when reading. Now, cppfront's approach to types I think is bonkers, making critical details hard to find except maybe through convention.

    https://github.com/hsutter/cppfront

    > <> for inequality is something SQL got right

    Maybe I'm not recognizing the biases of my own learning background but this never reads right to me vs "not equal" / `!=`.

    > - concise keywords like `fn`

    In other discussions, it sounded like Graydon had an upper limit of 4 characters for keywords

    https://www.reddit.com/r/rust/comments/13oemrg/question_abou...

    For me, I had a "whoosh" moment for `fn` and always thought it a weird abbreviation, completely overlooking "fn" keys on laptops.

  5. inko

    A language for building concurrent software with confidence

    Perhaps you'd be interested in Inko (https://inko-lang.org/). It's obviously not there yet in terms of tooling and what not, but it might scratch an itch for those looking for something a bit like Rust, but easier to use.

    Disclaimer: I'm the author of said language :)

  6. ponyc

    Pony is an open-source, actor-model, capabilities-secure, high performance programming language

    "Exterior iteration. Iteration used to be by stack / non-escaping coroutines, which we also called "interior" iteration, as opposed to "exterior" iteration by pointer-like things that live in variables you advance. Such coroutines are now finally supported by LLVM (they weren't at the time) and are actually a fairly old and reliable mechanism for a linking-friendly, not-having-to-inline-tons-of-library-code abstraction for iteration. They're in, like, BLISS and Modula-2 and such. Really normal thing to have, early Rust had them, and they got ripped out for a bunch of reasons that, again, mostly just form "an argument I lost" rather than anything I disagree with today. I wish Rust still had them. Maybe someday it will!"

    I remember that one. The change was shortly after I started fooling with Rust and was major. Major as in it broke all the code that I'd written to that point.

    "Async/await. I wanted a standard green-thread runtime with growable stacks -- essentially just "coroutines that escape, when you need them too"."

    I remember that one, too; it was one of the things that drew me to the language---I was imagining something more like Pony (https://www.ponylang.io/).

    "The Rust I Wanted probably had no future, or at least not one anywhere near as good as The Rust We Got."

    Almost certainly true. But The Rust We Got is A Better C++, which was never appealing to me because I never liked C++ anyway.

  7. rust-playground

    The Rust Playground

    The compiler won't choke, but it will stop you from accessing the value.

    It doesn't matter if you omit the `else` clause or not, the type system ensures that you can't access invalid values.

    Here's a bit of an example based off of @Ygg2's code: https://play.rust-lang.org/?version=stable&mode=debug&editio...

  8. logic

    Logic backend implementation for Robot Rumble

    I've just been browsing, eg., https://github.com/robot-rumble/logic/blob/master/lang-runne...

    Have a look at real-world rust repos that are more than simple application code.

    Personally, I feel like I'm being visually assaulted.

  9. SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    SaaSHub logo
NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts

  • What backwards-incompatible changes would you make in a hypothetical Rust 2.0?

    10 projects | /r/rust | 19 Apr 2023
  • Why Turborepo is migrating from Go to Rust – Vercel

    7 projects | /r/golang | 8 Mar 2023
  • What are Rust’s biggest weaknesses?

    7 projects | /r/rust | 17 Nov 2022
  • Why does Rust bindgen have bitfields?

    3 projects | /r/rust | 10 Jun 2022
  • What are legitimate problems with Rust?

    12 projects | /r/rust | 21 May 2022

Did you know that Rust is
the 5th most popular programming language
based on number of references?