What?

I will be holding the tenth of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements).

Last time we covered defining and instantiating structs with section 1 of chapter 5, "Using Structs to Structure Related Data". We'll be continuing with section 2, where we'll be writing some code!

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/6703544

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+2 (aka 6pm Central European Time) on Monday (2023-05-20). If you were present for a previous session, then basically the same time-of-day and day-of-week as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now).

EDIT: here's the recording https://youtu.be/s0U7KBXxL8g

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the book, both reading aloud the literal text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

Who ?

You! (if you're interested). And, of course, me.

We've got two parallel streams going here. One is up to chapter 10 on Traits and the other on chapter 5 on Structs & Enums.

• How are we feeling about Rust the language?
• Any persistent confusions or difficulties?
• Favourite features or success stories?
• How are we finding "The Book" in general?
  • Personally, I think it's good but not great and am definitely reaching out for other learning experiences or materials, lately finding myself going through the Std Lib Docs a bit
  • Andy Balaam's Rust Tutorial Series over on peertube are also good and I recently remembered to watch them as I go

Otherwise ... any thoughts or requests on what else can happen here for those going through "The Book"?

• I'm thinking of having posts on sets of chapters once the two twitch streams have gotten up to them.
• So right now, both have gotten through the borrow checker chapter (ch 4).
• The idea would be to have a reading club happen here too ... to allow written discussion/questions here for those not able to make the streams (or who like/prefer written discussion), but also to provide a retrospective for those who've gone through the streams.
• Personally, in these discussions I'd post my understanding of the topic, look back on the quizzes to see what tripped me up, or any other practical issues I ran into, and post anything else I may have found that helped me on the topic. Basically to see what I actually learned from that chapter.
• Thoughts??
• Another thing I can think of is challenges and exercises. I tried one a while back, but I think it was too much/long, so smaller exercises would probably work better for getting us thinking/coding in rust. AoC has come up and there are plenty of others. Would regular posts from such a thing be welcome or helpful??

Ownership is finally over! Ok, I know we're going to be seeing more of it throughout the rest of the book, but at least it should always be in the context of "doing" something else/useful. For example, grouping bits of related data into structs.

What?

I will be holding the ninth of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements).

This week we begin chapter 5 "Using Structs to Structure Related Data"!

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/6557213

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+2 (aka 6pm Central European Time) on Monday (2023-05-13). If you were present for a previous session, then basically the same time-of-day and day-of-week as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now).

Edit: here's the link to the recording https://youtu.be/h4l5Ksd5w7E

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

Who ?

You! (if you're interested). And, of course, me.

What?

I will be holding the eighth of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements).

This week we finish chapter 4: "Understanding Ownership" by reading through the "Ownership Recap (4.5).

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/6353244

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+2 (aka 6pm Central European Time) on Monday (2023-05-06). That's around 4 hours after this post is created. If you were present for a previous session, then basically the same time-of-day and day-of-week as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now).

EDIT: here's the recording: https://youtu.be/3w7m5GM7eV8

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

Who ?

You! (if you're interested). And, of course, me.

This might be a more interesting dive into Rust for those with a fair amount of existing c and/or c++.

I tried it out myself a few years ago. I had fun reliving the nightmare of implementing doubly-linked lists in C back in school! I never made it to the end of the book, though; it got wayyyy more complex around halfway than I could process at the time.

Hi all! So much happening in my personal life these past 2 weeks that I couldn't put aside the time or energy to host these sessions. Things are calming down a bit (plus I've missed doing the sessions), and so I'm happy to announce the date for the next session.

What?

I will be holding the seventh of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements).

This week we will be continuing chapter 4: "Understanding Ownership". Last session we finished "Fixing Ownership Errors" (4.3). We will thus start from the beginning of "The Slice Type" (4.4).

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/5991675

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+2 (aka 6pm Central European Time) on Monday (2023-04-29). If you were present for a previous session, then basically the same time-of-day and day-of-week as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now). Edit: here's the recording: https://youtu.be/OeyWDSJ-Y5E

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

