We are officially finished with The Book. Now onto something that matters.

Today is an exploratory session to explore the lemmy codebase, see how well it's documented, and make targets for contribution.

If anyone's following along this week is dedicated to familiarizing ourselves with the codebase. Pull it down, set up our dev environment, run the code. After that pick a directory and attempt to explain a few functions to a duck. If a duck is not present find a google search result for the term "duck" will suffice.

As always, a stream will be available at the following link of myself doing this for around 2 hours starting one hour after this post is made. https://www.twitch.tv/deerfromsmoke

Welcome to week 31 of Reading Club for Rust’s “The Book” (“The Rust Programming Language”).

“The Reading”

Chapter 21:
https://rust-book.cs.brown.edu/ch18-03-pattern-syntax.html (the special Brown University version with quizzes etc)

The Twitch Stream

Starting today within the hour @[email protected] twitch stream on this chapter: https://www.twitch.tv/deerfromsmoke

https://www.youtube.com/watch?v=ou2c5J6FmsM&list=PL5HV8OVwY_F9gKodL2S31czb7UCwOAYJL (YouTube Playlist)

Be sure to catch future streams (will/should be weekly: https://www.twitch.tv/deerfromsmoke)

• Today (monday september 23), at 18:00 UTC+2
• We'll be starting chapter 8, Common Collections: https://rust-book.cs.brown.edu/ch08-00-common-collections.html
• twitch.com/Jayjader for the stream
• vod link: https://youtu.be/41SQ0BsbcIA

Intro

Having read through the macros section of "The Book" (Chapter 19.6), I thought I would try to hack together a simple idea using macros as a way to get a proper feel for them.

The chapter was a little light, and declarative macros (using macro_rules!), which is what I'll be using below, seemed like a potentially very nice feature of the language ... the sort of thing that really makes the language malleable. Indeed, in poking around I've realised, perhaps naively, that macros are a pretty common tool for rust devs (or at least more common than I knew).

I'll rant for a bit first, which those new to rust macros may find interesting or informative (it's kinda a little tutorial) ... to see the implementation, go to "Implementation (without using a macro)" heading and what follows below.

Using a macro

Well, "declarative macros" (with macro_rules!) were pretty useful I found and easy to get going with (such that it makes perfect sense that they're used more frequent

The post mentions data or research on how rust usage in is resulting in fewer errors in comparison to C. Anyone aware of good sources for that?

A supplement to typical tutorials that caters to C programmers interested in learning how to be unsafe upfront.

Seems good from a quick skim. Also seems that the final lesson is that starting on the safe/happy path in rust doesn’t have to cost performance if you know what you’re doing.

Just a quick riff/hack on whether it'd be hard to make a collect() method that "collected" into a Vec without needing any turbofish (see, if you're interested, my prior post on the turbofish.

Some grasp of traits and iteration is required to comfortably get this ... though it might be a fun dive even if you're not

Background on collect

The implementation of collect is:

 rust

    
fn collect<B: FromIterator<Self::Item>>(self) -> B
where
    Self: Sized,
{
    FromIterator::from_iter(self)
}

  

The generic type B is bound by FromIterator which basically enables a type to be constructed from an Iterator. In other words, collect() returns any type that can be built from an interator. EG, Vec.

The reason the turbofish comes about is that, as I said above, it returns "any type" that can be built from an iterator. So when we run something like:

 rust

    
let z = [1i32, 2, 3].into_iter().collect();
 

  

... we have a probl

I hadn't thought about this until now. Handy.

Of course there's the f64 equivalent: std::f64::consts

This pertains to Ch 16.03 of The Book, specifically Arc in multithreaded programs

I was just looking at the signature for thread::spawn (documentation linked to by post URL) wondering if and how the requirement for a thread-safe smart pointer is enforced by the type system. In short, how is the use of Arc necessitated by the type system??

For the signature, you get this:

 rust

    
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T + Send + 'static,
    T: Send + 'static,

  

Where the parameter f is bound by F: FnOnce() -> T + Send + 'static.

And ... I'm not entirely sure how I should think about this.

Obviously, Send and 'static here are related to my question, where in some way the closure must be thread-safe (through the Send trait) and also have a whole-life-of-the-program lifetime (through the 'static lifetime). Therefore, in some way, something like Rc would be invalid but Arc would be.

But how exactly?

1. Are the bounds

The about section of the linked page has links and a brief explanation of the story.

In my own words ...

Description of the Turbo-fish syntax

• Whenever a generic type (see ch 10 of The Book) is involved in calling a function/method or constructing/handling a struct/enum, you may need to specify that concrete type for that generic.
  • See this handy blog post on the turbofish that lists when it's necessary
