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;
    }
}
  • wisha@lemmy.ml
    2·
    4 个月前

    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;
    }
}
  • [object Object]@sh.itjust.worksEnglish
    2·
    4 个月前

    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.

      • bobo@lemmy.ml
        0·
        4 个月前

        random pile of unclear errors

        warning: Git tree ‘/path/to/repo’ is dirty

        • Ephera@lemmy.mlEnglish
          1·
          4 个月前

          Unfortunately, that shows up even when you’ve just modified an existing file, which is not a problem for it.

          And which also happens to be the state my repo is in basically all the time, because I’ll change some setting, then see if it works like I want it to before making a commit…

      • Ethan@programming.devEnglish
        1·
        4 个月前

        Yes, preferring a language that’s easy to read and therefore easy to maintain over a language like Rust is definitely coping 🙄

        • WhyJiffie@sh.itjust.worksEnglish
          2·
          4 个月前

          preferring Rust over Rust? what do you mean?

          do you think loosely typed python is easy to read and maintain?

            • edinbruh@feddit.itEnglish
              1·
              4 个月前

              Yeah, like, who would ever want to

              stuff1()?.map(stuff2);

              It’s much better to just:

              err, value = stuff1();
if err == nil 
    return err, nil;
if value != nil
    stuff2(value);

              And you might even:

              for a in vec {
    vec[a]
}
              • Ethan@programming.devEnglish
                0·
                4 个月前

                I totally agree, that Go snippet is absolutely more maintainable. Though you forgot the curly braces and the semicolons are unnecessary.

                • AeonFelis@lemmy.world
                  1·
                  4 个月前

                  Though you forgot the curly braces and the semicolons are unnecessary.

                  Yup. These are pretty big issues. But there are also some minor, trivial, purely-preference-based issues - like returning an error if err == nil instead of when it isn’t.

      • verdare@piefed.blahaj.zoneEnglish
        1·
        4 个月前

        Yeah, recent versions of GCC have gotten a lot better. I suspect it’s actually because of languages like Rust raising the bar.

            • SpaceNoodle@lemmy.world
              0·
              4 个月前

              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.

              • WhyJiffie@sh.itjust.worksEnglish
                1·
                4 个月前

                no they didn’t, yes it could have happened:

                1. GCC: exists, not too good messages
                2. rust gets made
                3. rust gets popular
                4. 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