## **Polkadot News**

Meet the Polkadot Decentralized Futures teams, come to today’s space <https://x.com/Web3foundation/status/1818995146362438016>

The new Polkadot Ledger Generic app is still not supported by all parachains. See the list here: <https://dashboards.data.paritytech.io/metadata.html> For more info about the Ledger app, read the Polkadot Wiki <https://wiki.polkadot.network/docs/ledger>

The Polkadot Staking dashboard has been updated to support identities that have now migrated to People System Chain <https://x.com/rossbulat/status/1818971646968914218> For more information about identities, see the Polkadot Wiki <https://wiki.polkadot.network/docs/learn-identity>

The Polkadot Championship Hackathon is open to registration. Finals will be held at the Bali Blockchain Center right before Coinfest Asia <https://x.com/PolkadotChamps/status/1818948467642806545>

Participate in the discussion about reducing DOT inflation on the Polkadot Forum <https://forum.polkadot.network/t/proposal-for-adjusting-polkadots-inflation-system-reducing-issuance-and-complexity/9157>

The staking rate on Polkadot has decreased from 58.85 to 58.46% in the past week <https://staking.polkadot.cloud/#/overview>

Parathread 3393 (Self-funded) is currently bidding for the upcoming 77th slot auction <https://parachains.info/auctions>

There are 64 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 13 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

bafybeiajs2fm2zgpclhaqfez4ii77n5cljsdvgmyke352vo4rfipmjrbte

Polkadot Digest 2 August 2024

## **Polkadot News**

Do not miss the “Polkadot Beyond the Chain” Event in London tonight at 6 pm BST <https://lu.ma/k9bi54yl>

The Polkadot Championship Hackathon is open to registration. Finals will be held at the Bali Blockchain Center right before Coinfest Asia <https://x.com/PolkadotChamps/status/1818948467642806545>

Participate in the discussion about reducing DOT inflation on the Polkadot Forum <https://forum.polkadot.network/t/proposal-for-adjusting-polkadots-inflation-system-reducing-issuance-and-complexity/9157>

The staking rate on Polkadot slightly increased to 58.76% since last Friday <https://staking.polkadot.cloud/#/overview>

With three days left in the current parachain lease auction, Manta Network (self-funded) has been in the lead the entire Ending Period. <https://parachains.info/auctions>

There are 56 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 11 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

bafybeibm64o2leunrmgfrhcbt6662zd4xa4ogm4i466h2biyxubnedb22q

Polkadot Digest 5 August 2024

bafybeifks375xekcmd4p6ehqkrlxzv22iexxymudqnk5xgiyhkz7mema6y

## **Polkadot News**

