I want to open a discussion about challenging concepts to understand in Rust.
Share what’s difficult for you, and we can try to find a solution to that

Welcome to the Rust Developers Community, founded by Francesco Ciulla, a passionate Rust Developer who loves making videos about this cool language.

Join us to learn Rust, share knowledge, and connect with fellow Rustaceans 🦀

Rust Developers

A discussion forum for sharing and resolving challenging concepts encountered while learning Rust programming, inviting users to share their difficulties and collaboratively find solutions.

What is a concept hard to understand in Rust?

Async rust with traits such as sync / send on top of 'static lifetimes.
EG. (Little dummy code)
<pre><code>use std::sync::Arc;
use tokio::task;

struct SharedData {
 value: i32,
}

impl SharedData {
 async fn process(&amp;self) {
 println!(&quot;Processing value: {}&quot;, self.value);
 }
}

async fn perform_async_operations&lt;T&gt;(data: Arc&lt;T&gt;)
where
 T: Sync + Send + &#x27;static,
{
 let handle = task::spawn(async move {
 data.process().await;
 });

 handle.await.unwrap();
}

#[tokio::main]
async fn main() {
 let data = Arc::new(SharedData { value: 42 });
 perform_async_operations(data).await;
}
</code></pre>

Imo, borrowing and ownership are hard to understand. But over time, every programmer should know how to use them. The extensive syntax of the language is another challenging aspect to learn and remember. With AI, learning becomes much easier, but you still need a good understanding of Rust from the documentation.

Async and multithreading. Especially global state with multithreading, that’s a nightmare

I have tried to learn Rust on and off. My learning always stops at traits. The book does a good job explaining basic usage, but as soon as it gets more complicated, I start loosing it (for example when working with async Rust).

Coming from another language (Java, PHP) the way of structuring code is the most challenging for me right now.