Rust-playground Alternatives

rust-playground reviews and mentions

• Rust project goals: Immobile types and guaranteed destructors
  7 projects | news.ycombinator.com | 2 Aug 2026

  Here is an example of the problem: https://play.rust-lang.org/?version=stable&mode=debug&editio...

  Imagine if MyTrait comes from core/std. Adding an opt-out bound like ?Sized (or ?Move) is a breaking change for any generic code that relies on Sized/Move. But you want some traits from std to be open for !Move types.

• Memory Safety Absolutists
  9 projects | news.ycombinator.com | 25 Jul 2026
• Fil-C: Garbage In, Memory Safety Out – Filip Pizlo – SSW 2026 [video]
  2 projects | news.ycombinator.com | 24 Jul 2026

  If this was an array, that is, a built-in type with a static length, this example does give a compile-time error: https://play.rust-lang.org/?version=stable&mode=debug&editio...

  However, a vector's length is inherently a runtime concept, so the compiler does not attempt to directly reason about this at compile time. However, for this exmaple, post-optimizations, it doesn't do a runtime check at all: it calls the panic directly, because the optimizer does in fact reason that this always panics and removes the dynamic check.

• IPv6 zones in URLs are a mistake
  5 projects | news.ycombinator.com | 4 Jun 2026

  In Rust there is the same problem. The `url::Url` library does not support `%`.

  `http::Uri` does, and it accepts both `%` and `%25`.

  https://play.rust-lang.org/?version=stable&mode=debug&editio...

• Int a = 5; a = a++ + ++a; a =? (2011)
  1 project | news.ycombinator.com | 14 May 2026

  > For example any mildly complex loop that involves pointer juggling can benefit.

  I'd say that when you're writing a mildly complex loop that involves pointer juggling, one should prefer to be defensive and explicit rather than cleverly trying to compress everything into one-liners.

  > So then I implement the local equivalent of inc( v ) and ... same issue, right?

  This isn't done in Rust because there's no benefit. It's rare to find an occasion where it's necessary to do something tricky enough to forego using iterators, and when working with raw pointers Rust code just plain doesn't use basic addition for pointer arithmetic; instead it has a variety of pointer arithmetic methods for being explicit about the desired semantics (e.g. ptr::add, ptr::offset, ptr::wrapping_add, etc).

  > Plus with rust macros is there any technical reason you can't trivially implement ++ for yourself?

  There's not, but people might look at you sideways. Here, I implemented it for you: https://play.rust-lang.org/?version=stable&mode=debug&editio... . It expands to nested blocks with internal assignments, which results in a well-defined semantics following the defined order of evaluation in Rust.

• Embedded Rust or C Firmware? Lessons from an Industrial Microcontroller Use Case
  4 projects | news.ycombinator.com | 3 May 2026

  Not technically. But that's not the issue. The issue is that trait resolution and imports are treated inconsistently and that is a mistake.

  Compare to [this](https://play.rust-lang.org/?version=stable&mode=debug&editio...)

• A simplified model of Fil-C
  2 projects | news.ycombinator.com | 17 Apr 2026

  https://play.rust-lang.org/?version=stable&mode=debug&editio...

  Catch the panic & unwind, safe program execution continues. Fundamentally impossible in Fil-C.

• A tail-call interpreter in (nightly) Rust
  4 projects | news.ycombinator.com | 5 Apr 2026

  Yes, I agree. Like I said, it might be useful when dealing with something that is easier to express in (tail) recursion form instead of an iteration.

  Anyway, here's something more-or-less equivalent in Rust, which will blow the stack if made to loop too many times: https://play.rust-lang.org/?version=stable&mode=debug&editio...

  (There may be a way to use a closure instead of a function to avoid hard-coding the type of `$i` in the macro, but I can't find an easy way to write a recursive closure call in Rust).

• Lisette a little language inspired by Rust that compiles to Go
  13 projects | news.ycombinator.com | 5 Apr 2026

  > the insistence of separating structs and methods.

  From a readability perspective, I do basically agree with this - it's weird that that implementation lives in a different, same-level code block to the struct itself

  But the kind-of-tautalogical explanation for _why_ it's this way is that inherent `impl` blocks are completely different language items than struct definitions.

  They're actually sort of weird because impls are crate-scoped, not module-scoped like names/symbols are (for example: [1]). So inherent impls really can be defined anywhere. A crate can even inherent impls for types defined in other crates (although that impl can only be used in the crate that defines it).

  [1]: https://play.rust-lang.org/?version=stable&mode=debug&editio...

• A Grand Vision for Rust
  10 projects | news.ycombinator.com | 7 Mar 2026

  `std::net::TcpStream`? Interestingly, it doesn't need to be mutable if you know the trick.

  * It implements `Write` for `TcpStream` which is likely what you were using. And `Write` requires `&mut`, probably because the same trait is used for writing to application buffers (e.g. through `BufWriter` or just to a `Vec`).

  * But it also implements `Write` for `&TcpStream`. So if you use the awkward phrasing `(&stream).write_all(b"asdf")`, you don't need mutable access. [2] This allows you to use it with anything that takes the trait, without requiring mutability. You might need this if say you're reading from the socket from one thread while simultaneously writing to it from another thread.

  [1] https://doc.rust-lang.org/std/net/struct.TcpStream.html

  [2] https://play.rust-lang.org/?version=stable&mode=debug&editio...

• A note from our sponsor - SaaSHub
  www.saashub.com | 8 Aug 2026

  SaaSHub helps you find the best software and product alternatives Learn more →