made in gimp, with <3
Context for actual rust programmers
I was having massive beef with the rust compiler yesterday, every cargo check takes 20 seconds.
And then look at the three functions below, only one of them are Send, if you know why, please let me know.
(Note: value that is not Send cannot be held across an await point, and Box<dyn Error> is not Send)
async fn one() {
let res: Result<(), Box<dyn Error>> = do_stuff();
if let Err(err) = res {
let content = err.to_string();
let _ = do_stuff(content).await;
}
}
async fn two() {
let res: Result<(), Box<dyn Error>> = do_stuff();
let content = if let Err(err) = res {
Some(err.to_string())
} else {
None
};
drop(res);
if let Some(content) = content {
let _ = do_stuff(content).await;
}
}
async fn three() {
let content = {
let res: Result<(), Box<dyn Error>> = do_stuff();
if let Err(err) = res {
Some(err.to_string())
} else {
None
}
};
if let Some(content) = content {
let _ = do_stuff(content).await;
}
}
This is an awful “meme”
You are running into the Send Approximation being too conservative. The compiler does not like to see a let binding for a non-Send type and an
.awaitstatement in the same scope. It is not (yet) smart enough to know that the non-Send type is already consumed by the time of the.await.You’ve already discovered the workaround in your
three(). To make it more conciseasync fn four() { let content = do_stuff().err().map(|err| err.to_string()); if let Some(content) = content { let _ = do_stuff_2(content).await; } }cargo() { cargo $@ echo So how you doin\' today? }Fixed
Rust output is bad? I feel like it’s one of the best in terms of telling you where you got things wrong. Nix output when you accidentally get infinite recursion is so bad.
Come to think of it, Nix fits all three better than Rust.
People who’ve never used Rust or only used it once and couldn’t grok it like to meme that Rust is bad to cope.
Yes, preferring a language that’s easy to read and therefore easy to maintain over a language like Rust is definitely coping 🙄
preferring Rust over Rust? what do you mean?
do you think loosely typed python is easy to read and maintain?
I’ll stick with Go TYVM
Ah yes, the good old random pile of unclear errors because you forgot to add the file in git thanks nix
random pile of unclear errors
warning: Git tree ‘/path/to/repo’ is dirty
Is this a comment I’m not flake enough to understand?
I get that it’s supposed to be a meme, but aside from the first one these aren’t even rust stereotypes. Is this a meme specifically for people who haven’t used rust, know nothing about rust but have maybe heard that it’s a programming language?
Yeah, part of the point of Rust is that it does exactly what you tell it - sometimes to the point of absurdity. No implicit casting for instance.
And here I was thinking most of our programming problems come from the thing doing exactly what we told it to, but didn’t quite think the process through enough. Or at all.
This is for people who learnt C++ in 2008 and refuse to believe that they’ve never fucked up a malloc in their lives
C++
malloc
You aren’t supposed to use malloc in C++ with very few exceptions.
I mean Rust is definitely known for long compilation times but yeah otherwise I am not sure how any of this is Rust-specific. Maybe by “doesn’t do what you tell it to do” they mean the borrow checker and strict compile time checks…?
i’ve edited the post content for context, and a small puzzle for rust programmers
I was actually wondering if this was supposed to be about a specific problem someone has with rust (not like I haven’t gotten stuck on some weird corner with rust before), but looking at the meme, that seemed unlikely to me. Thanks for the context.
output makes no sense
C++ template errors enter the room
Template errors make sense as long as you carefully read the entire error, but nobody has ever actually done that.
You are saying that the error messages terminate at some point?
Well, yeah, templates won’t recurse beyond 1,024 levels.
boost::msmerrors enter the roomdeleted by creator
cargo delete this_postDeterministic: ✅ ❌
Deterministic when hit by that weird cosmic ray: ❌❌
/jk
Just a guess, but are you missing
+ Sendon your error type?Yeah, I was gonna say, that might be the root cause.
In the vast majority of cases, you want
Box<dyn Error + Send + Sync>, but folks tend to leave out theSend + Sync, because it looks like additional complexity to them, and because it doesn’t cause problems when they’re not doing async/await.
It’s better to define a type alias, if you don’t want that long type name everywhere.
So a narrow but clear win for the Rust compiler still…
I thought the rust compiler was supposed to be polite and helpful (unlike gcc, or nix).
It is, this meme is just trash.
Oh god nix output
You create a new file and don’t check it into git yet.
Nix commands: “I’ve never met this file in my life!”
gcc was unhelpful a couple decades ago. I’ve found it to be rather helpful in recent years.
Yeah, recent versions of GCC have gotten a lot better. I suspect it’s actually because of languages like Rust raising the bar.
No, Rust came later.
they didn’t say otherwise
They literally did. They theorized that Rust influenced GCC’s improved error messaging. That could not have happened if GCC improved their error messaging prior to the existence of Rust.
no they didn’t, yes it could have happened:
- GCC: exists, not too good messages
- rust gets made
- rust gets popular
- gcc error messages get improved by good example of rust
gcc is not a dead project. it is continuously maintained. its improvements can be influenced by other projects like rust
But GCC did not improve their error messages (much) prior to Rust, despite Clang’s error messages comparing favorably to GCC even before Rust 1.0 was released, as for example discussed in
https://gcc.gnu.org/wiki/ClangDiagnosticsComparison?action=recall&rev=1
Rust itself is 14 years old, slightly older than above wiki page, and even back then it had great error messages, though they’ve also improved since. Here’s a fun site where you can see how error messages have evolved through Rust’s life:
https://kobzol.github.io/rust/rustc/2025/05/16/evolution-of-rustc-errors.html
It’s only very recently that GCC has started to catch up, for example with some nice improvements in GCC 15:
https://developers.redhat.com/articles/2025/04/10/6-usability-improvements-gcc-15
Oh, guess my mental timeline is wrong!
sometimes?! Cargo never makes sense to me!
It never asks me :(
deleted by creator











