@mttaggart it really was the laziest of lazy, they're literally in a function with an error return option and yolo'ing it with unwrap was sad to see. This is why the clippy lints denying usage of it (and expect) in production code are mandatory in my eyes.

Also https://nounwrap.yaleman.org for why I think unwrap should be removed and leave expect for when you really want to panic your code 😃

@mttaggart think its kinda stretching it to say it was "Buried" - it was highlighted and explained what it did and that it was the issue

@mttaggart I feel like all programming languages toe the line between being too permissive and everything breaks or too conservative and nobody uses it. For what it's worth I think rust does a good job striking this balance.

this is cloudflares fault and I really hope no one focuses their "this must never happen again" energy at Rust.

@mttaggart
Isn't crashing the right choice when your rules enforcement engine can't fit all the rules into memory?

@mttaggart oh dear. Unwrap should only be used at Christmas.

@mttaggart Do you use `assert!`?

@mttaggart If people aren't supposed to use it then it should be removed from tutorials and linters should default to alerting, otherwise the language will get the same reputation as, say, PHP because practically every tutorial I've seen about Rust teaches it the wrong way by default and rarely mentions the different correct ways.

I would consider going as far as deprecating it since it's such a massive foot-gun.

@mttaggart ROFL, it looks like they had a return type and everything.

@mttaggart TIL. Do linters flag this?

(I do not write mission critical Rust. Or even important Rust. Just learning the language, slowly. )

@mttaggart

Heh. I learned that the hard way, and I'm a novice to Rust

Change this:

let value = some_function().unwrap();

to this:

let value = some_function()?;

Stops panics and instead gracefully returns the Err up the call stack to a function that can handle it. This is how idiomatic Rust handles errors.

@mttaggart One of the first impressions I got while digging into Rust was that *some* unwrapping was useful but LOTS of unwrapping was a code smell.

Encouraged to see that understanding appears to track.