• This type is provided with the turbo fish syntax: ::<> ... where the type goes between the angle brackets.
• EG:

 rust

    
let v = Vec::new();

let v2 = Vec::<i32>::new()


  

• The elements of v have an undefined type, which rust will infer once an element is pushed into it. But v2 has a defined element type, i32, defined using the turbo fish.

The Story

• This syntax wasn't always liked, and the double colons (::) thought redundant.
• But it stuck
• And was g

Nice and handy reference with explanations and examples.

You've gotta be familiar with Traits to try to work this out.

::: spoiler Just in case you want to try to work it out your self first Gotta say, after hearing that rust is not an OOP/Class-inheritance language, and is strongly and explicitly typed, the Deref trait feels like a helluva drug!

Obviously it's not the same thing, but working this out definitely had me making a couple of double takes.

Somewhat awkwardly, I worked it out through the standard lib docs before reading ch 15 of the book (it's more fun this way!).

And for those who want a quick answer:

• Read the Deref docs, especially the deref coercion part
• This allows a variable of a particular type to be implicitly substituted with another variable of a different type.
• It happens any time a reference is passed in/out of a function, including self in method calls.
  • And obviously requires that Deref be implemented.
• So `s

What?

I will be holding the fifteenth 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 began chapter 7 (Managing Growing Projects with Packages, Crates, and Modules), and read up through section 7.3 (Paths for Referring to an item in the Module Tree). This time we will start at section 7.4 (Bringing Paths Into Scope with the use Keyword).

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

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 Monda

Continuing on from Chs 5 & 6 of "The Book" (see "Reading Club" post here), I don't think the Copy and Clone traits were quite given sufficient coverage.

So I thought I'd post my understanding here.

Tl;Dr

| Copy | Clone | |------ |------- | | Implicit | Explicit (v.clone())| | Simple (memcpy) | Arbitrary | | "cheap"/quick | Potentially expensive | | Simple types | Any type |

Derivable Traits

• These are traits which have a standard implementation that can be freely and easily applied to structs and enums (IE, custom types).
• The ones available in the standard library are listed in Appendix C of The Book. Other libraries/crates can apparently implement them too (though I don't know of any).
• They are part of and use the Attributes syntax (see [Documentation in the Rust Reference here](https://doc.rust-lang

Relevant for @[email protected] 's next stream next week as they're hitting smart pointers.

cross-posted from: https://programming.dev/post/16059115

Found this on Mastodon https://fosstodon.org/@dpom/112681955888465502 , and it is a very nice overview of the containers and their layout.

What?

I will be holding the fourteenth 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 completed chapter 6 (enums & pattern matching). This time we will begin chapter 7 (Managing Growing Projects with Packages, Crates, and Modules).

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

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 this day (2023-06-24). If you were present for a previous session, then basically the same time-of-day and day-o

After Chs 5 and 6 (see the reading club post here), we get a capstone quiz that covers ownership along with struts and enums.

So, lets do the quiz together! If you've done it already, revisiting might still be very instructive! I certainly thought these questions were useful "revision".

I'll post a comment for each question with the answer, along with my own personal notes (and quotes from The Book if helpful), behind spoiler tags.

Feel free to try to answer in a comment before checking (if you dare). But the main point is to understand the point the question is making, so share any confusions/difficulties too, and of course any corrections of my comments/notes!.

Finally, we can make our own types (or data structures)!!

This is supplementary/separate from the Twitch Streams (see sidebar for links), intended for discussion here on lemmy.

The idea being, now that both twitch streams have read Chapters 5 and 6, we can have a discussion here and those from the twitch streams can have a retrospective or re-cap on the topic.

This will be a regular occurrence for each discrete set of topics coming out of The Book as the twitch streams cover them

With Ch 4 on the borrow checker out of the way, chapters 5 & 6 feel like the "inflection point" ... the point where we're ready to actually start programming in rust.

Custom types, data structures, objects with methods, pattern matching, and even dipping into rust's traits system and it's quasi answer to class inheritance.

If you're comfortable enough with the borrow checker, you can really start to program with rust now!

I personally didn't think this content was difficult, thoug

cross-posted from: https://lemmy.ml/post/17090253

cross-posted from: https://lemmy.ml/post/17090149

Hi! I've created a CLI tool for downloading Rust web books (like The Rust Programming Language) as EPUB, so that you can easily read them on your e-book reader. The tool is heavily based on this gist and a lot of proompting.

Check it out here: https://github.com/mawkler/rust-book-to-epub