Who ?

You! (if you're interested). And, of course, me.

Just place to keep links to comments from this community that go "above and beyond" in helping someone out and really explaining or teaching.

There'll be a link in the side bar.

Feel free to add any links you like with a comment

Intro

I'm not on top of traits or generics but found myself looking some of them up anyhow, and came across the Sum trait.

Here is the Std Lib documentation on Sum (I believe).

And I guess all of the generics and/or type logic and how they interoperate has thrown me for a bit of a spin ... so I thought I'd put my thoughts here. Maybe I'll work things out in writing it or maybe someone here can help me/us out?

A bit long ... sorry

Trait Definition

From the docs and source, here is the trait's signature:

// core::iter::Sum
pub trait Sum<A = Self>: Sized {
    // Required method
    fn sum<I: Iterator<Item = A>>(iter: I) -> Self;
}

First thoughts: Defined on elements not iterators?

• The part that confused me at first was what Self is actually. Naively, I imagined it was referring to the iterator (or type that'd implemented Iterator) ... but that clearly can't be true because the return type is Self.
• So ... Sum is implemented not on any collection but on the element type?!
• If so, why not rely on the Add Trait at the element level, which is responsible for the addition operator (see docs here)?

Kinda seems so?

• So, in trying to understand this, I thought I'd look at the source of Iterator::sum() first figuring that it'd be the main implementation.
  • See docs on sum() here and source code here
• This is the sum you'd be calling in something like vec![1, 2, 3].into_iter().sum() to get 6.

core::iter::Iterator::sum
fn sum<S>(self) -> S
where
    Self: Sized,
    S: Sum<Self::Item>,
{
    Sum::sum(self)
}

• Ok, so the call of Sum::sum(self) clearly indicates that this is not where Sum is defined (instead it must be in Sum::sum() somehow).
• Moreover, self is being passed into Sum::sum(), withself being the Iterator here ... which means there's no method being called on Iterator itself but something from another module.
• Additionally, this method is bound by the generic <S> which is defined in the where clause as Sum<Self::Item> ... which ... wait WTF is going on?
  • So this method (Iterator::sum()) must return a type that has implemented the trait Sum??
  • If that's correct, then that confirms my suspicion that Sum is implemented on the elements of an iterator (where I'm sure those comfortable with the generics syntax of the definition above are yelling YES!! OF course!!)
  • That's because the return type of sum() would generally have to be the same type as the summed elements, so S is both the type of the elements in the iterator and the return type of sum. All good.
  • And indeed, in the definition of the type alias S we've got Sum<Self::Item> which binds the return type of Iterator::sum() to the type of the iterator's elements (ie Self::Item)
    • Self::Item is technically the Item type of the Iterator which can, AFAIU, be defined as distinct from the type of the elements of the collection from which the iterator is derived but that's another story.

Back to the beginning

• So back to trying to understand the definition of core::iter::Sum (which I believe is the definition of the trait):

// core::iter::Sum
pub trait Sum<A = Self>: Sized {
    // Required method
    fn sum<I: Iterator<Item = A>>(iter: I) -> Self;
}

• The trait itself is bound to Sized. I don't know the details around Sized (see docs here and The book, ch 19.4 here) but it seems fundamental likely that it applies to vectors and the like.
• The generic A = Self and its occurrences in the generics for the sum() function and its return type ... are a lot:
  • AFAIU, Self, ie the type on Sum is implemented for, must be the Item type for the Iterator that will be passed into the sum method.
  • But it must also be the return type of sum() ... which makes sense.
• So the confusing part here then is the generic type of the sum() method: <I: Iterator<Item = A>>.
  • Remember, A = Self, so it's really <I: Iterator<Item = Self>> (right?)
  • This generic type is any Iterator whose Item (ie, the type that is returned each iteration) is the same type as Self.
• Which means that if I want to sum a vector if i32 numbers, I'd have to make sure I've implemented Sum not on Vec but on i32 and defined it as a method that takes any iterator of i32 (ie Self) elements to then return an i32 element.
• Ok ....

Confirmation

• We can look at the implementors of core::iter::Sum ( see docs here) and check the source for the i32 implementation ...
• Which gives us this source code:

integer_sum_product! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }

