30 Days of Rust - Halfway
Tags: rust, learning, beginners
Published: 2023-05-09 06:09:09

Wohoo, we've made it to the halfway point 💪 For those following carefully, it hasn't quite been 15 continuous days, but in sum we've written 15 Rust blogs and learned (and suffered) a bunch. I'm not going to mark this blog with anything special. My only goal right now is to finish the Rust book by day 30. Let's goooo!

## Yesterday's questions answered
- A `const` function simply describes a function that is called from with in a `const context`. A `const context` exists in specific expressions, particularly those linked to array size and length declaration and as well as `const`, `static` and `enum` declaration. `const` functions are called at compile time.
- The "use case" for integer overflow seems to be limited to primarily the crypto world. I found [an article](https://medium.com/coinmonks/understanding-arithmetic-overflow-underflows-in-rust-and-solana-smart-contracts-9f3c9802dc45) explaining how to handling for a specific type of smart contract (I didn't really read it, it's too early for smart contracts!!!). Another situation could be in a memory restrictive environment. Imagine a tiny CPU processing requests from sensors in some kind of embedded system. If one of those sensors is faulty or there is a bug in the communication protocol (the latter being unlikely) the CPU could receive a 256 instead of 255, leading to an overflow.

## Today's open questions
- What is a `static`?


## Fun fun FUNctions
We already covered the basic syntax of functions, particularly in [day 3](https://dev.to/johnnylarner/30-days-of-rust-day-3-40fl). I'll add some summary points that I've learned to better express how functions work.

Remember, a function in Rust can return a value in Rust by ending in an expression *or* a `return` statement. The Rust book provides useful definitions for those terms:

>  **Statements** are instructions that perform some action and do not return a value.
>  **Expressions** evaluate to a resultant value

We can see now that the `return` keyword offers a unique behaviour for statements in Rust. This also explains why you cannot chain declaration statements in Rust, as a statement does not return a value, for example in Python:
```python
x = y = 6
print(f"{x}, {y}")
# 6, 6
```

Functions, however, are not the only instance where expressions in an inner scope can be used to return a value to an outer scope in Rust. We've already encountered this a few times:
```rust
let x = {
	let x = 2;
	x + 2
}
println!("x = {x}"); // 4

let y = match johnny_is_awesome {
	Ok(johnny) => true,
	Err(_) => false
}
println!("Is Johnny awesome? {y}");

```
We could use a `loop` or `if` expression in a similar fashion. What's interesting here is that Rust is consistent to the definitions it stated above. And I'd like to shamelessly *speculate* that the inclusion `return` statement may even be a historical product from programming tradition (or to make Rust seem not too try hard hipster).

## Quickly on `ifs`
I'm pretty certain I've been mistakenly calling `if` expressions `if` *statements*  for the entirety of this blog 🐒 Kudos if you spotted those mistakes. As noted above it's possible for a value to be assigned from an `if` expression in Rust. As such (and this is also true for `match` expressions), each arm (aka block) of an if expression must yield a result of the same type (only if you care about your code compiling, of course). I'm guessing my confusion stems from the Python world where `if` is rarely used as an expression:
```python
args = args if args else {}

if not args:
	args = {}
```

## Even quicker on `loops`
A couple of neat tricks for loops in Rust:
- You can label a loop. This label can be used by the `continue` or `break` keywords (not specifying the label will break the innermost loop of the current scope). Note the single `'` here, it's not a typo:
```rust
'outer: loop {
	'inner: loop {
		if ... {
			break 'outer;
		} else {
			break; // Breaks 'inner
		}
	}
}
```
- Range iterators have a `rev` method which will reverse the order of the range!