ashleygwilliams / a-very-brief-intro-to-rust Goto Github PK

In the example test function, it demonstrates your complete lack of understanding for how Option<> works in Rust. You supply the argument some of the time, in the form of what should be the "contained" type, and in another test, you leave it out altogether. Not to mention that the input type for the tested function does not take an Option<>.

There is a missing semicolon at the end of the line defining str1 in the first example of concatenation, and str2 in the second.

There is also a missing semicolon at the end of whos definition in the "Option" example, and in the testing example.

You appear to be using the documentation (///) comment type in your examples, rather than the correct regular (//) comments. You should only use /// when documenting your code so it can be parsed by rustdoc.

Many of your examples imply that it returns &str, and you do also directly state it returns &str.

- `format!` is also a macro. We talked about it before as a way to build `str`s out of
  `str`s.

As described in https://doc.rust-lang.org/nightly/std/macro.format.html

Use the syntax described in std::fmt to create a value of type String. See std::fmt for more information.

It should be Option<&str>, but &str is written.

Thanks for these slides!

In slide 15 the comment mentions a trailing comma.

This looks like maybe it's something you mention in the talk, but as someone just reading the slides without that context I don't know what it means. What does it mean?

Maybe a third bullet to explain it? Or an * at the end?

In its current state, it combines two strings, one with a space included, but wouldn't it be nice to include the space in the format!() template string?

Hey hey!

I am very much a beginner rustacean who comes and looks around at rust bookmarks once a month or so and really appreciate this resource

A few months ago (oh god, it was six months ago) I focused really hard on Rust for a few days and made a bit of small progress, and one of my small breakthroughs was realizing that "signed" and "unsigned" weren't some super advanced CS thing (maybe about like.. cryptography?) but actually kind of simple/understandable. Maybe I'm the only one who is thrown off by this term, bc all of the rust resources I looked at treated it as kind of obvious... but I think an introductory resource like this might as well cover that base. I think a helpful way to do it would be to give some examples on the slide that introduces them. Something like:

u32: unsigned 32-bit integer (for example, 4 or 5)
i32: signed 32-bit integer (for example, -4 or positive 7)

(feel free to run with that or anything else)

Thanks for making this!