• Which is using this macro defined in the same file:

macro_rules! integer_sum_product {
    (@impls $zero:expr, $one:expr, #[$attr:meta], $($a:ty)*) => ($(
        #[$attr]
        impl Sum for $a {
            fn sum<I: Iterator<Item=Self>>(iter: I) -> Self {
                iter.fold(
                    $zero,
                    #[rustc_inherit_overflow_checks]
                    |a, b| a + b,
                )
            }
        }

• which ... uses fold() (basically reduce but with an initial value) and plain addition in the anonymous/closure function |a, b| a + b. What!?

Why? How?

• Ok that was a long way to go to find the addition operator at the bottom of the heap of traits!

• Hopefully I've grasped the mechanics?!

• I'm not quite clear on why it's build this way. I'm guessing there's some flexibility baked into the way that the relevant implementation of Sum depends on the element type, which can be flexibly defined as the Item type of an Iterator independently of the type of the collection's elements. That is, an iterator can utilise a type different from the actual elements of a collection and then rely on its particular implementation of sum. And then this can be independent from Add.

• But that feels like a lot of obscure flexibility for a pretty basic operation, no?

• For example, this code doesn't compile because a type needs to be specified, presumably type inference gets lost amongst all the generics?

// doesn't compile
let x = vec![1i32, 2, 3].into_iter().sum();

// These do compile
let x2 = vec![1i32, 2, 3].into_iter().sum::<i32>();  // turbofish!!
let x3: i32 = vec![1i32, 2, 3].into_iter().sum();

• Design choices aside ...
• I'm still unclear as to how Iterator::sum() works

fn sum<S>(self) -> S
where
    Self: Sized,
    S: Sum<Self::Item>,
{
    Sum::sum(self)
}

• How does Sum::sum(self) work!?
• self is the Iterator (so vec![1i32, 2, 3].iter()).
• And Sum::sum() is the essential trait addressed above.
• How does rust go from a call of a trait's method to using the actual implementation on the specific type? I guess I hadn't really thought about it, but it makes sense and it's what all those Selfs are for.
• In this case though, it's rather confusing that the relevant implementation isn't on the type of self, but because of the definition of Sum, the implementation is on the type of the elements (or Item specifically) of self. Sighs

Thoughts??

A minor but interesting and illuminating point came up in a conversation that I thought was worth sharing, for those learning rust, in a separate post. I'm mostly just copy-and-pasting here.

• See comment here by @[email protected]

TL;DR: The patterns you use in match statements and related syntax are (basically) available to you in let statements. This is how destructuring works!! And what they're for with let. But the patterns have to be "irrefutable"

IE, they have to always be able to match the expression/value.

For those who aren't aware, here's the first section in The Book on patterns in let statements.

I think, if this is confusing, there are two points of clarification:

1. All let statements involve patterns (as Ephera states). They're all let PATTERN = EXPRESSION.
   • For ordinary variable binding, we're just providing a basic pattern that is essentially like a wildcard in that it will match the totality of any expression and so be bound to the full/final value of that expression.
   • It's only when the pattern becomes more complex that the pattern matching part becomes evident, as elements of the value/expression are destructured into those of the pattern.
   • EG, let (x, y, _) = (1, 2, 3); or Ephera's example below let Something(different_thing) = something; which extracts the single field of the struct something into the variable different_thing (handy!).
2. let statements must use irrefutable patterns. That is, patterns that cannot fail to match the expression.
   • For example, against a tuple, (x, y, _) will always match. Another way of putting it: irrefutable patterns are about destructuring not testing or conditional logic.
   • if let statements on the other hand can take both irrefutable patterns and refutable, but are really intended to be used with refutable patterns as they're intended for conditional logic where the pattern must be able to fail to match the expression/value.
   • See The Book chapter on refutability

The nice and useful example provided by @[email protected] (in the original comment):

struct Something(DifferentThing);

let something = Something(DifferentThing::new());

let Something(different_thing) = something;

• Here, the variable something is a struct of type Something which contains one field of type DifferentThing.
• In the final line, we're extracting that DifferentThing field with a pattern in a let statement.
• IE, Something(different_thing) is the pattern. And it is irrefutable against all variables of type Something, as they have only one field.

I can't help but suspect it doesn't offer much and you may as well just use match statements for whenever you want pattern matching, however many times it might be slightly more verbose than what you could do with if let.

I feel like I'd easily miss that pattern matching was happening with if let but will always know with match what's happening and have an impression of what's happening just from the structure of the code.

Hi all!

What?

I will be holding the sixth of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements).

This week, we will be continuing chapter 4: "Understanding Ownership". Last week we finished "References and Borrowing" (4.2). We will thus start from the beginning of "Fixing Ownership Errors" (4.3).

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/5871866

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+1 (aka 6pm Central European Time) on Monday (2023-04-15). If you were present for a previous session, then basically the same time as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now). Edit: here's the recording: https://youtu.be/7XcluwdxBHQ

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

