submitted 4 months ago* (last edited 4 months ago) by to c/programmer_humor@programming.dev
 

made in gimp, with <3

Context for actual rust programmersI 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 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;
    }
}

top 50 comments

sorted by: hot top controversial new old
[–] 115 points 4 months ago* (2 children)

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.

  • source
  • hideshow 4 child comments
  • [–] 20 points 4 months ago (2 children)

    Ah yes, the good old random pile of unclear errors because you forgot to add the file in git thanks nix

  • source
  • parent
  • hideshow 4 child comments
  • [–] 8 points 4 months ago (1 child)

    random pile of unclear errors

    warning: Git tree '/path/to/repo' is dirty

  • source
  • parent
  • hideshow 2 child comments
  • [–] 84 points 4 months ago (3 children)

    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?

  • source
  • hideshow 6 child comments
  • [–] 31 points 4 months ago (1 child)

    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.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 16 points 4 months ago (2 children)

    This is for people who learnt C++ in 2008 and refuse to believe that they've never fucked up a malloc in their lives

  • source
  • parent
  • hideshow 4 child comments
  • [–] 2 points 4 months ago

    Hah I learned c++ in the 90s and never felt shame for messing up an allocation.

    I think when this happens, I have a puddle of memory, the spilled ram “lubricates” the pointers, which often rub against each other. The wasted memory acts like oil does to a rusted chain. It’s helping push the program through the finish line.

    Yes, I am having fun here

  • source
  • parent
  • [–] 14 points 4 months ago (1 child)

    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...?

  • source
  • parent
  • hideshow 2 child comments
  • [–] [S] 8 points 4 months ago (1 child)

    i've edited the post content for context, and a small puzzle for rust programmers

  • source
  • parent
  • hideshow 2 child comments
  • [–] 3 points 4 months ago

    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.

  • source
  • parent
  • [–] 62 points 4 months ago (3 children)

    output makes no sense

    C++ template errors enter the room

  • source
  • hideshow 5 child comments
  • [–] 16 points 4 months ago (1 child)

    Template errors make sense as long as you carefully read the entire error, but nobody has ever actually done that.

  • source
  • parent
  • hideshow 2 child comments
  • load more comments (1 reply)
    [–] 41 points 4 months ago (1 child)
  • [–] 40 points 4 months ago

    So a narrow but clear win for the Rust compiler still...

  • source
  • [–] 37 points 4 months ago
    cargo() {
      cargo $@
      echo So how you doin\' today?
    }
    

    Fixed

  • source
  • [–] 32 points 4 months ago (3 children)

    I thought the rust compiler was supposed to be polite and helpful (unlike gcc, or nix).

  • source
  • hideshow 6 child comments
  • [–] 8 points 4 months ago (1 child)

    gcc was unhelpful a couple decades ago. I've found it to be rather helpful in recent years.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 30 points 4 months ago

    cargo delete this_post

  • source
  • [–] 21 points 4 months ago*

    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 .await statement 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 concise

    async fn four() {
        let content = do_stuff().err().map(|err| err.to_string());
        if let Some(content) = content {
            let _ = do_stuff_2(content).await;
        }
    }
    
  • source
  • [–] 13 points 4 months ago

    I love the rust compiler, it makes debugging so easy

  • source
  • [–] 10 points 4 months ago (1 child)

    Just a guess, but are you missing + Send on your error type?

  • source
  • hideshow 2 child comments
  • [–] 6 points 4 months ago

    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 the Send + 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.

  • source
  • parent
  • [–] 8 points 4 months ago

    This is an awful "meme"

  • source
  • [+] 4 points 4 months ago* (last edited 3 months ago)
    [–] 3 points 4 months ago

    First mistake was using async

  • source
  • [–] 2 points 4 months ago

    It never asks me :(

  • source
  • [–] 2 points 4 months ago (2 children)

    https://xkcd.com/303/ vs this guy who thinks 20 seconds is a long time

  • source
  • hideshow 3 child comments
  • [–] 2 points 4 months ago

    I've done professional work on an old Unix system where the full build was more than 2 hours, and an incremental stop-rebuild-restart cycle was 20 minutes.

    You get to where you really stare at your edits for a while before you hit build.

  • source
  • parent
  • load more comments (1 reply)
    load more comments
    view more: next ›