rfcs VS rust-gc

That nobody has gone through the effort of collating its requirements and writing an RFC after https://github.com/rust-lang/rfcs/pull/770 was closed (back in 2015).

I assume a big issue is that this is full of edge cases up the ass, and the value is somewhat limited in the sense that if you know you want durable writes you'll sync() and know you're fucked if you get an error, but close() does not guarantee a sync to disk, as the linux man page indicates:

> A successful close does not guarantee that the data has been successfully saved to disk, as the kernel uses the buffer cache to defer writes.

I never heard of "German strings" in place of the small string optimization before! And there had been way too many proposals to add such types to the standard library [1] [2] [3] [4]. My understanding is that:

1. Both `Vec` and `String` should share the same layout as part of the standard library's contract.

2. Unlike `String`, the equivalent optimization for `Vec` is more questionable especially when T might be any type. C++ standard libraries frequently do implement multiple layouts for std::string but not for std::vector for the same reason.

3. Rust never allows an implicit copying of `String` in the first place, which greatly benefits from the SSO, so the lack of SSO in Rust is less important compared to C++.

[1] https://github.com/rust-lang/rust/issues/4991

[2] https://github.com/rust-lang/rust/issues/20198

[3] https://github.com/rust-lang/rfcs/pull/2990

[4] https://github.com/rust-lang/unsafe-code-guidelines/issues/4...

nrc was poking at the problem in 2016 https://internals.rust-lang.org/t/struct-field-defaults/3412 which led to this RFC https://github.com/rust-lang/rfcs/pull/1806

It got postponed because it wasn't going to make it into Rust 2018: https://github.com/rust-lang/rfcs/pull/1806#issuecomment-327...

You can check out Rust-langs RFC Repo to see their well-documented and thorough process for an RFC.

Finally, I found the answer in the RFC Book (RFC stands for Request For Comments). RFC 2451 from 2018-05-30 that starts with the following lines:

RFC: Add large language models to Rust

https://github.com/rust-lang/rfcs/pull/3603

Man, SO and family has really gone downhill. That top answer is absolutely terrible. In fact, if you care, you can literally look at the RFC discussion here to see the actual debate: https://github.com/rust-lang/rfcs/pull/582

Basically, `for x in y` is kind of redundant, already sorta-kinda supported by itertools, and there's also a ton of macros that sorta-kinda do it already. It would just be language bloat at this point.

Literally has nothing to do with memory management.

rust-langdev has a lot of libraries for building compilers in Rust. Perhaps you could use these to make your implementation easier, and revisit it later if you want to build things from scratch. I'd suggest logos for lexing, LALRPOP / chumsky for parsing, and rust-gc for garbage collection.

There's nothing stopping you from doing that in Rust. See rust-gc for an example of a GC implemented in Rust. Another example is mozjs, which is Rust bindings to SpiderMonkey. The GC there is implemented in C++, but it shows how you'd structure wrapper types for GC'd pointers in Rust so that you can use them safely, even with all the "ugliness" of a browser-grade GC.

One can have a GC as a library, https://github.com/Manishearth/rust-gc

The ones I am aware of are gc and broom. None will be as simple to use as the one in old Rust as userland implementations don't have the benefit of first-class integrated compiler support.

Rust has rust-gc, which is an attempt to add opt-in GC over Rust's more traditional automatic memory management. It's a neat project, but I'm not sure where it's actually being used.

Inb4 "already exists": the question is about making it convenient, not just imlementing the behavior.

There is also a library implementation of garbage collection for Rust, made by someone from the Rust core team.

Yep! And I'd actually fully agree those are garbage collection, there's also a crate by Manish which does """real""" garbage collection—https://github.com/Manishearth/rust-gc

I don't know that I'd say it "works" - it's never a technique I've needed to use myself, but it's the approach taken by e.g. https://github.com/Manishearth/rust-gc

Anyway, I found something recent that implements "rc" but in terms of tracing: https://github.com/Manishearth/rust-gc/ . Maybe useful for projects involving graphs of objects.