Who ?

You! (if you're interested). And, of course, me.

Hi all! I had to cancel last week's session at the last minute, so this week we'll just be covering what we would have covered, then.

(recap of the session info for completeness' sake:)

What?

I will be holding the fifth of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements). This week, we will be continuing chapter 4: "Understanding Ownership".

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/5452538

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+1 (aka 6pm Central European Time) on Monday (2023-04-08). If you were present for a previous session, then basically the same time as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now). Edit: the recording is now uploaded on youtube: https://youtu.be/zueZGhlkiyE

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

Who ?

You! (if you're interested). And, of course, me.

Hey!

I'm a professional software engineer with several years of experience using Rust. Unfortunately I don't really have the time to contribute to Lemmy directly myself, but I love teaching other people Rust so if:

• You are curious about Rust and why you should even learn it
• You are trying to learn Rust but maybe having a hard time
• You are wondering where to start
• You ran into some specific issue

... or anything to do with Rust really, then feel free to ask in the comments or shoot me a PM 🙂

Edit: I'm currently feeling too unwell to host the reading club this evening.

Hi all!

What?

I will be holding the fifth of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements). This week, we will be continuing chapter 4: "Understanding Ownership".

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/5452538

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+1 (aka 6pm Central European Time) on Monday (2023-04-01). If you were present for a previous session, then basically the same time as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now).

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

Who ?

You! (if you're interested). And, of course, me.

cross-posted from: https://lemmy.world/post/13508677

Hello All:

I am working on rust problems here. In the second question I solved it by simply adding the return statement for the function to modify. I am not sure what the lesson in ownership to walk away with in this problem. Any guidance?

Hi all!

What?

I will be holding the fourth of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements). This week, we will be starting chapter 4: "Understanding Ownership".

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/5278834

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+1 (aka 6pm Central European Time) on Monday (2023-03-25). If you were present for a previous session, then basically the same time as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now). Edit: the recording can be found at the following link: https://youtu.be/YmMreNK3fcw.

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

The interactive quizzes have started getting more interesting! Unfortunately, we're still on a decent delay from when I'm speaking to when I see people's comments appear in chat, so we will most likely continue to work through them in a more disjointed manner than the rest of the material.

Who ?

