rust-gc VS tokio

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.

A high-performance runtime, with a multi-threaded, asynchronous event loop written in Rust (using Tokio and Hyper).

Tokio: Asynchronous Runtime for Rust

Concurrent Processing: We're able to handle multiple tasks or LLM requests that run concurrently by leveraging Rust's async capabilities and Tokio runtime to significantly speed up batch operations.

In the code above, the execute_task function simulates a task that takes some time to complete. The Rust Tokio runtime manages the main function's execution without blocking the thread, allowing other asynchronous tasks to proceed concurrently. The main function then waits for the task to finish before printing a completion message.

In this tutorial, you'll start the journey towards building Nimblecache (Redis clone) by first creating a simple TCP server using Tokio, a powerful asynchronous runtime for the Rust programming language. By the end of this tutorial, you will have a basic understanding of how to handle TCP connections and manage asynchronous tasks using Tokio. Let's dive in!

Obs: For the curious non-Rust people, tokio is an async runtime for Rust, in other words, it's like our Executor, only much more powerful and well-written.

A high-performance runtime, with a multi-threaded, asynchronous event loop written in Rust (using Tokio and Hyper).

Our choice of Rust as the programming language in 2018 was a calculated risk. Rust offers the best of both worlds: the speed and control of languages like C/C++ and the safety and ease of use of languages with runtime environments like Go. Rust and its network library ecosystem were still relatively young at that time. We invested significantly in underlying libraries like Tokio, Tower, and H2 to build the necessary infrastructure.