วีดีโอ

Ok I checked macro's expansion, apparently it's smart enough to treat the joining only when.. you guessed it, joining. I.e its behaviour is similar to string.join(iterable) in Python or iterator.join(string) in Rust.

Hey - I just haven't had all that much time to work on the channel recently, definitely planning to come back to it whenever possible though!

That is definitely in the plans!

Hey! It's not really a code editor - I just used mdbook: crates.io/crates/mdbook You can see my source code for it here: github.com/danbugs/danlogs/tree/master/Rust/The%20Rust%20Programming%20Language%20-%20Tutorials/extra/asref_borrow

This kind of comment is what keeps me going - Thank you!

Hey - apologies on the delay getting back to you. That was actually a mistake on my part. I meant to make use of it, but, iirc, I just kind of forgot about the struct. I have a (now) pinned comment on this video w/ further details on how I intended to use it.

Any specific reason why? I’ve recently taken a liking to having it like this (:

My eyes are torn... ​@@danlogs

Good catch! I'm glad you liked the video ;D

The star symbol means: "zero or more". We see its usage in this example to match "zero or more" statements. Take this simpler macro, for example: 𝚖𝚊𝚌𝚛𝚘_𝚛𝚞𝚕𝚎𝚜! 𝚙𝚛𝚒𝚗𝚝_𝚊𝚕𝚕 { ($($𝚜:𝚕𝚒𝚝𝚎𝚛𝚊𝚕),*) => { // receiving one of more literals (like: i32s, &strs, etc.) separated by commas $( 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("{}", 𝚜𝚝𝚛𝚒𝚗𝚐𝚒𝚏𝚢!($𝚜)); )* // one println! per literal we match } } 𝚏𝚗 𝚖𝚊𝚒𝚗() { 𝚙𝚛𝚒𝚗𝚝_𝚊𝚕𝚕!(𝟷, 𝟸, 𝟹); // we're passing in 3 literals } Because of the star symbol, our 𝚖𝚊𝚒𝚗, in simplified form, expands to: 𝚏𝚗 𝚖𝚊𝚒𝚗() { { 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("{}", 𝚜𝚝𝚛𝚒𝚗𝚐𝚒𝚏𝚢!(𝟷)) }; { 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("{}", 𝚜𝚝𝚛𝚒𝚗𝚐𝚒𝚏𝚢!(𝟸)) }; { 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("{}", 𝚜𝚝𝚛𝚒𝚗𝚐𝚒𝚏𝚢!(𝟹)) }; ; } I hope this helps!

Oh, my bad - I didn't really change my mic setup from the last video, but I'll try speak closer to it next time (:

You can just normalize the audio in a video editing tool no?

@@hlavaatch ~ not afaik.

That's true, github.com/rust-lang/rust/pull/93563 was merged just this past November 🎉 ~With that said, afaik, there's still no way to fulfill the multiple-producer-multiple-consumer pattern w/ the standard library's crate as `std::sync::mpmc` is still private: play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=3650e906a764237c3d49cd572610a289

@@danlogs what is the advantage of the multiple consumer pattern? Is it faster? I don't see the advantage of that over having a single consumer in the main function that is receiving all messages

@@osgiliath_burns ~ It's not really about performance but more about the fact that sometimes, you just need multiple consumers. For example, say you have a system receiving different types of data, like temperature readings, humidity levels, and error messages from sensors. Instead of one consumer sorting and handling everything, you could have: - One consumer dedicated to handling temperature data, - Another for humidity, - And a third just for error messages. This way, each consumer only deals with what it needs to, making the code cleaner and easier to work with when you’re handling multiple tasks at once.

Hey - sorry for taking a while to get back to you! To clarify, 𝙲𝚊𝚜𝚎𝙸𝚗𝚜𝚎𝚗𝚜𝚒𝚝𝚒𝚟𝚎𝚂𝚝𝚛(..) implements the equality traits so that 𝙲𝚊𝚜𝚎𝙸𝚗𝚜𝚎𝚗𝚜𝚒𝚝𝚒𝚟𝚎𝚂𝚝𝚛("𝚔𝚎𝚢") == 𝙲𝚊𝚜𝚎𝙸𝚗𝚜𝚎𝚗𝚜𝚒𝚝𝚒𝚟𝚎𝚂𝚝𝚛("𝙺𝙴𝚈"), so 𝚏𝚑𝚖.𝚐𝚎𝚝("𝚔𝚎𝚢") will return 𝙲𝚊𝚜𝚎𝙸𝚗𝚜𝚎𝚗𝚝𝚒𝚝𝚒𝚟𝚎𝚂𝚝𝚛("𝚅𝙰𝙻𝚄𝙴"), which, in concept, is incorrect - i.e., we got a 'hash' collision for two keys that should not match. This is to highlight that, w/ this, we should use 𝙰𝚜𝚁𝚎𝚏, as the equality traits don't work the same and that's a usage requirement between the borrowed and owned type for 𝙱𝚘𝚛𝚛𝚘𝚠.

They're equivalent in terms of functionality, but some may argue that one could be more readable than the other (i.e., 𝚁𝚌::𝚌𝚕𝚘𝚗𝚎(&𝚗𝟹) is clearer in its intent of simply creating a shared reference and not a deep clone the data as .𝚌𝚕𝚘𝚗𝚎() sometimes does.)

I'm not sure I'm too confident in my artistic skills to draw you a diagram, but I'll try to explain: (Example #1) 𝚏𝚗 𝚖𝚊𝚒𝚗() { 𝚕𝚎𝚝 𝚖𝚞𝚝 𝚡 = 𝟷0; 𝚕𝚎𝚝 𝚢 = &𝚡; 𝚕𝚎𝚝 𝚣 = &𝚡; // 𝚙𝚛𝚒𝚗𝚝 𝚊𝚕𝚕 𝚟𝚊𝚛𝚜 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("𝚡: {}, 𝚢: {}, 𝚣: {}", 𝚡, 𝚢, 𝚣); // 𝚌𝚑𝚊𝚗𝚐𝚎 𝚡 𝚡 = 𝟸0; // 𝚙𝚛𝚒𝚗𝚝 𝚊𝚕𝚕 𝚟𝚊𝚛𝚜 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("𝚡: {}, 𝚢: {}, 𝚣: {}", 𝚡, 𝚢, 𝚣); } (play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=c684bf88870bd0761c27385c9a3b15ec) ^^^ this doesn't compile, as we cannot assign to 𝚡 after it's bene immutably borrowed. After this, you may think - Oh, that's ok, we can just make the references mutable! BUT... (Example #2) 𝚏𝚗 𝚖𝚊𝚒𝚗() { 𝚕𝚎𝚝 𝚖𝚞𝚝 𝚡 = 𝟷0; 𝚕𝚎𝚝 𝚢 = &𝚖𝚞𝚝 𝚡; 𝚕𝚎𝚝 𝚣 = &𝚖𝚞𝚝 𝚡; // 𝚙𝚛𝚒𝚗𝚝 𝚊𝚕𝚕 𝚟𝚊𝚛𝚜 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("𝚡: {}, 𝚢: {}, 𝚣: {}", 𝚡, 𝚢, 𝚣); // 𝚌𝚑𝚊𝚗𝚐𝚎 𝚡 𝚡 = 𝟸0; // 𝚙𝚛𝚒𝚗𝚝 𝚊𝚕𝚕 𝚟𝚊𝚛𝚜 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("𝚡: {}, 𝚢: {}, 𝚣: {}", 𝚡, 𝚢, 𝚣); } (play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=a27ce1c125a55b2387ddd5986398e106) ^^^ also does not compile, because we cannot mutably borrow 𝚡 twice. (Working Example) 𝚏𝚗 𝚖𝚊𝚒𝚗() { 𝚕𝚎𝚝 𝚖𝚞𝚝 𝚡 = 𝟷0; 𝚕𝚎𝚝 𝚢 = &𝚖𝚞𝚝 𝚡; // 𝚙𝚛𝚒𝚗𝚝𝚒𝚗𝚐 𝚘𝚗𝚕𝚢 𝚢 '𝚌𝚊𝚞𝚜𝚎 𝚡 𝚠𝚊𝚜 𝚊𝚕𝚛𝚎𝚊𝚍𝚢 𝚖𝚞𝚝𝚊𝚋𝚕𝚢 𝚋𝚘𝚛𝚛𝚘𝚠𝚎𝚍, // 𝚊𝚗𝚍 𝚒𝚝 𝚝𝚊𝚔𝚎𝚜 𝚊𝚗 𝚒𝚖𝚖𝚞𝚝𝚊𝚋𝚕𝚎 𝚋𝚘𝚛𝚛𝚘𝚠 𝚘𝚏 𝚡 𝚝𝚘 𝚙𝚛𝚒𝚗𝚝 𝚒𝚝 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("𝚢: {}", 𝚢); *𝚢 = 𝟸0; // 𝚊𝚜 𝚢 𝚒𝚜 𝚗𝚘 𝚕𝚘𝚗𝚐𝚎𝚛 𝚞𝚜𝚎𝚍, 𝚠𝚎 𝚌𝚊𝚗 𝚙𝚛𝚒𝚗𝚝 𝚡 𝚙𝚛𝚒𝚗𝚝𝚕𝚗!("𝚡: {}", 𝚡); // 𝚘𝚞𝚝𝚙𝚞𝚝: // 𝚢: 𝟷0 // 𝚡: 𝟸0 } (play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=94aec871dd2770874e9210212c90e64b). For more details on this stuff, I'd recommend checking out this video if you haven't already: th-cam.com/video/iMJtA5i335Q/w-d-xo.html

It took me a while, but I fixed it on later videos - Thanks! (: