วีดีโอ

Thank you really much! 💛

On it! 😁

Definitely noted, thanks! 😁🙌🏻

Thanks a lot! And hey there fellow Rustacean! 🙌🏻

Oh, that's nice! Anything to share like a crates.io link? ☺️

Not throwing shade at Rust. Extension methods have been a great addition to the C# language, so I'm glad to see it as part of the Rust ecosystem as well. ...now if only we could get Rust-style enums. (discriminated unions?)

True in production code. Just made it explicit here to showcase the general concept. ☺️

Ja. ☺️ Dankesehr!

@ Hast du deutsch kanal? Ich will deutsch und rust praktiken at the same time))

@ im moment noch keinen deutschen Kanal, sorry. ☺️

Cannot take someone serious who(writes(this(unreadable(mess(lmao))))) 😂

@@RustIsWinning That's still method chaining.

@@anon_y_mousse Fair point. At least I looked it up and found method cascading which I have never seen before. Learned something new today lol

True, Kotlin also has it, with their extension methods. ☺️

Thanks a lot and super glad you like it! 😁🙌🏻

Sure, in reality, a good idea. Probably not necessary to explain the concept. ☺️

boo

False that's only possible if you re-export the trait from the source library.

The import is always explicit ☺️

@@oliverjumpertzme so? thats not what im talking about at all.

@@Cm0nd00d you can boo me but im right. not everything rust does is per definition good. i write a ton of rust and some parts of it are just shit and some design decisions are baffling and bad.

Would you care to explain? C++ only has abstract classes and inheritance, Java requires you to implement any interface at the class declaration level and has inheritance, Kotlin has extension functions, which work similarly to Rust and inheritance, JavaScript only has the global prototype, TypeScript as well, Go only has promoted structs, so...I'd love to hear your thoughts on this. ☺️

@oliverjumpertzme I found this wikipedia page, even though it doesn't seem very... sourced. en.m.wikipedia.org/wiki/Extension_method. But the idea is that either it's dynamic, or there's a keyword like "extension" that makes it much more readable. Or for more function-oriented languages like common lisp or Julia it's as simple as writing a function, like you did in the video, because there is not the alternative of the dot syntax. I probably exaggerated on the "good part", but my basic idea is that, even if I can understand the beauty of having everything come from the same concept like traits, it can make things harder to read and understand. For me personally it demotivates me from seriously trying the language.

@@oliverjumpertzme I found this wiki page, even though it doesn't seem very... sourced. en.m.wikipedia.org/wiki/Extension_method But the idea is that either it's dynamic, or there's a keyword like "extension" that makes it much more readable. Or for more function-oriented languages ​​like common lisp or Julia it's as simple as writing a function (exactly like the alternative in the video, but in those languages ​​it automatically becomes methods). I probably exaggerated on the "good part". My basic idea is that, even if I can understand the beauty of having everything come from the same concept like traits, it can make things harder to read and understand. For me personally it demotivates me from seriously trying the language.

@@oliverjumpertzme He might be thinking of C sharp.

I have watched my video over and over again to find issues…and you directly find one. Damn. That's definitely a mistake. There shouldn't be an arrow. 😅

@oliverjumpertzme 😂 It happens to the best of us, for me it's useful to let a few hours pass before I look at something again and the errors jump at me.

@ guess what, I did that for several days. 😂

Thank you! 💛 super glad you like it 🙌🏻

Hey, I use Davinci Resolve and basically just keyframe-animate images. For the code snippets, I use Snappify. ☺️ does this help?

Just amazing DX! 💛

Awwww, thank you! 💛

Yep! I was looking forward to those so much. Super happy they are finally here 💛

If you like traits and async, check out the async_trait crate :D Didn't know about it and had a lot of boiletplate code in my project. That crate is true magic.

Phew, many, to be honest. But the best training is probably building something yourself, learning along the way by googling yourself through any issue you encounter. :)

@@oliverjumpertzme Thanks for the tip! I totally agree sometimes the best way to learn is just diving in and figuring things out as you go. If you don't mind, could you share the source as well

@@julietlukasunny5651which source exactly do you mean? If you don't mind me asking. 😅

Hey, thanks a lot! Oh, if I ever make it to St. Louis, I'll remember that! 💛

Due to API constraints. Except is still nicer tho

Thanks! And absolutely noted as an idea! 💛