You! (if you're interested). And, of course, me.

General page for challenges for learning rust

Writing a Diff

• First posed here
• Check in for solutions/statuses here

Intro

Not long ago I posed a challenge for those of us learning rust: https://lemmy.ml/post/12478167.

Basically write an equivalent of git diff --no-index A B ... a file differ.

While it's never too late to attempt it, I figured it'd be a good time to check in to see what anyone thought of it, in part because some people may have forgotten about it and would still like to have a shot, and also because I had a shot and am happy with what I wrote.

Check In

I'll post where I got up to below (probably as a comment), but before that, does anyone have anything to share on where they got up to ... any general thoughts on the challenge and the general idea of these?

My experience

My personal experience was that I'd not kept up with my rust "studies" for a bit and used this as a good "warm up" or "restart" exercise and it worked really well. Obviously learning through doing is a good idea, and the Rust Book is a bit too light, IMO, on good exercises or similar activities. But I found this challenge just difficult enough to make me feel more comfortable with the language.

Future Challenges

Any ideas for future challenges??

My quick thoughts

• A simple web app like a todo app using axtix_web and diesel and some templating crate.
• Extend my diffing program to output JSON/HTML and then to diff by characters in a string
• A markdown parser??

Quick little confusion or even foot-gun I ran into (while working on the challenge I posed earlier).

TLDR

My understanding of what I ran into here:

• Matching on multiple variables simultaneously requires assigning them to a tuple (?),
• which happens more or less implicitly (?),
• and which takes ownership of said variables.
• This ownership doesn't occur when matching against a single variable (?)
• Depending on the variables and what's happening in the match arms this difference can be the difference between compiling and not.

Anyone got insights they're willing to share??

Intro

I had some logic that entailed matching on two variables. Instead of having two match statements, one nested in the other, I figured it'd be more elegant to match on both simultaneously.

An inline tuple seemed the obvious way to do so and it works, but it seems that the tuple creates some ownership problems I didn't anticipate, mostly because I was thinking of it as essentially syntax and not an actual tuple variable.

As you'll see below, the same logic with nested match statements each on a single variable doesn't suffer from the same issues.

Demo Code

fn main() {

    // # Data structures
    enum Kind {
        A,
        B
    }
    struct Data {
        kind: Kind
    }

    // # Implementation
    let data = vec![Data{kind: Kind::A}];

    // ## Basic idea: process two adjacent data points
    let prev_data = data.last().unwrap();
    let new_data = Data{kind: Kind::B};

    //
***
MATCH STATEMENTS
***

    // ## This works: match on one then the other
    let next_data = match prev_data.kind {
        Kind::A => match new_data.kind {
            Kind::A => 1,
            Kind::B => 2,
        },
        Kind::B => match new_data.kind {
            Kind::A => 3,
            Kind::B => 4,
        },
    };

    // ## This does NOT work: match on both
    let next_data2 = match (prev_data.kind, new_data.kind) {
        (Kind::A, Kind::A) => 1,
        (Kind::A, Kind::B) => 2,
        (Kind::B, Kind::A) => 3,
        (Kind::B, Kind::B) => 4,
    };
}

The Error

The error is on the line let next_data = match (prev_data.kind, new_data.kind), specifically the tuple and its first element prev_data.kind, with the error:

error[E0507]: cannot move out of `prev_data.kind` which is behind a shared reference

move occurs because `prev_data.kind` has type `Kind`, which does not implement the `Copy` trait

The Confusion

So prev_data.kind needs to be moved. That's ok. Borrowing it with (&prev_data.kind, ...) fixes the problem just fine, though that can cause issues if I then want to move the variable within the match statement, which was generally the idea of the logic I was trying to write.

What got me was that the same logic but with nested match statements works just fine.

I'm still not clear on this, but it seems that the inline tuple in the second tuple-based approach is a variable that takes ownership of the variables assigned to it. Which makes perfect sense ... my simple mind just thought of it as syntax for interleaving multiple match statements I suppose. In the case of nested match statements however, I'm guessing that each match statement is its own scope.

The main thing I haven't been able to clarify is what are the ownership dynamics/behaviours of match statements?? It seems that there's maybe a bit happening implicitly here?? I haven't looked super hard but it does seem like something that's readily glossed over in the materials I've seen thus far??

General Implications

AFAICT:

• if you want to match on two or more variables simultaneously, you'll probably need borrow them in the match statement if they're anything but directly owned variables.
• If you want to then use or move them in the match arms you may have to wrangle with ownership or just use nested match statements instead (or refactor your logic/implementation).
• So probably don't do multi-variable matching unless the tuple of variables is a variable native to the logic?

Hi all!

What?

I will be holding the third of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements). This week, we will be continuing (and hopefully concluding) chapter 3: "Common Programming Concepts". Last session covered sections 3.1 and 3.2; this session will start at section 3.3 (Functions).

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/5036425

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the previous session)

