98 lines
2.9 KiB
Markdown
98 lines
2.9 KiB
Markdown
#Rust
|
|
|
|
The quick brown fox jumps over the lazy dog. The dog stays blissfully asleep. :)
|
|
|
|
# What is Chapter 3?
|
|
Chapter three is about common programming concepts that I would be familiar with
|
|
from other languages. This chapter covers variables, mutability, data types,
|
|
functions, comments, and control flow.
|
|
|
|
# 3.1 Variables and Mutability
|
|
## Variables
|
|
Rust defines variables kind of like C does:
|
|
```rust
|
|
let x = 7; // x is 7!
|
|
```
|
|
but Rust also allows explicit declaration of types when defining a variable:
|
|
|
|
```rust
|
|
let x: u32 = 7; // x is a 32 bit unsigned integer with value 7
|
|
let y: f32 = 7.0; // y is a 32 bit float with value of 7.0
|
|
```
|
|
|
|
Variables can be defined in specific scopes that do not escape the inner scope:
|
|
|
|
```rust
|
|
let x: u32 = 4;
|
|
{
|
|
let mut x = x;
|
|
x += 2;
|
|
}
|
|
|
|
println!("{x}")
|
|
>> 4 // NOT 6.
|
|
```
|
|
|
|
## Mutability
|
|
All variables in Rust are immutable unless specifically mentioned. This is
|
|
part of ensuring memory safety--you will not be able to overwrite variables
|
|
unless you declare that they can change over time. Here's an example:
|
|
|
|
```rust
|
|
let x: u32 = 2;
|
|
x += 2; // Will fail. x is not mutable
|
|
|
|
let mut y: u32 = 2;
|
|
y += 2; // Will work, since y is mutable
|
|
```
|
|
|
|
### Constants
|
|
Constants are a special case in Rust. They are immutable variables just like
|
|
`let`, but they have a special ability to be defined in the global scope,
|
|
where `let` may not be. Here's an example.
|
|
|
|
```rust
|
|
const TWO_PLUS_THREE: u32 = 2 + 3;
|
|
fn main() {
|
|
println!("{TWO_PLUS_THREE}");
|
|
}
|
|
>> 5
|
|
```
|
|
Constants are by convention written in UPPER_CAMEL_CASE.
|
|
|
|
# 3.2 Data Types
|
|
Rust is a statically typed language. Variables in Rust must have their types
|
|
known at compile time, or else the compilation will fail. A lot of times types
|
|
can be inferred, but this is not possible for cases where there are multiple
|
|
possible types.
|
|
|
|
For these cases, the type must be annotated, like this:
|
|
```rust
|
|
let annotated: str = "This one is annotated!";
|
|
let not_annotated = "This one is not!";
|
|
```
|
|
|
|
## Scalar Types
|
|
Scalar types are those that only take on one object. Examples in Rust are
|
|
integers, characters, booleans, and floating-point numbers.
|
|
|
|
Integers can be signed or unsigned, with different levels of bit resolution,
|
|
up to 128 bits. That being said, there is an 'arch' length that is the size of
|
|
the operating system. This is used with `isize` and `usize`. Signed integers are
|
|
stored with two's complement.
|
|
|
|
Numbers can also be written in differnet formats, including decimals (with _
|
|
escapes), hex values, octal values, binary values, or even as a byte(b'A').
|
|
|
|
>[!note] A special note about *integer overflow*.
|
|
> Rust code compiled and ran in debug mode will have checks for integer
|
|
> overflow, causing the code to panic at runtime if an overflow occurs.
|
|
> Production code compiled with the `--release` flag will NOT panic however,
|
|
> but instead will wrap around to the first value in the possible range.
|
|
|
|
# 3.3 Functions
|
|
|
|
# 3.4 Comments
|
|
|
|
# 3.5 Control Flow
|