Hey, thanks a lot! 💛 Regarding your question: I think we need to distinguish between errors and bugs here ( once again :) ). The question, thus, is: Is your response not building correctly a real bug or something you should expect and handle? First of all, I'd make sure that your route handler either returns a Result<Response, SomeError> or something like Result<Response, (StatusCode, String)> (because the latter can easily be converted to a valid response by axum's buit-in converters). If you return a non-dynamic response, i.e. no dynamic contents or just little, mostly statically defined in your source code, I'd still use expect because if that Response doesn't build, that's a real bug. An example of the sole return statement of a handler function: Ok(Response::builder() .status(StatusCode::TEMPORARY_REDIRECT) .header("Location", "example.com/redirect-url".into()) .body(Body::empty()) .expect("This response should always be constructable")) There is nothing really dynamic in this response and building that should not fail if you do everything correctly. Or let's say: If something fails, that's a bug. If you have a highly dynamic response that you can't really control, I'd map to an internal server error, like so: Ok(Response::builder() . status(StatusCode::OK) .header("Cache-Control", DEFAULT_CACHE_CONTROL_HEADER_VALUE) .body(json!(response_object).to_string()) // given some Error implements IntoResponse, so axum can convert it correctly .map_err(|_| SomeError::INTERNAL_PROCESSING_ERROR)?) or Ok(Response::builder() . status(StatusCode::OK) .header("Cache-Control", DEFAULT_CACHE_CONTROL_HEADER_VALUE) .body(json!(response_object).to_string()) // given your return type is Result<Response, (StatusCode, String)> .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Processing failed".into())?) But I think to have understood that you do something like this?: get_optional_value() .ok_or_else(|_| Response::builder().status(StatusCode::NOT_FOUND).body(Body::empty())...???) If that's the case, I think the same rules apply. If it is completely static, use expect. Your hard-coded response not building correctly is a bug: get_optional_value() .ok_or_else(|_| Response::builder().status(StatusCode::NOT_FOUND).body(Body::empty()).expect("Oops, bug!")) If it is highly dynamic, you have a problem because your return type basically needs a Response but building that response is fallible, which would lead to an infinite loop of map_err's with question marks (I hope you understand what I mean). So my suggestion: Either make your peace with expect, or change the return type of your handler function to something more flexible like: Result<Response, (StatusCode, String)> or Result<Response, impl IntoResponse>, which gives you a lot more flexibility to define your errors. Alternatively, create an error type that implements IntoResponse (which also carries the risk of having to build a fallible Response again that...yea...might end in the same infinite loop of error handling). Does this help, or shall we go over this in more detail? :)

Hey, glad to hear that! Yes, it is. ☺️

Agree. Some cost is always associated with something. But as said: zero-additional cost would also be okay, for me. ☺️

I am well aware of that, but that was not the main point of the video, which is why I used an example everyone would understand, no matter their experience in Rust. ;) And no, multiple equals signs never panic. They just return an err because for this particular example, we only allow key=value. If you really want equals signs to be allowed in either key or value, I’d actually involve quotes in the grammar, like most sane languages and parsers do.

If you REALLY know what you're doing…you're free to. 😂

You can well do that. A common impl I see (and also use) is From<&str>, for example, and even String implements From<&str>. :) The only thing From implies (by the docs is): The conversion MIGHT not be cheap, or you MUSTN'T rely on it being cheap. It does not specifically say anything about the base value, although in theory, From is meant to take ownership. But in the end, it's perfectly fine to do that. The docs just list a few requirements that are usually associated with the conversion: 1. The conversion is *infallible* 2. The conversion is *lossless* 3. The conversion is *value-preserving* 4. The conversion is *obvious*

Yep! The "really" best way to express the problem in Rust is probably this implementation (as already shown and discussed in other comments): fn try_from(input: &str) -> Result<Self, Self::Error> { let mut split = input.split('=').map(str::trim).map(str::to_owned) match (split.next(), split.next(), split.next()) { (Some(key), Some(value), None) => Ok(Self{ key: key.to_owned(), value: value.to_owned() }), _ => Err(ParsingError::MalformedRecord(input.into())), } } I generally agree that I'd do it this way. In this case, I just had to make an easy-enough example to showcase the problem, which also does not turn away complete Rust newbies. So in general, in this example, you CAN "implement the problem away" by using more advanced language features. :)

@@oliverjumpertzme That's a creative way of using pattern matching. Didn't even cross my mind. I guess the only downside is it's allocating a tuple. Might use that in my parsing implementations from now on actually Also, I agree, sometimes just using "match" is better. Especially if you need to treat errors as "warnings" and use a control statement such as "continue;"

No, it would result in a: Record { key: "key", value: "" } :)

”The guy” had a point to make which was not to optimize each and every bit of some code. 😉

Yes. As shown. But for many programs, even a secondary thread panicking can bring the whole system down. ☺️

Do you mean: if split.len() != 2 { return Err(ParsingError::MalformedRecord(value.into())); } Yea, that also works. :) There are several ways to do it. I chose this approach to illustrate the overall thing better. Optimization is a good thing, but it often costs additional explanation. View this just as example code to prove a point.

Awesome! 💛

Awwww, I am sure I still have a lot to learn, but this makes my day…so thank you! 💛

Thanks for watching and the feedback 💛🙏🏻