When ?

Currently, I intend to start at 18:00 UTC+1 (aka 6pm Central European Time) on Monday (2023-03-18). If you were present for a previous session, then basically the same time as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now).

Edit: the session recording is available at the following link: https://youtu.be/v5b6UIDZQ5A

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

The interactive quizzes have started getting more interesting! Unfortunately, we're still on a decent delay from when I'm speaking to when I see people's comments appear in chat, so we will most likely continue to work through them in a more disjointed manner than the rest of the material.

Who ?

You! (if you're interested). And, of course, me.

Hi all!

What?

I will be holding the second of the secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We are using the Brown University online edition (that has some added quizzes & interactive elements). This week, we will be starting chapter 3: "Common Programming Concepts".

Previous session details and recording can be found in the following lemmy post: https://jlai.lu/post/4802347

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

(also, obviously, to follow up on the first/previous session)

When ?

Currently, I intend to start at 18:00 UTC+1 (aka 6pm Central European Time) on Monday (2023-03-11). If you were present for the first session, then basically the same time as that one was.

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

The basic format is: I will be sharing my computer screen and voice through an internet live stream (hosted at https://www.twitch.tv/jayjader for now). The stream will simultaneously be recorded locally and uploaded afterwards to youtube (also, for now). EDIT: link to recording: https://youtu.be/TnGMnlsT23o

I will have on-screen:

• the BU online version of The Book
• a terminal session with the necessary tooling installed (notably rustup and through it cargo & "friends")
• some form of visual aid (currently a digital whiteboard using www.excalidraw.com)
• the live stream's chat (probably)

I will steadily progress through the chapter, both reading aloud the literal chapter text and commenting occasionally on it. I will also perform any code writing and/or terminal commands as the text instructs us to.

People who either tune in to the live stream or watch/listen to the recording are encouraged to follow along with their own copy of the book.

I try to address any comments from live viewers in the twitch chat as soon as I am aware of them. If someone is having trouble understanding something, I will stop and try to help them get past it.

The interactive quizzes have so far been too trivial to warrant working on the answers collectively. This week might prove different; we can see how we prefer to work through them as we encounter them.

Who ?

You! (if you're interested). And, of course, me.

It seems they’re not far from finishing and have the first few chapters up for early access and feedback. It could be the go to text for learning the protocol.

Hi all!

What?

I will be starting a secondary slot/sessions for the Reading Club, also on "The Book" ("The Rust Programming Language"). We will, also, very likely use the Brown University online edition (that has some added quizzes & interactive elements).

Why?

This slot is primarily to offer an alternative to the main reading club's streams that caters to a different set of time zone preferences and/or availability.

When ?

Currently, I intend to start at 18:00 UTC+1 (aka 6pm Central European Time). Effectively, this is 6 hours "earlier in the day" than when the main sessions start, as of writing this post.

The first stream will happen on the coming Monday (2023-03-04).

Please comment if you are interested in joining because you can't make the main sessions but would prefer a different start time (and include a time that works best for you in your comment!). Caveat: I live in central/western Europe; I can't myself cater to absolutely any preference.

How ?

We will start from the beginning of "The Book".

There are 2 options:

1. mirror the main sessions' pace (once every week), remaining ~4 sessions "behind" them in terms of progression through "The Book"
2. attempt to catch up to the main sessions' progression

I am personally interested in trying out 2 sessions each week, until we are caught up. This should effectively result in 2-3 weeks of biweekly sessions before we slow back down. I'm not doing this just for me, however, so if most people joining these sessions prefer the first option I'm happy to oblige.

I will be hosting the session from my own twitch channel, https://www.twitch.tv/jayjader . I'll be recording the session as well; this post should be edited to contain the url for the recording, once I have uploaded it.

Who ?

You! (if you're interested). And, of course, me.