Going through some exercises on basic Rust syntax and ownership. Links: Exercises: https://101-rs.tweede.golf/A1-language-basics/mod.html, Slides: http://artificialworlds.net/presentations/rust-101...

cross-posted from: https://diode.zone/videos/watch/9766d1f1-6018-48ec-ad67-e971758f8a3a

Going through some exercises on basic Rust syntax and ownership.

Links:

Rust 101 is a series of videos explaining how to write programs in Rust. The course materials for this series are developed by tweede golf. You can find more information at https://github.com/tweedegolf/101-rs and you can sponsor the work at https://github.com/sponsors/tweedegolf . They are released under the Creative Commons Attribution Share Alike 4.0 International license.

This series of videos is copyright 2023 Andy Balaam and the tweede golf contributors and is released under the Creative Commons Attribution Share Alike 4.0 International license.

These videos are roughly on track with the Reading Club apparently, so this video belongs here this week, I think.

  • maegul (he/they)@lemmy.mlMEnglish
    1·
    10 months ago

    Ok, so the first exercise here 1-basic-syntax/01.rs throws me a little bit. With the compiler error it’s easy enough to fix, but conceptually I didn’t actually have this down.

    fn multiply(a: i32, b: i32) {
    a * b
}

    This function is invalid. The crucial error from the compiler is:

    error[E0308]: mismatched types
 --> src/bin/01.rs:6:5
  |
5 | fn multiply(a: i32, b: i32) {
  |                            - help: try adding a return type: `-> i32`
6 |     a * b
  |     ^^^^^ expected `()`, found `i32`

    So the quick fix it needs is a return type. That’s fine.

    The bits that throw me are:

    • The default return type is an empty tuple? (whatever is meant by ()).
    • There is no type inference on the return type? For let v = a * b; rust is happy to infer that v: i32, why not a function’s return? I’d guess some policy of ensuring function declarations are clean with respect to types and reaping the compiling and safety features that follow that.
    • JayjaderMEnglish
      2·
      9 months ago

      I think I have some answers for you if you haven’t resolved them yet:

      • the default return type is not an empty tuple, but the unit type which basically represents a unit of computation being performed, without any data as output (i.e. purely side-effects are allowed). It is kinda the equivalent of void from java- and c-style languages. Here is a decent explanation on StackOverflow if you prefer that sort of thing.
      • there absolutely is inference on the return type (I’ve used it in other rust projects before), but I can’t remember if it only, or also takes into account how the function is externally called. In any case, this function’s sole use is on the line
          println!("{}", multiply(10, 20));

      And “sadly” (for us here), this doesn’t explicitly say “I am expecting an int/i32 as output of multiply”, it only says “I am expecting something that implements the Display trait”. I think that in such cases it defaults to assuming the unit type () because it is the “simplest”/“most conservative” guess the compiler can make in such cases.

        • JayjaderMEnglish
          2·
          9 months ago

          I found a more precise answer re: type inference: https://stackoverflow.com/questions/24977365/differences-in-type-inference-for-closures-and-functions-in-rust

          As I understand it, if a function is public you will need to explicit the return type. If it’s private/local/not visible from outside the module wherein it is defined, then inference can kick in.

          But generally, you’ll want to specify the return type to make the compiler that much more aware of your intent.

          • maegul (he/they)@lemmy.mlMEnglish
            1·
            9 months ago

            That makes a lot of sense. Intuitively I figured it would be something like that.

            Still, as a compilation error, it’s confusing to see an error on the unit type being inconsistent when the issue is really an untyped return. Though now I know what the unit type is it’s a bit clearer what such a compiler error is about.

            • deur@feddit.nlEnglish
              3·
              9 months ago

              This behavior is simple, it just wasn’t explained to you at the correct level.

              All blocks (code between { and }) evaluate to some value, they’re all treated as expressions. A function “without a return type” will always return () because that’s what a block that doesn’t have any “output” “returns”.

              This understanding is fundamental to Rust and, for example, is involved in understanding when we have to and don’t have to use return in a function. Quite usefully, it also allows us to organize our code by creating a new scope, i.e.

              let foo: u32 = {
    // Hate dropping mutex guards explicitly? This is one way you can avoid that (although it's arguably a code smell that I discourage and should not have even mentioned)

    // This block evaluates to 100
    100
};

              let foo: () = {
    println!("this block evaluates to the unit type");
}

              The way Rust interprets the issue with your function is:

              1. This function returns a unit type () because it doesn’t have an explicit return value
              2. The block that defines this function is evaluating to a value of type i32 which is not ()
              3. errors

              The reason the error is perhaps more unclear than it could be is because they assume you have read the Rust book or understand how blocks are expressions themselves.

              It would be valuable to look at https://doc.rust-lang.org/book/ch03-03-how-functions-work.html for more details and to gain a more thorough understanding of the topic at hand. I left out the precise details on “which expression from the block is the one that it evaluates to” other than the obvious case of “the very last expression”.

              • maegul (he/they)@lemmy.mlMEnglish
                11·
                9 months ago

                The reason the error is perhaps more unclear than it could be is because they assume you have read the Rust book or understand how blocks are expressions themselves.

                I’m not so sure that this is the issue. I understood that blocks are expressions. The issue was that I didn’t know that type inference doesn’t apply to function returns (generally). That such is not true is easy to guess, but I’d presumed as much because the task of inferring seemed no more difficult than local variable type inference.

                And so given that it’s such a simple and essential requirement, I’m not sure it wouldn’t be simpler and better to have a compiler error that simply states that an explicit return type is required.

                Seeing instead that the return type was understood to be the unit type is also confusing as the function block clearly had a return value (here, AFAIU, explicit/implicit return makes no difference). So instead of wondering about the need for an explicit return type I immediately wondered about what type the function was actually returning (ie, had I accidentally created ()).

                Of course I didn’t know about the unit type etc. But even so, as a compiler error, it’s represented in pieces rather than cutting to the core requirement of an explicit return type. Perhaps a reminder better left to a linter. I’d guess clippy warns you about this, but I thought I’d just rely on the compiler for as long as I can.