diff options
20 files changed, 140 insertions, 1 deletions
diff --git a/.obsidian/graph.json b/.obsidian/graph.json index 1cdef47..863f273 100644 --- a/.obsidian/graph.json +++ b/.obsidian/graph.json @@ -17,6 +17,6 @@ "repelStrength": 10, "linkStrength": 1, "linkDistance": 500, - "scale": 0.0889892578125, + "scale": 0.04303687666455931, "close": true }
\ No newline at end of file diff --git a/Accessing a tuple by index is different from an array.md b/Accessing a tuple by index is different from an array.md new file mode 100644 index 0000000..58a93a9 --- /dev/null +++ b/Accessing a tuple by index is different from an array.md @@ -0,0 +1,3 @@ +[[Rust]] + +In rust the way to access a tuple's value by a specific index is done with a `.` rather than `[]`. For an array it is no different from other languages.
\ No newline at end of file diff --git a/An empty tuple is called a unit.md b/An empty tuple is called a unit.md new file mode 100644 index 0000000..a97056a --- /dev/null +++ b/An empty tuple is called a unit.md @@ -0,0 +1,3 @@ +[[Rust]] + +An empty tuple `()` is named a `unit`. This acts as a sort of null value, it is the default value of functions that return nothing. So instead of saying it returns null I should say it returns a unit.
\ No newline at end of file diff --git a/Array notation.md b/Array notation.md new file mode 100644 index 0000000..b4cc810 --- /dev/null +++ b/Array notation.md @@ -0,0 +1,13 @@ +[[Rust]] + +The array notation is a bit special compared to other languages so I will write it down here: + +Unlike tuples, arrays can only hold one type: + +`let a: [i32; 5] = [1, 2, 3, 4, 5]` Specifies an array of length 5. +`let a = [3; 5];` specifies an array of length 5 with all values set to 3. +> Note the semicolon rather than a comma! + +Indexing as usual + +Out of bounds access result in a panic.
\ No newline at end of file diff --git a/Arrays are useful when you know the length will not change.md b/Arrays are useful when you know the length will not change.md new file mode 100644 index 0000000..574dd01 --- /dev/null +++ b/Arrays are useful when you know the length will not change.md @@ -0,0 +1,3 @@ +[[Rust]] + +Because they are more efficient than vectors, if you know ahead of time that the length of the array isn't going to change, for example the names of the months: use an array.
\ No newline at end of file diff --git a/Cargo.md b/Cargo.md new file mode 100644 index 0000000..baa57ed --- /dev/null +++ b/Cargo.md @@ -0,0 +1,9 @@ +[[Rust]] + +Standard stuff: +- cargo build +- cargo update +- cargo run + +Cool tidbit: +- cargo doc --open diff --git a/Char is a unicode scalar value.md b/Char is a unicode scalar value.md new file mode 100644 index 0000000..00d1f59 --- /dev/null +++ b/Char is a unicode scalar value.md @@ -0,0 +1,3 @@ +[[Rust]] + +In rust a `char` is a scalar value, it is 4 bytes in size and contains a unicode value so it can represent any character.
\ No newline at end of file diff --git a/Integers can overflow if compiled with --release.md b/Integers can overflow if compiled with --release.md new file mode 100644 index 0000000..94d80ca --- /dev/null +++ b/Integers can overflow if compiled with --release.md @@ -0,0 +1,11 @@ +[[Rust]] + +Integers that overflow wrap around. ie in an i8 256 -> 0, 257 -> 1, etc. + +The standard library includes families of methods for primitive numeric types to handle wrapping: +- `wrapping_*`: wrap in all modes +- `checked_*`: return None if overflow +- `overflowing_*`: return val + bool that indicates whether overflow occurred +- `saturating_*`: saturate at the minimum or maximum values + +[[Saturating a value when wrapping]] diff --git a/Items that are always imported by default in Rust are called the prelude.md b/Items that are always imported by default in Rust are called the prelude.md new file mode 100644 index 0000000..6a4fa2f --- /dev/null +++ b/Items that are always imported by default in Rust are called the prelude.md @@ -0,0 +1,5 @@ +[[Rust]] + +Every function and other thing that are always accessible in every Rust program are together called the `prelude`. + +What is included in the prelude is documented [here](https://doc.rust-lang.org/std/prelude/index.html)
\ No newline at end of file diff --git a/Pattern matching with a match expression.md b/Pattern matching with a match expression.md new file mode 100644 index 0000000..affc752 --- /dev/null +++ b/Pattern matching with a match expression.md @@ -0,0 +1,13 @@ +[[Rust]] + +This looks like a regular function call but then followed by a block of code. It is called a match expression. A match expression consists of arms, that are the pattern to match and the code to execute. + +For example if a function returns an enum it is a nice way to write each case, it is somewhat similar to a switch statement. + +```rust +guess.cmp(&secret_number) { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!!"), +} +``` diff --git a/Primitive values such as the array are allocated on the stack.md b/Primitive values such as the array are allocated on the stack.md new file mode 100644 index 0000000..c46ff60 --- /dev/null +++ b/Primitive values such as the array are allocated on the stack.md @@ -0,0 +1,3 @@ +[[Rust]] + +This may be useful to know when optimizing for speed. But for example arrays are limited (or more difficult) in use than vectors which are allocated on the heap instead.
\ No newline at end of file diff --git a/Random numbers in Rust.md b/Random numbers in Rust.md new file mode 100644 index 0000000..85b4e59 --- /dev/null +++ b/Random numbers in Rust.md @@ -0,0 +1,3 @@ +[[Rust]] + +To do random numbers we can use the [rand crate](https://crates.io/crates/rand).
\ No newline at end of file diff --git a/References are also immutable by default.md b/References are also immutable by default.md new file mode 100644 index 0000000..f434b63 --- /dev/null +++ b/References are also immutable by default.md @@ -0,0 +1,5 @@ +[[Rust]] + +--- + +Because references are also immutable by default, if we would declare a variable mutable such as `let mut guess = String::new();` and we were to pass a references to guess to another function, we must place the `mut` keyword there as well as such: `read_line(&mut guess)` rather than just `read_line(&guess)`. @@ -0,0 +1,17 @@ +[[Why it is good to learn rust]] +[[Cargo]] +[[Items that are always imported by default in Rust are called the prelude]] +[[Static class functions are called associated functions]] +[[References are also immutable by default]] +[[Random numbers in Rust]] +[[Pattern matching with a match expression]] +[[Shadowing variables]] +[[Integers can overflow if compiled with --release]] +[[Char is a unicode scalar value]] +[[Unlike integers floats do not have an architecture dependent size]] +[[Why is it called destructuring]] +[[Accessing a tuple by index is different from an array]] +[[An empty tuple is called a unit]] +[[Primitive values such as the array are allocated on the stack]] +[[Arrays are useful when you know the length will not change]] +[[Array notation]] diff --git a/Saturating a value when wrapping.md b/Saturating a value when wrapping.md new file mode 100644 index 0000000..2cc5bf9 --- /dev/null +++ b/Saturating a value when wrapping.md @@ -0,0 +1,12 @@ +[[Integers can overflow if compiled with --release]] +[[Rust]] + +This was a bit confusing to me, but [this forum post](https://users.rust-lang.org/t/saturating-what-does-it-really-do-and-when-is-it-useful/52720/2) sums it up quite well: + +Instead of wrapping around or error'ing, the maximum or minimum value of the type is chosen depending on which is closest to the result. + +Example with `u8`: +`0 - 1 = 0` +`7 - 8 = 0` +`8 + 1 = 8` +`1 + 8 = 8`
\ No newline at end of file diff --git a/Shadowing variables.md b/Shadowing variables.md new file mode 100644 index 0000000..ce10d66 --- /dev/null +++ b/Shadowing variables.md @@ -0,0 +1,12 @@ +[[Rust]] + +It is basically redeclaring the same variable, but it can be redeclared with a **different type**. A immutable variable can also be shadowed. + +Shadowing is undone when the scope ends, for example in a closure I can shadow a variable from the parent scope, but in the parent scope after the child scope ends we have the original value not the one from the child scope. + +It is useful for reusing a name, ie: +```rust +let spaces = " "; +let spaces = spaces.len(); +``` +> the type of spaces changes from string to u32. diff --git a/Static class functions are called associated functions.md b/Static class functions are called associated functions.md new file mode 100644 index 0000000..dc4c195 --- /dev/null +++ b/Static class functions are called associated functions.md @@ -0,0 +1,6 @@ +[[Rust]] + +--- +An `associated function` is what in other OOP languages like PHP would be considered a static function on a class. So it's callable directly from on type rather than an object. An example in Rust is `String::new()`. + +It is indicated by the double colon `::`.
\ No newline at end of file diff --git a/Unlike integers floats do not have an architecture dependent size.md b/Unlike integers floats do not have an architecture dependent size.md new file mode 100644 index 0000000..f6b962f --- /dev/null +++ b/Unlike integers floats do not have an architecture dependent size.md @@ -0,0 +1,5 @@ +[[Rust]] + +Integers come in many sizes with the smallest being 8-bit and the largest 128-bit. However there is also `usize or isize` which specifies that the size is dependent on the CPU architecture. + +In contrast, floating points only have two sizes: f32 and f64. There is no fsize.
\ No newline at end of file diff --git a/Why is it called destructuring.md b/Why is it called destructuring.md new file mode 100644 index 0000000..6f8945c --- /dev/null +++ b/Why is it called destructuring.md @@ -0,0 +1,8 @@ +[[Rust]] + +Destructuring is binding each value in a compound type to a name. It is called destructuring because we break the compound element into individual elements. + +```rust +let tup = (1, 2, 3); +let (a, b, c) = tup; +``` diff --git a/Why it is good to learn rust.md b/Why it is good to learn rust.md new file mode 100644 index 0000000..c60bbc6 --- /dev/null +++ b/Why it is good to learn rust.md @@ -0,0 +1,5 @@ +[[Rust]] + +--- +I want to do game engine development and game development in my spare time +I can use it for systems programming too
\ No newline at end of file |