The state of Polkadot Q2 2024 has been published by Messari [messari.co/4dmITSb](http://messari.co/4dmITSb)

Web3 Summit will be in Berlin between the 19th and 21st of August, you can still get your tickets here: <https://ti.to/web3-summit/web3-summit-2024> 

Different teams from the Polkadot ecosystem are participating as speakers to Coinfest Asia: Ingo from Kilt, Jay from Kusamarian, Anta from Mandala, Ursula from Scytale, and more! <https://x.com/CoinfestAsia/status/1820640371468369940>

The Polkadot Championship Hackathon is open to registration. Finals will be held at the Bali Blockchain Center right before Coinfest Asia <https://x.com/PolkadotChamps/status/1818948467642806545>

The staking rate on Polkadot slightly decreased to 58.64% since last Friday <https://staking.polkadot.cloud/#/overview>

With two days left in the current parachain lease auction, Manta Network (self-funded) has been in the lead the entire Ending Period. <https://parachains.info/auctions>

There are 53 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 11 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

bafybeic6ccdbnqpvoqibp5luykehlqywvvad3bcf6ixfdkf3c3htmzyv5m

Polkadot Digest 6 August 2024

## **Polkadot News**

Are you opengoving? Upskill your experience on Polkadot OpenGov with the new Nova Wallet release <https://x.com/NovaWalletApp/status/1820804430750536097>

The Polkadot Championships Hackathon Bali Edition just doubled the prize pool, register now <https://polkadotchampionship.org/>

Web3 Summit will be in Berlin between the 19th and 21st of August, you can still get your tickets here: <https://ti.to/web3-summit/web3-summit-2024>

The staking rate on Polkadot slightly increased to 58.75% since yesterday <https://staking.polkadot.cloud/#/overview>

With one day left in the current parachain lease auction, Manta Network (self-funded) has been in the lead the entire Ending Period. <https://parachains.info/auctions>

There are 53 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 11 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

bafybeiaigm7ngzdytb2znvj7xxddcaptspettmkdbx5qf3io5vinuauzja

Polkadot Digest 7 August 2024

## **Polkadot News**

The Web3 Summit will host a hackathon co-organized by WebZero and Web3 Foundation; sign up here: <https://symmetry.theblockspace.net/signup>

Web3 Summit will be in Berlin between the 19th and 21st of August, you can still get your tickets here: <https://ti.to/web3-summit/web3-summit-2024>

The Polkadot Championships Hackathon Bali Edition just doubled the prize pool; register now: <https://polkadotchampionship.org/>

Polkadot is the title sponsor of Coinfest Asia in Bali, thanks to Mandala Chain. As such, ecosystem agents will be on-site to support and also as speakers. Polkadot will have a booth, and anyone is welcome to join the web3 movement: <https://coinfest.asia/>

You can rewatch the live stream about Polkadot’s trustless bridges Hyperbridge and Snowbridge: <https://x.com/i/broadcasts/1mrGmMXvEeDGy>

The staking rate on Polkadot slightly increased to 58.87% since yesterday <https://staking.polkadot.cloud/#/overview>

Manta Network (self-funded) won the 77th Polkadot parachain slot auction <https://parachains.info/auctions>

There are 53 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 13 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

bafybeiabllmgwka343foq57v257urepo5vholrm2ywsby3vxbfdclbd3si

Polkadot Digest 8 August 2024

## **Polkadot News**

The new Polkadot website made by Distractive is live <https://polkadot.com/> <https://x.com/Polkadot/status/1821568462365347872>

Polkadot nomination pool members will be able to vote in OpenGov; see these support guides: <https://support.polkadot.network/support/solutions/articles/65000188140-changes-for-nomination-pool-members-and-opengov-participation>

Read the introduction to Play on Polkadot by <https://medium.com/web3foundation/decentralized-futures-introducing-play-on-polkadot-pop-9b65ce6f23b7>

The Web3 Summit will host a hackathon co-organized by WebZero and Web3 Foundation; sign up here: <https://symmetry.theblockspace.net/signup>

Web3 Summit will be in Berlin between the 19th and 21st of August; you can still get your tickets here: <https://ti.to/web3-summit/web3-summit-2024>

The Polkadot Championships Hackathon Bali Edition just doubled the prize pool; register now: <https://polkadotchampionship.org/>

Polkadot is the title sponsor of Coinfest Asia in Bali, thanks to Mandala Chain. As such, ecosystem agents will be on-site to support and also as speakers. Polkadot will have a booth, and anyone is welcome to join the web3 movement: <https://coinfest.asia/>

There are 56 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 10 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

bafybeifyiaxnrlrzsigmypel6qjfbp6slzf6imshmytiyfaybq5yzrie2m

Polkadot Digest 9 August 2024

## **Polkadot News**

The new design for the Polkadot Fellowship Dashboard is live <https://polkadot-fellows.github.io/dashboard/>

The Polkadot’s JAM graypaper v0.3.4 is out <https://github.com/gavofyork/graypaper/releases/>

Polkadot nomination pool members will be able to vote in OpenGov; see these support guides: <https://support.polkadot.network/support/solutions/articles/65000188140-changes-for-nomination-pool-members-and-opengov-participation>

The Web3 Summit will host a hackathon co-organized by WebZero and Web3 Foundation; sign up here: <https://symmetry.theblockspace.net/signup>

Web3 Summit will be in Berlin between the 19th and 21st of August; you can still get your tickets here: <https://ti.to/web3-summit/web3-summit-2024>

The Polkadot Championships Hackathon Bali Edition just doubled the prize pool; register now: <https://polkadotchampionship.org/>

Polkadot is the title sponsor of Coinfest Asia in Bali, thanks to Mandala Chain. As such, ecosystem agents will be on-site to support and also as speakers. Polkadot will have a booth, and anyone is welcome to join the web3 movement: <https://coinfest.asia/>

There are 53 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 13 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

bafybeig2ithf3skx3e7yojag7zw24b2gtmhpjd2jdyxfi67cqics7wcvvm

Polkadot Digest 12 August 2024

## **Polkadot News**

Web3 Summit will be in Berlin next week; you can still get your tickets here: <https://ti.to/web3-summit/web3-summit-2024>

Watch today’s livestream with Mandala Chain bringing Polkadot at Coinfest Asia <https://x.com/i/broadcasts/1yoKMyQBRmWKQ>

You can watch classes at the Polkadot Blockchain Academy and learn more about Polkadot and how to build on top of it <https://www.youtube.com/@polkadotblockchainacademy/videos>

The Web3 Summit will host a hackathon co-organized by WebZero and Web3 Foundation; sign up here: <https://symmetry.theblockspace.net/signup>

The Polkadot Championships Hackathon Bali Edition just doubled the prize pool; register now: <https://polkadotchampionship.org/>

With four days left in the current parachain lease auction, Parathread 3378 (self-funded) has been in the lead the entire Ending Period. <https://parachains.info/auctions>

There are 52 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 13 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

bafybeif5scw2dinxsdzx2tbpculxkiarrya7y7auvlbrwpua276k5fys7u

Polkadot Digest 13 August 2024

## **Polkadot News**

Do not miss the Polkadot interview live stream with Conor Daly today at 11 am UTC <https://x.com/Polkadot/status/1823411830997373317>

The unbonding queue for Polkadot and Kusama has been approved by the Polkadot Technical Fellowship. Upon implementation and deployment, new requests will be executed with a minimum of 2 days, when the queue is comparatively empty, to the conventional 28 days, if the sum of requests (in terms of stake) exceeds some threshold. <https://x.com/GehrleinJonas/status/1823267448038015450>

Watch Filippo from the Web3 Foundation explaining Polkadot and JAM at Encode Club tomorrow, 15th August, at 4 pm BST <https://x.com/filippoweb3/status/1808142672617423228>

Join OpenGuild's Discord and stay up-to-date with this summer Polkadot HackCamp! <https://x.com/openguildwtf/status/1823615576838955055>

You can learn more about the Polkadot Technical Fellowship on the Polkadot Wiki <https://wiki.polkadot.network/docs/learn-polkadot-technical-fellowship>

With three days left in the current parachain lease auction, Zeitgeist (self-funded) is in the lead but Parathread 3378 has been in the lead the entire Ending Period. <https://parachains.info/auctions>

There are 51 active referenda on Polkadot OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fpolkadot#/referenda>

## **Kusama News**

There are 13 active referenda on Kusama OpenGov. <https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Frpc.ibp.network%2Fkusama#/referenda>

The Digest will take a break tomorrow for a Swiss public holiday and will resume on Friday with the W3F Teched Team members @baderyo\_o and @DrW3RK until the 19th of August

bafybeib2fn73ukcvs4t5pfi5ief6udfqfavzlgrnenhvkvrk7ljf2ujltq

Polkadot Digest 14 August 2024

* Scan the QR
* If you do not have it, install Nova Wallet
* Create a wallet with cloud backup (no need to remember a seed phrase)
* Scan the QR again
* Log in to Flappywud.lol using Nova → play  
If you score above 20 points you get 20k WUD deposit on hydration.

bafybeifp4q4kxrrb65tsjxu2noqho6edjbub6jjpkp2peivyb2eiwao6jy

Easy and Fun Onboarding into Polkadot with Gavun Wud!

This is the third post about my journey learning the Rust programming language using the [Rust Book](https://doc.rust-lang.org/book/). Previous posts include:

[Chapter 3: Shadowning, mutability, variables and constants, data types, and control flow](https://grillapp.net/@filippoweb3/41957?ref=10124)

I am documenting this as I think it is a useful thing to do for people interested in learning Rust from my non-developer perspective.

At this stage, you have already [installed Rust](https://doc.rust-lang.org/book/ch01-01-installation.html) on your machine, and you are ready to write and run your first Rust programs.

I am using [VS code](https://code.visualstudio.com/) with the [rust-analyzer extension](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). I am working on an M1-mac.

The following tutorial will cover [Chapter 4 of the Rust Book](https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html). It is meant to be a summary and used with the book as a complementary source of information.

Ownership in Rust allows for memory safety without needing a garbage collector. In Rust, memory is managed through a set of rules that the compiler checks.

## Stack and Heap Memory

|Stack | Heap |
|:----:|:-----:|
| It stores values in order and removes them in the opposite order. | Less organized than stack, allocation process through pointers |
| Data must have known size. | The pointer has a fixed size, and stored data does not |
| Fast read/write | Slow read/write because of the allocation process |

The scope is defined as the range within a program when the value is valid.

The scope is defined with `{}`. The code below will return an error because `s` is called outside its scope.

```
fn main() {

{
    let s = "hello"; //string literal
}

println!("{s}")

}
```

String literals are immutable string values that are hardcoded into the program. This is good if we know the string when we write the program, but what if we do not? What if we want to use user inputs? For these situations, Rust has the `String` type that can store text on the heap. Such text is unknown to us at compile time. The code below created a `String` variable `s`, appends to it a literal, and prints `s`:

```
let mut s = String::from("hello"); //String type

s.push_str(", world!");

println!("{s}");
```

The call `String::from` requests the memory from the memory allocator at runtime. When the variable goes out scope, Rust automatically calls the `drop` function (at the end of `{}`).

## Moving Variables

A `String` is made of three parts stored on the stack memory:


A pointer to the heap memory holding the string content
Length, i.e., how much memory in bytes is currently in use
Capacity, i.e., the total amount of memory in bytes received by the allocator

The code below:

```
let s1 = String::from("hello");
let s2 = s1;
```

copies the pointer, length, and capacity are copied, but the data on the heap are not. That is, Rust does kind of a shallow copy (and not a deep copy). Both data pointers for `s1` and `s2` are pointing to the same location. When those variables go out of scope, they will try to free the same memory (double-free error). Freeing memory twice can lead to memory corruption and vulnerabilities. To ensure safety, after declaring `s2`, Rust does not consider `s1` as valid anymore. Because `s1` is invalid after declaring `s2`, we are not talking about shallow copy but moving variables. We say `s1` was moved into `s2`.

To make a deep copy, we can use the `clone` method.

```
let s1 = String::from("hello");
let s2 = s1.clone(); // deep copy
```

In this way, both variables are valid.

## Ownership and Functions

Let’s take the example below.
```
let s = String::from("hello");

takes_ownership(s); // s is moved into fn, no longer valid after (drop function)

let x = 5;

makes_copy(x); // x is moved into fn, by x is Copy trait, and thus still valid afterwards
```

Where

```
fn takes_ownership(some_string: String){
    println!("{some_string}");
}

fn makes_copy(some_integer: i32){
    println!("{some_integer}");
}
```

The `s` variable goes out of scope after the function `takes_ownership` is called. This is because `s`, is of String type, and the drop function is called when it goes out of scope. The drop function is called for those types that own resources and have thus allocated memory (heap). The drop function is not called for primitive types like integers that implement the Copy trait and thus do not move and are trivially copied (stack memory). This is why `x` is valid after calling the function `makes_copy`.

## References and Borrowing

A reference is sort of a pointer in that we can use it to follow data stored at a specific address and is guaranteed to point to a valid value for the life of that reference.

See the example below:

```
let s1 = String::from("hello");

let len = calculate_length(&s1); //borrows s1 to calculate length

println!("The length of '{s1}' is {len}."); //using s1 and len
```

Where 

```
fn calculate_length(s: &String) -> usize { // s is a reference to a String
    s.len()
} // s goes out of scope, but because it is a reference, the String won’t be dropped
```

The `&s1` allows us to refer to `s1` without taking ownership of it. Consequently, `s1` will not be dropped when the reference stops being used. The action of creating a reference is called “borrowing”. References are immutable by default.

## Mutable References

References can be mutable, as shown below.

```
let mut s = String::from("hello");

change(&mut s);
```

Where

```
fn change(some_string: &mut String) {
    some_string.push_str(", world!");
}
```

You cannot borrow `s` as a mutable reference more than once. This restriction avoids “data races” at compile time due to:
Two or more pointers access data at the same time
At least one of the pointers is used to write data
There is no mechanism being used to synchronize access to the data

You cannot have simultaneous mutable references, but you can have multiple mutable references in a controlled fashion, as shown below:

```
{
    let r1 = &mut s;
} // mutable reference goes out of scope

let r2 = &mut s;
```

You cannot have a mutable reference when there is already an immutable reference of the same value. The immutable reference must go out of scope before introducing an immutable reference to the same value. See below:

```
let mut s = String::from("hello");

let r1 = &s;
let r2 = &s;
println!("{r1} and {r2}"); // two immutable reference out of scope

let r3 = &mut s; // new mutable reference to the same value
println!("{r3}");
```

## Dangling References

Dangling references happen when the memory where a pointer points to is freed while keeping the pointer. See below:

```
fn dangle() -> &String {
    let s = String::from("hello");

    &s
}
```

The function `dangle` returns a reference to the String `s`. Because `s` is defined with fn, it goes out of scope when the function is called, and the compiler will return an error.

## Slice Type

### String Slices

A string slice is a reference to a part of a String.

```
let s = String::from("Hello, world!");

let hello = &s[0..6];
let world = &s[7..13];
```

Where the syntax is `[start index..end index]`, and `end index` is one more than last position in the slice. In Rust, you can shorten slices as follows:
`&s[0..6]` can be `&s[..6]` (slice from the start)
`&s[7..13]` can be `&s[7..]` (slice up to the end)
`&s[0..13]` can be `&s[..]` (slice entire string)

Let’s take a look at the function below:

```
fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes(); //conversion to byte array
    for (i, &item) in bytes.iter().enumerate() { // iteration over bytes
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}
```

The function takes a reference to a String as input and returns a string slice. The String is first converted into a byte array, then a for loop iterates through the bytes, and if it encounters a space, it returns a string slice from string start to that space. If there is no space, it just returns the whole string slice.

We can take slices of literals and String values. We can thus improve the previous function as follows:

```
fn first_word(s: &str) -> &str {
```

This allows us to pass both Strings and string literals because string literals are already string slices. If we have a string slice, we can pass it directly, while if we have a String, we can just pass a slice of that String.

So far we learned the basics of ownership, references and borrowing, and slices. See you in the next post!


bafybeih4oa2o4v3qd6jurmqpielgbdftnwkbh2wijzc6qu2cxfs726w4ne

My Rust Journey - 4 oct 2024

This is the 4th post about my journey learning the Rust programming language using the [Rust Book](https://doc.rust-lang.org/book/). Previous posts include:

[Chapter 1: Basics of Rust and Cargo](https://grillapp.net/@filippoweb3/my-rust-journey-17-jan-2024-41322?ref=10124)

[Chapter 3: Mutability and shadowing, variables and constants, scalar and compound data types, functions, control flow with conditional statements and loops](https://grillapp.net/@filippoweb3/my-rust-journey-20-jan-2024-41957?ref=10124)

[Chapter 4: Ownership, reference and borrowing, and slice type](https://grillapp.net/@filippoweb3/my-rust-journey-4-oct-2024-212790?ref=10124)

I am documenting this as I think it is a useful thing to do for people interested in learning Rust from my non-developer perspective.

At this stage, you have already [installed Rust](https://doc.rust-lang.org/book/ch01-01-installation.html) on your machine, and you are ready to write and run your first Rust programs.

I am using [VS code](https://code.visualstudio.com/) with the [rust-analyzer extension](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). I am working on an M1-mac.

The following tutorial will cover [Chapter 5 of the Rust Book](https://doc.rust-lang.org/book/ch05-00-structs.html). It is meant to be a summary and used with the book as a complementary source of information.

## Structs

Similar to tuples, they hold multiple related values of different types.

```
struct User {
        active: bool,
        username: String,
        email: String,
        sign_in_count: u64,
    }
```

We use the keyword `struct` and name it `User` to define a struct. Within the struct we define names and types for each piece of data called _field_. Note how the struct is defined outside the main function.

Once the struct is defined, we can create multiple instances by specifying values for each field.

```
let user1 = User { // User instance
        active: true,
        username: String::from("user1name"),
        email: String::from("user1email"),
        sign_in_count: 1,
    };
```

A function to create new instances of that struct would look like this:

```
fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username,
        email,
        sign_in_count: 1,
    }
}
```

where `username` and `email` are the fields to be updated. We are using the _init shorthand_ so that we do not have to write `username: username` and `email: email`.

To utilize the function we can use the following code:

```
let a = String::from("user2email");
let b = String::from("user2name");

let user2 = build_user(a, b);
```

The _struct update syntax_ is used to create new instances including most of the values from another instance.

```
let user3 = User {
        email: String::from("user3email"), // change only email
        ..user2 // rest filed like user 2
    };
```

Rust also supports _tuple structs_. Tuple structs are useful when:
Give the tuple a name and make the tuple a different type from other tuples
Naming each field

```
struct Color(i32, i32, i32)
```

And then in the main function you can specify a color

```
let black = Color(0,0,0);
```

Each defined struct is a different type even though fields of those structs have the same type. 

### Rectangle Example

Let’s build a case where we want to calculate the area of a rectangle using structs.

We defined the `Rectangle` struct

```
struct Rectangle {
    width: u32,
    height: u32,
}
```

Then, we defined the `area` function:

```
fn area(rectangle: &Rectangle) -> u32 {
    rectangle.width * rectangle.height
}
```

This function is defined with one parameter named `rectangle` that is an immutable borrow of a `Rectangle` struct instance. The function accesses the `width` and `height` fields of the `Rectangle` instance. Accessing fields of a borrowed struct does not move the field values. 

Then, within the main function, we use the following code:

```
let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("The area of the rectangle is {} square pixels.", area(&rect1));
```

## Print in Debug mode

The struct primitive can be printed in debug mode as follows:

```
#[derive(Debug)] // used to print struct values
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {

println!("{:#?}", rect1);

}
```

The `{:?}` prints `rect1` using the' Debug' output format. The {:#?} can be used in larger structs for better readability.

Another way to print values in debug mode is to use the `dbg!` macro, which takes ownership over an expression and prints the file and line where the debug call occurs, along with the resultant value of the expression.

```
let scale = 3;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

dbg!(&rect1);
```

The `dbg!` is applied to the `width` field, takes ownership of `scale`, and gives it back to `width` (essentially is like we never used it). We then use the macro again to print `rect1`, but because we do not want it to take ownership of it, we just use a reference to `rect1`.

## Methods

The area function we defined before is specific: it only computes the area of rectangles. We can ensure that the area function only works with `Rectangle` type, by turning the area function into area method.

Outside the main function, after specifying the `Rectangle` struct we specify the `impl` (implementation) block for `Rectangle`. Everything in that block will be associated with the `Rectangle` type. We move the area function within the block and use the `self` as the parameter.

```
impl Rectangle {
    fn area(&self) -> u32 { // defining the area method
        self.width * self.height
    }
}
```

The `&self` is short for `self: &Self`, where `Self` is an alias for the type the `impl` block is for. Methods must have a parameter named `self` of type `Self` that can be abbreviated with `self`. We use the reference `&self` because we borrow a `Self` instance as we did with `rectangle: &Rectangle`.

Then within the main function, we can print the area value as follows:

```
println!(
        "The area of the rectangle is {} square pixels.", 
        rect1.area() // using the area method
    );
```

We use the _method syntax_ to call the area method on our `Rectangle` instance. A method can have the same name as one of the struct fields. We can add another method in our block implementation:

```
impl Rectangle {
    fn area(&self) -> u32 { // defining the area method
        self.width * self.height
    }

    fn width(&self) -> bool {
        self.width > 0
    }
}
```

The second `width` method will return `true` if the width is greater than zero. Within the main function, we can use both `.width` or `.width()` and Rust will know that one will be the struct field and the other will be the method.

```
println!(
        "The width of the rectangle is {}.", 
        rect1.width // using the width field or .width() method
    );
```

### Automatic Referencing and Dereferencing

When you call a method using `object.method()`, Rust automatically adds in &, &must, * so the object matches the signature of the method. The following are the same:

```
p1.distance(&p2)
&p1.distance(&p2)
```

Automatic referencing works well because methods have a clear `receiver` of the `Self` type. Given the receiver and method, Rust can figure out if the method is reading (&self), mutating (&mut self), or consuming (self).

### Associated Functions

Functions within an `impl` block are called _associated functions_ because are associated with the type named after the implementation. 

Associated functions do not have to include `self` as the first parameter (and do not need to be methods). An example is the `String::from` function defined on the `String` type. Let’s, for example, create a function with one dimension parameter:

```
fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }
```

The `Self` in the return type and the body of the function are aliases for the type that appears for the `impl` keyword (not shown), in this case, `Rectangle`.

To use the the `square` associated function you can use the `::` syntax as shown in the code below:

```
let sq = Rectangle::square(3);
```

So far we learned the basics of Structs, Methods and Associated Functions in Rust. See you in the next post!

bafybeifct42gbphc5syhqqxwv2mbhm4uqrcamfc7vuqtbsgc5odnoppham

My Rust Journey - 10 Oct 2024

Currently, 67 different accounts got are eligile to get at least the Bronze NFT.

145 shares, equivalent to 10B WUD and 2200 DOT have been burned into the WUD/DOT LP on Hydration.

See the leaderboard --> https://flappywud-backend-production.up.railway.app/burn-leaderboard

Join the tg chat --> t.me/GavunWud and use the in-chat filters `/nfts` to know how to participate.

See this video --> https://www.youtube.com/watch?v=b-mbadQ3v3s

bafybeigcxrdpxvockkbdym3ei6gpx5ylcfopwgi4awjy7yi3wr4kthqzjm

7 hours left to get your Gavun Wud OG NFT!

Learn about Gavun Wud and the hottest NFT sale on Polkadot since 2020

bafybeiefac2lvi5ufudocoymhd4pumn6werjgyu7landeotkc6d5l5f5sq

This is the 5th post about my journey learning the Rust programming language using the [Rust Book](https://doc.rust-lang.org/book/). Previous posts include:

[Chapter 5: Ownership, reference and borrowing, and slice type](https://grillapp.net/@filippoweb3/my-rust-journey-4-oct-2024-212790?ref=10124)

I am documenting this as I think it is a useful thing to do for people interested in learning Rust from my non-developer perspective.

At this stage, you have already [installed Rust](https://doc.rust-lang.org/book/ch01-01-installation.html) on your machine, and you are ready to write and run your first Rust programs.

I am using [VS code](https://code.visualstudio.com/) with the [rust-analyzer extension](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). I am working on an M1-mac.

The following tutorial will cover [Chapter 6 of the Rust Book](https://doc.rust-lang.org/book/ch06-00-enums.html). It is meant to be a summary and used with the book as a complementary source of information.

## Enumerations

An `enum` value can be only one of its variants containing data themselves. The code below shows the `IpAddr` enumeration specifying two IP address variants `V4` and `V6`, each one containing some data of the `String` type. Within the main function, we can then specify IP addresses.

```
enum IpAddr {
    V4(String),
    V6(String),
}

fn main() {
    let home = IpAddr::V4(String::from("127.0.0.1"));
    let loopback = IpAddr::V6(String::from("::1"));
}
```

Note how the name of each `enum` variant is a function: `IpAddr::V4()` takes a `String` argument and returns an instance of `IpAddr` type.

With `enum`, each variant can have different types and amounts of associated data (differently from `struct`) as shown below:

```
enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

fn main() {
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6(String::from("::1"));
}
```

The code shows that you can put any kind of data within an `enum`.

ChatGPT can be used to build a comparison table between `struct` and `enum`.

![](https://ipfs.subsocial.network/ipfs/bafybeianab25rstkcchbxj2a6ln4e6nhzrxcbb2loaayksjiarm2ekxvy4?type=.png)

The standard library has an `IpAddr` enum, in which its variants have `struct` as address data.

An `enum` can contain multiple data types. Similarly to `struct`, we can write `impl` to define functions that can be used within an `enum` and its variants.

```
enum Message {
    Quit,
    Move {x: i32, y: i32},
    Write(String),
    ChangeColor(i32, i32, i32),
}

impl Message {
    fn call(&self) {
        println!("{:?}",self);
    }
}

fn main() {
    let m = Message::Write(String::from("hello"));
    m.call()
}
```

## Option Enum

The standard library's `Option` type encodes the case where a value can be either something or nothing.

Rust does not have the `null` feature. The issue with null values is that if you try to use them as non-null values, you will get an error of some sort. A null is a value that is absent or invalid. Rust has the `enum` called `Option<T>` that can encode the concept of a value being present or absent, and is defined as follows:

```
enum Option<T> {
	None,
	Some(T),
}
```

The `<T>` syntax means that the `Some` variant of the `Option` enum can hold one piece of data of any type, and that each type that gets used in place of T makes the whole `Option<T>` type a different type.

```
let some_number = Some(5);
let some_char = Some('e');
let absent_number: Option<i32> = None;
```

The type of `some_char` is `Option<char>` (noted with Rust analyzer plugin on VS code). Note how we need to manually specify the type for `absent_number`, in this case being `Option<i32>`. The `None` value is the same thing as null, but the compiler will return an error if we do not specify the type. More than that, any operation using and `Option<T>` type will fail unless specifically implemented.

The code below will return an error because Rust does not understand how to add and `i8` and `Option<i8>` type.

```
let x = 5;
let y = Some(5);

let sum = x + y;
```

The only way to use `y` is to get `T` out of `Option<T>`.

## Match Control Flow

In Rust, the `match` construct is used to compare a value against a series of patterns, and then execute code based on pattern matching. See the code below:

```
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        },
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}
```

We specify the enum `Coin`, with different coins as variants. Within the `value_in_cents` function, we match each variant with a number. Then within the `main` function, we can use the `value_in_cents` function as follows: `value_in_cents(Coin::Penny)`.

### Patters that Bind to Values

We can extract values from `enum` variants using match arms. We add the `UsState` enum and include it within the `Quarter` variant in the `Coin` enum. We then modify the `value_in_cents` function to print the coin variant Quarter state origin.

```
enum UsState {
    Alabama,
    NewYork,
    Washington,
    LosAngeles,
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        },
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}", state);
            25
        }
    }
}
```

Within the main function, we can use the following code:

```
value_in_cents(Coin::Quarter(UsState::LosAngeles));
```

### Matching with Option<T>

We can get the inner `T` value out of `Some` using matching expressions. See the function below:

```
fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}
```

We use the function within the `main` body:

```
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
```

The function `plus_one` takes `Some(5)` and compares it with the match arms. The last arm is the correct one, `i` takes the value of 5, and we get the resulting `Some(6)`.

Note that the match arms must cover all possible values. Omitting the `None` arm will result in a compiler error. We say that matches in Rust are exhaustive: we must exhaust all possibilities for the code to be valid.

### Catch-all Patterns and the _ Placeholder

We can simply tell Rust that we are not going to use anything else than is specified in the match arm by using the `_` placeholder as follows:

```
et dice_roll = 7;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => (),
    }
```

Where the functions are defined below:

```
fn add_fancy_hat() {
    println!("Add a fancy hat!")
}
fn remove_fancy_hat() {
    println!("Remove your fancy hat!")
}
```

For all the numbers except 3 and 7, the function will not return anything, it will just skip all the possible remaining patterns.

### Control Flow if let

The two below are the same:

```
let config_max = Some(3u8);
    match config_max {
        Some(max) => println!("The maximum is {max}."),
        _ => (),
    };

    if let Some(max) = config_max {
        println!("The maximum is {max}.");
    };
```

The `if let` is a more concise syntax for a `match` that runs code when the value matches one pattern and then ignores all the other values.

So far, we learned Enums, Matching, and Control Flow in Rust. See you in the next post!


bafybeifictlc4qbo4jpdjldexecr3oazw5udunemy24myeuyqjpoha62fq

My Rust Journey - 11 Oct 2024

Access the collection **[here](https://kodadot.xyz/ahp/collection/244?sort=blockNumber_ASC)**

Introducing the official Gavun Wud OG WUD BURN NFT Collection—a legendary, 1st edition set of ultra-rare NFT cards auctioned from September to October 2024, created to honor the OG degens who burned WUD and DOT within the WUD Hydration Liquidity Pool.

This exclusive collection features 4 tiers: Diamond, Gold, Silver, and Bronze, each representing the loyalty and dedication of those who contributed to burning an incredible 219.3962 LP shares.

These NFTs are tightly linked to the WUD memecoin, granting holders not only OG status but also special benefits in WUD's flagship web3 game: flappywud.lol (see each card’s description for more details). There may be even more benefits in future WUD endeavors. The auction concluded on October 11th, 2024, at Polkadot relay chain block 22921710, marking a monumental moment in WUD history.

See the OG $WUD BURN MASTERS Leaderboard: https://flappywud-backend-production.up.railway.app/burn-leaderboard

bafybeih3cvage4g3tbh7vwjkgcrpcjkv3sncybmcyepj77fo66esj7mfnu

The WUD OG BURN NFT Collection is here!

This is the 6th post about my journey learning the Rust programming language using the [Rust Book](https://doc.rust-lang.org/book/). Previous posts include:

[Chapter 1: Basics of Rust and Cargo](https://grillapp.net/@filippoweb3/my-rust-journey-17-jan-2024-41322?ref=10124)

[Chapter 3: Mutability and shadowing, variables and constants, scalar and compound data types, functions, control flow with conditional statements and loops](https://grillapp.net/@filippoweb3/my-rust-journey-20-jan-2024-41957?ref=10124)

[Chapter 4: Ownership, reference and borrowing, and slice type](https://grillapp.net/@filippoweb3/my-rust-journey-4-oct-2024-212790?ref=10124)

[Chapter 5: Ownership, reference and borrowing, and slice type](https://grillapp.net/@filippoweb3/my-rust-journey-4-oct-2024-212790?ref=10124)

[Chapter 6: Enums, Control Flow and Matching](https://grillapp.net/@filippoweb3/my-rust-journey-11-oct-2024-214967?ref=10124)

I am documenting this as I think it is a useful thing to do for people interested in learning Rust from my non-developer perspective.

At this stage, you have already [installed Rust](https://doc.rust-lang.org/book/ch01-01-installation.html) on your machine, and you are ready to write and run your first Rust programs.

I am using [VS code](https://code.visualstudio.com/) with the [rust-analyzer extension](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). I am working on an M1-mac.

The following tutorial will cover [Chapter 7 of the Rust Book](https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html). It is meant to be a summary and used with the book as a complementary source of information.

Rust module system includes:
Packages: cargo features to build, test, and share crates
Crates: a tree of modules that produces a library or executable
Modules and use: to control the organization, scope, and privacy of paths
Paths: a way of naming items such as structs, functions, and modules

## Packages and Crates

A crate is the smallest amount of code the Rust compiler can consider at a time.

A crate can be binary or library. Binary crates are programs containing a main function, and they can compile to executable files. Library crates do not have a main function and do not compile, but they share functionalities to be shared with multiple projects. 

A package is a bundle of one or more crates providing a set of functionalities. A package contains a cargo.toml file describing how to build the crates. A package can contain multiple binary crates and, at most, one library crate. 

When you create a new package with `cargo new`, the `toml` file uses Rust convention that `src/main.rs` is the crate root of a binary crate with the same name as the package, and `src/lib` is its crate root.

## Modules to Control Scope and Privacy

Modules let us organize code within a crate. The code within a module is private by default.

Below is an example code of a module tree structure within the `src/lib.rs` crate.

```
mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}
```

The `hosting` and `serving` are sibling modules with the parent module `front_of_the_house`.

## Paths

Paths are used to find items within a module tree. A path can be:

Absolute: full path starting from the crate root, for code on an external crate
Relative: starts from the current module and uses `self`, `super`, or an identifier in the current module

Modules are by default private; to make them public, we need to specify them with `pub`. See below:

```
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}

pub fn eat_at_restaurant() {
    crate::front_of_house::hosting::add_to_waitlist(); //absolute path

    front_of_house::hosting::add_to_waitlist(); //relative path
}
```

First, we need to make `hosting` and `add_to_waitlist` public so that we can use them within the function `eat_at_restaurant`.

## Relative Paths with super

The `super` syntax is equivalent to `../` in the file system and refers to an item in the parent module.

## Making structs and enums public

If you make a struct public, its fields will be private by default unless you make them public. Instead, if you make an enum public, all enum variants will also be public.

## Bringing paths into scope with the “use” keyword

`use crate::front_of_house::hosting` will create a shortcut for future use so that you can use:

```
hosting::add_to_waitlist()
```

instead of

```
crate::front_of_house::hosting::add_to_waitlist()
```
The way the path is used is called “idiomatic” in that we are still specifying the module where the function is defined. The unidiomatic way would be determining the path as follows:

```
use crate::front_of_house::hosting::add_to_waitlist;
```

And then call the function `add_to_waitlist`. This creates confusion about where the function is coming from, especially if you have large pieces of code.

You can also provide new names with the `as` keyword when you specify a path: `use std::io::Result as IoResult`.

With `pub use` you can make available a name for any code to use from a new scope.

You can also use nested pahs: `use std::{cmp::Ordering, io}` is equivalent to:

```
use std::cmp::Ordering;
use std::io;
```

and `use std::io::{self, Write}` is equivalent to:

```
use std::io;
use std::io::Write;
```

`use std::collections::*` brings into scope all public items defined in a path.

You can also separate modules into different files, as explained [here](https://doc.rust-lang.org/book/ch07-05-separating-modules-into-different-files.html).

In this chapter,  we learned about managing your project with packages, crates, and modules in Rust. See you in the next post!


bafybeicevjs7v5rqm7eh53iigjuo4kfm3fxv7rxskp434qko5vx7hh62ju

My Rust Journey - 18 Oct 2024

This is the 7th post about my journey learning the Rust programming language using the [Rust Book](https://doc.rust-lang.org/book/). Previous posts include:

[Chapter 1: Basics of Rust and Cargo](https://grillapp.net/@filippoweb3/my-rust-journey-17-jan-2024-41322?ref=10124)

[Chapter 3: Mutability and shadowing, variables and constants, scalar and compound data types, functions, control flow with conditional statements and loops](https://grillapp.net/@filippoweb3/my-rust-journey-20-jan-2024-41957?ref=10124)

[Chapter 4: Ownership, reference and borrowing, and slice type](https://grillapp.net/@filippoweb3/my-rust-journey-4-oct-2024-212790?ref=10124)

[Chapter 5: Ownership, reference and borrowing, and slice type](https://grillapp.net/@filippoweb3/my-rust-journey-10-oct-2024-214448?ref=10124)

[Chapter 6: Enums, Control Flow and Matching](https://grillapp.net/@filippoweb3/my-rust-journey-11-oct-2024-214967?ref=10124)

[Chapter 7: Packages, Crates and Modules](https://grillapp.net/@filippoweb3/my-rust-journey-18-oct-2024-216937?ref=10124)

I am documenting this as I think it is a useful thing to do for people interested in learning Rust from my non-developer perspective.

At this stage, you have already [installed Rust](https://doc.rust-lang.org/book/ch01-01-installation.html) on your machine, and you are ready to write and run your first Rust programs.

I am using [VS code](https://code.visualstudio.com/) with the [rust-analyzer extension](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). I am working on an M1-mac.

The following tutorial will cover [Chapter 8 of the Rust Book](https://doc.rust-lang.org/book/ch08-00-common-collections.html). It is meant to be a summary and used with the book as a complementary source of information.

## Vectors

See below ways to create a vector.

```
    let v: Vec<i32> = Vec::new(); //creating empty vector

    let mut v = Vec::new();

    v.push(5); //pushing values into a vector
    v.push(6);
    v.push(7);
    v.push(8);

    let v = vec![1, 2, 3, 4, 5]; //create a vector with vec! macro
```

We can create a vector using `Vec<T>` or the macro `vec!`. The first time we specify `v` we need to specify the type as well because we are creating an empty vector and Rust cannot know what is in it at compile time. If we create `v` and then push numbers into it, Rust can infer and we do not to specify the type when we create the empty vector. At compile time `v` will contain some values.

We can extract the third value in `v` by taking a reference to it: `&v[2]`.

We can also do some additional operations. If we use the `get` method we end up with an `Option<T>` that we can use with `match`.

```
let third: Option<&i32> = v.get(2);
    match third {
        Some(third) => println!("The third element is {third}."),
        None => println!("There is no element."),
    }
```

This will allow our program not to enter panic if we specify and index that is outside our vector.

We can also iterate through a vector using `for` loops.

```
let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
        println!("{i}");
    }
```

In this case, we make the vector mutable so that when we iterate through it we can do some operations to modify its elements. Not how to change the value that the mutable reference refers to we need to dereference with the `*` operator.

We can define an enum to store values of different types into one vector.

```
enum SpreadsheetCell {
    Int(i32),
    Float(f64),
    Text(String),
}

let row = vec![ //within the main function
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Text(String::from("blue")),
        SpreadsheetCell::Float(10.12),
    ];
```

The enum specifies the types we can have in a spreadsheet cell. The vector constructs the row with different types.

## Storing UTF-8 Encoded text with Strings

We can specify a string literal and then specify the `String` type using the `to_string` method or the usual `String::from()`.

```
let data = "foo";
let s = data.to_string();

let mut s = String::from("foo");
```

We can update a string using the `push_str` method or the `push` method for char literals.

```
s.push_str("bar");

println!("{s}");
    
s.push('!');

println!("{s}");
```

We can also combine different strings:

```
let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2; //s1 moved to s3
```

The `+` operator uses the `add` method that takes a reference to a string `&str` as input. This is why we used `&s2`. But `&s2` is `&String` type. The `add` method uses a deref coercion turning `&s2` into `&s2[..]`. Because the method does not take ownership of the input parameter, `s2` is still valid after the operation.

For concatenating multiple strings we can use the `format` macro.

```
let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = format!("{s1}-{s2}-{s3}");
```

### Iterating over strings

You can iterate over strings using the `bytes` or `chars` methods.

```
for b in "hello".chars() {
        println!("{b}");
    }
```

For more information about indexing strings see the [Rust book](https://doc.rust-lang.org/book/ch08-02-strings.html#storing-utf-8-encoded-text-with-strings).

## Hash maps

Hash maps are the last type of collection for this chapter (after vectors and strings). Like vectors, hash maps store data on the heap memory and are homogeneous (key and values must have the same type).

Hash maps take the form `HashMap<K, V>` where `K` are the keys and `V` the values.

```
let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

let team_name = String::from("Blue");
let score = scores.get(&team_name).copied().unwrap_or(0);
```

The `score` has the value associated with the “Blue” key. The `get` method returns an `Option<&i32>`, but `copied` actually returns `Option<>i32`. The `unwrap_or` sets the score to 0 if no key exists. We can iterate through the Hash map as follows:

```
for (key, value) in &scores {
        println!("{key}: {value}");
    }
```

Once values are inserted into a hash map, they are owned by it. Values with Copy trait are copied into it, but owned values are moved into it.

Each unique key can have one associated value at a time.

We can modify hashmaps as follows:

```
scores.insert(String::from("Blue"), 25); // overwriting

scores.entry(String::from("Yellow")).or_insert(200); //adding a key and value if not present
scores.entry(String::from("Blue")).or_insert(100);
```

The `entry` method takes the key we want to check as a parameter and gives back an enum called `Entry` that represents a value that might or might not exist.  The `or_insert` method on `Entry` returns a mutable reference to the value of the corresponding key if it exists, or it attaches a new key with the new value. In this case, both keys already exist, and the code won’t do anything.

The code below counts the occurrence of words in a sentence.

```
let text = "hello world wonderful world";

let mut map = HashMap::new();

for word in text.split_whitespace() {
    let count = map.entry(word).or_insert(0);
    *count += 1;
}

println!("{:?}", map);
```

The `split_whitespace` method returns an iterator over subslices separated by space. At each iteration, the loop adds `word` and inserts 0 if there is no value, adding +1. If a word occurs more than once, it just adds +1.

In this chapter,  we learned about common collections in Rust. See you in the next post!

bafybeigz4ltaxdr2ad5767cychli2yxi356hdrekatt3av6qbl7nvqw27e

My Rust Journey - 5th November 2024

This is the 8th post about my journey learning the Rust programming language using the [Rust Book](https://doc.rust-lang.org/book/). Previous posts include:

[Chapter 1: Basics of Rust and Cargo](https://grillapp.net/@filippoweb3/my-rust-journey-17-jan-2024-41322?ref=10124)

[Chapter 3: Mutability and shadowing, variables and constants, scalar and compound data types, functions, control flow with conditional statements and loops](https://grillapp.net/@filippoweb3/my-rust-journey-20-jan-2024-41957?ref=10124)

[Chapter 4: Ownership, reference and borrowing, and slice type](https://grillapp.net/@filippoweb3/my-rust-journey-4-oct-2024-212790?ref=10124)

[Chapter 5: Ownership, reference and borrowing, and slice type](https://grillapp.net/@filippoweb3/my-rust-journey-10-oct-2024-214448?ref=10124)

[Chapter 6: Enums, Control Flow and Matching](https://grillapp.net/@filippoweb3/my-rust-journey-11-oct-2024-214967?ref=10124)

[Chapter 7: Packages, Crates and Modules](https://grillapp.net/@filippoweb3/my-rust-journey-18-oct-2024-216937?ref=10124)

[Chapter 8: Common collections](https://grillapp.net/@filippoweb3/my-rust-journey-5th-november-2024-221406?ref=10124)

I am documenting this as I think it is a useful thing to do for people interested in learning Rust from my non-developer perspective.

At this stage, you have already [installed Rust](https://doc.rust-lang.org/book/ch01-01-installation.html) on your machine, and you are ready to write and run your first Rust programs.

I am using [VS code](https://code.visualstudio.com/) with the [rust-analyzer extension](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). I am working on an M1-mac.

The following tutorial will cover [Chapter 9 of the Rust Book](https://doc.rust-lang.org/book/ch09-00-error-handling.html). It is meant to be a summary and used with the book as a complementary source of information.

Rust groups errors into:


Recoverable like a file not found → Report to user and retry operation
Unrecoverable → always symptoms of a bug, and the program is always stopped

Rust has a type `Result<T, E>` for recoverable errors and the `panic!` macro that stops execution when there is an unrecoverable error. 

## Unrecoverable errors

See the example below:

```
fn main() {
    let v = vec![1, 2, 3];

    v[99];
}
```

The program throws the error message

```
thread 'main' panicked at src/main.rs:4:6:
index out of bounds: the len is 3, but the index is 99
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
```

The `src/main.rs:4:6` indicates the 4th line and 6th character.

We are attempting to access the 100th element in the vector with only three elements. To avoid _buffer overread_ Rust stops execution and refuses to continue.

The error message also suggests running `RUST_BACKTRACE=1 cargo run`. A backtrace is a list of all functions that have been called.

## Recoverable errors

See the code below.

```
let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => match error.kind {
            ErrorKind::NotFound => {
                match File::create("hello.txt") {
                    Ok(fc) => fc,
                    Err(e) => panic!(
                        "Problem creating the file: {:?}",
                        e
                    ),
                }
            }
            other_error => {
                panic!("Problem opening the file: {:?}", other_error);
            }
        },
    };
```

The return type of `File::open` is a `Result<T, E>`. The Result enum and its `Ok` and `Err` variants are brought into scope by the prelude, and there is no need to specify `result::` in the code. 

When the result is `Ok`, the code returns the file; when it is `Err`, it calls the `panic!` macro. 

The type of the `Err` variant is `io::Error`, a struct provided by the standard library. The struct has the `kind` method to get an `io::ErrorKind`, an enum with variants representing different kinds of errors. The one we are interested in is the `ErrorKind::NotFound` variant, which indicates that the file we are trying to open does not exist yet. 

If the file is not found, we create it. A nested match also takes care of failure in creating the file. If the file exists but there is an error that is not `NotFound`, the program panics. 

The code below is a simplified version using closures and the `unwrap_or_else` method.

```
let greeting_file = File::open("hello.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("hello.txt").unwrap_or_else(|error| {
                panic!("Problem creating the file: {:?}", error);
            })
        } else {
            panic!("Problem opening the file: {:?}", error);
        }
    });
```

The code does not contain and `match` expression.

The two lines of code below are shortcuts for panic on error using `unwrap` and `expect`.

```
let greeting_file = File::open("hello.txt").unwrap();

let greeting_file = File::open("hello.txt").expect("hello.txt should be included in this project");
```

## Propagating errors

The function below shows how we can propagate errors in Rust.

```
fn read_username_from_file() -> Result<String, io::Error> {
    let username_file_result = File::open("hello.txt");

    let mut username_file = match username_file_result {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut username = String::new();

    match username_file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e), // no need to call return, it's the last expression!
    }
}
```

The function returns a value of the type `Result<T, E>` where the generic parameter T is filled with the `String` type and the generic parameter E with the `io::Error` type. The function calls the `File::open` function and handles the `Result` value with a match. If the file opening is successful, the file handle becomes the value of the mutable variable `username_file`. In case of an error in opening the file, we pass the error to the variable `e` and we return early out of the function.

If we get a file handle within `username_file`, we create a mutable variable for `username` and with `read_to_string` method we read the content in `username_file` and put it into `username`. The method also returns a `Result` that we need to match. If `read_to_string` succeeds we return the result, if it fails we pass the error to the `e` variable. 

This way of propagating errors is common, and rust uses the ? operator to make the code cleaner.

```
fn read_username_from_file_2() -> Result<String, io::Error> {
    let mut username_file = File::open("hello.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}
```

The function `fs::read_to_string` opens the file, creates a new `String`, reads the contents of the file, puts the contents into the string and returns it.

```
fn read_username_from_file_3() -> Result<String, io::Error> {
    std::fs::read_to_string("hello.txt")
}
```

The ? operator after a `Result` value works similarly to the match expressions we defined. The ? operator additionally calls the `from` function and converts the received error type into the error type defined by the current function.

The ? operator can only be used in functions where the return type is `Result` or `Option`. The operator performs an early return of the function.

In this chapter,  we learned about how to handle errors in Rust. See you in the next post!

bafybeihs7pkrpw4u2e5oq5l64lq7eju6pyr77m3ng5xaurwzgfq76cpxgi

My Rust Journey - 6th Nov 2024

bafybeiaoqeupzfgtb3h23q4lmxion7ziypo47r4akffksv6ulmgojgbhei

filippoweb3

bafyreihql63btmdqkcsgjbpbsxbw36px556xylpktuinzcqh3p3m5olycq

Community Highlights

bafyreidrxd4vlkqzxll4iorjzgb2d33vrsqjkea5d6junacrwo3iufz4oa

Vlad P.

Polkadot News

The Web3 Summit will host a hackathon co-organized by WebZero and Web3 Foundation; sign up here: https://symmetry.theblockspace.net/signup

Web3 Summit will be in Berlin between the 19th and 21st of August, you can still get your tickets here: https://ti...

Polkadot News

Are you opengoving? Upskill your experience on Polkadot OpenGov with the new Nova Wallet release https://x.com/NovaWalletApp/status/1820804430750536097

The Polkadot Championships Hackathon Bali Edition just doubled the prize pool, register now https://polkadotchampionship.org/...

Polkadot News

Meet the Polkadot Decentralized Futures teams, come to today’s space https://x.com/Web3foundation/status/1818995146362438016

The new Polkadot Ledger Generic app is still not supported by all parachains. See the list here: https://dashboards.data.paritytech.io/metadata.html For...

🔥 Web3 explained from the non-developer's POV. 🚀 Helping Polkadot users explore the ecosystem with confidence. I post daily on socials. Opinions are mine.

Polkadot News

Do not miss the Polkadot interview live stream with Conor Daly today at 11 am UTC https://x.com/Polkadot/status/1823411830997373317

The unbonding queue for Polkadot and Kusama has been approved by the Polkadot Technical Fellowship. Upon implementation and deployment, new requests...

Polkadot News

Do not miss the “Polkadot Beyond the Chain” Event in London tonight at 6 pm BST https://lu.ma/k9bi54yl

The Polkadot Championship Hackathon is open to registration. Finals will be held at the Bali Blockchain Center right before Coinfest Asia https://x...

Polkadot News

The state of Polkadot Q2 2024 has been published by Messari messari.co/4dmITSb

Web3 Summit will be in Berlin between the 19th and 21st of August, you can still get your tickets here: https://ti.to/web3-summit/web3-summit-2024

Different teams from the Polkadot ecosystem are...

This is the 6th post about my journey learning the Rust programming language using the Rust Book. Previous posts include:

Chapter 1: Basics of Rust and Cargo

Chapter 3: Mutability and shadowing, variables and constants, scalar and compound data types, functions, control flow with conditional...

Polkadot News

Web3 Summit will be in Berlin next week; you can still get your tickets here: https://ti.to/web3-summit/web3-summit-2024

Watch today’s livestream with Mandala Chain bringing Polkadot at Coinfest Asia https://x.com/i/broadcasts/1yoKMyQBRmWKQ

You can watch classes at the Polkadot...

This is the 4th post about my journey learning the Rust programming language using the Rust Book. Previous posts include:

Chapter 1: Basics of Rust and Cargo

Chapter 3: Mutability and shadowing, variables and constants, scalar and compound data types, functions, control flow with conditional...

This is the 5th post about my journey learning the Rust programming language using the Rust Book. Previous posts include:

Chapter 5: Ownership, reference and borrowing, and slice type

I am documenting this as I think it is a useful thing to do for people interested in learning Rust from my...

Scan the QR

If you do not have it, install Nova Wallet

Create a wallet with cloud backup (no need to remember a seed phrase)

Scan the QR again

Log in to Flappywud.lol using Nova → play
If you score above 20 points you get 20k WUD deposit on hydration.

Polkadot News

The new Polkadot website made by Distractive is live https://polkadot.com/ https://x.com/Polkadot/status/1821568462365347872

Polkadot nomination pool members will be able to vote in OpenGov; see these support guides: https://support.polkadot...

Polkadot News

The new design for the Polkadot Fellowship Dashboard is live https://polkadot-fellows.github.io/dashboard/

The Polkadot’s JAM graypaper v0.3.4 is out https://github.com/gavofyork/graypaper/releases/

Polkadot nomination pool members will be able to vote in OpenGov; see these...

Currently, 67 different accounts got are eligile to get at least the Bronze NFT.

145 shares, equivalent to 10B WUD and 2200 DOT have been burned into the WUD/DOT LP on Hydration.

See the leaderboard --> https://flappywud-backend-production.up.railway.app/burn-leaderboard

Join the tg chat --> t...

This is the 7th post about my journey learning the Rust programming language using the Rust Book. Previous posts include:

Chapter 1: Basics of Rust and Cargo

Chapter 3: Mutability and shadowing, variables and constants, scalar and compound data types, functions, control flow with conditional...

Access the collection here

Introducing the official Gavun Wud OG WUD BURN NFT Collection—a legendary, 1st edition set of ultra-rare NFT cards auctioned from September to October 2024, created to honor the OG degens who burned WUD and DOT within the WUD Hydration Liquidity Pool.

This exclusive...

This is the third post about my journey learning the Rust programming language using the Rust Book. Previous posts include:

Chapter 3: Shadowning, mutability, variables and constants, data types, and control flow

I am documenting this as I think it is a useful thing to do for people interested...

This is the 8th post about my journey learning the Rust programming language using the Rust Book. Previous posts include:

Chapter 1: Basics of Rust and Cargo

Chapter 3: Mutability and shadowing, variables and constants, scalar and compound data types, functions, control flow with conditional...

Notable posts created by Subsocial community members. To have your post featured, make sure that it is high quality, and you have at least 2,000 SUB locked!