starting over

.gitignore

@@ -0,0 +1,14 @@
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb

hello_cargo/.gitignore

@@ -1,2 +0,0 @@
-Cargo.lock
-target

hello_cargo/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "hello_cargo"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]

hello_cargo/src/main.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("ǰ DZ Dz dz Ǵ ǵ Ƕ Ƿ Ǹ ǹ Ǻ ǻ Ǽ ǽ Ǿ");
-}

notes

@@ -0,0 +1,233 @@
+const is a thing
+const convention is all upper with _
+const evaluation info: https://doc.rust-lang.org/reference/const_eval.html
+
+you can add arbitray scopes to modify local variables or for other purposes!
+	{
+	some random shit;
+	}
+
+https://doc.rust-lang.org/book/ch03-02-data-types.html
+
+scalars:
+	ints
+	floats
+	bools
+	chars
+integer types:
+	8-bit	i8	u8
+	16-bit	i16	u16
+	32-bit	i32	u32
+	64-bit	i64	u64
+	128-bit	i128	u128
+	arch	isize	usize
+
+number literals
+decimal	1_024
+hex	0xff
+oct	0o77
+binary	0b1100_1011_0100_0001
+byte	b'E'
+
+release builds have no overflow wrap checking
+don't rely on this behavior
+
+explicitly use
+`wrapping_*` methods to do this
+	such as wrapping_add
+Return the None value if there is overflow with the checked_* methods
+Return the value and a boolean indicating whether there was overflow with the overflowing_* methods
+
+wtf is this:
+  Saturate at the value’s minimum or maximum values with saturating_* methods
+
+there are f32 and f64 floats. f64 is default cause they are about the same speed
+
+normal math operators
+int division is floor
+remainder % exists
+
+all operators:
+https://doc.rust-lang.org/book/appendix-02-operators.html
+
+
+type annotation:
+
+let var: type = val;
+
+Rust’s char type is four bytes in size and represents a Unicode Scalar Value
+
+Compound types
+
+  primitive compound types:
+  	tuples
+	arrays
+
+Tuples:
+	fixed length combo of types
+	type is ()
+
+	pulling out the elements of a tuple into individual variables is called destructuring
+
+Arrays:
+	fixed type fixed length
+	[]
+
+	init:
+		let a: [1, 2, 3];
+		let a: [3, 0]; // set every element to same value
+	reference:
+		let first = a[0];
+	they are allocated on stack
+
+https://doc.rust-lang.org/book/ch03-03-how-functions-work.html
+
+all function parameters must be annotated
+functions consist of statements and expressions
+statements perform an action and have no return value
+expressions do return something
+
+a scope block is an expression
+expressions do not end with a ";", if you add a ";" it will be statement
+return is explicit if the last statement in a function is an expression
+
+https://doc.rust-lang.org/book/ch03-04-comments.html
+comments
+
+// is a comment
+/* is also a comment
+b*/
+
+for some reason the doc didn't mention the second type..
+
+
+https://doc.rust-lang.org/book/ch03-05-control-flow.html
+control flow
+
+there is `if``
+
+block of code within the "if" are _arms_.
+just like the match
+
+if must recieve a bool
+no bad python
+if num {}
+
+if (thing) {
+    else if (other thing) {
+}   else if (yat) {
+}   else {
+}
+
+use `match` for too many else ifs
+
+if is an expression!
+
+you can loop with `loop`
+loop is an expression!
+
+break can return a value (not for for loops though they are a statement)
+break can select nest level with 'label
+
+thats called a loop label
+
+while loop exists
+for loop exists
+
+syntax: for x in y {}
+
+(start..end) is a Range
+(1..4).rev() is a thing
+
+
+https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html?search=
+ownership
+
+stack - lifo in order memory storage, stack of PLATES
+	pushing / popping
+	all data stored here must have a FIXED size
+
+heap - rando shit goes here
+	allocating / deallocating
+	pointer to data structure goes on the stack, the actual data goes on the heap
+
+each value in Rust has an _owner_
+there can be only one owner at a time
+when the owner goes out of scope, the value goes out of scope
+
+a string has 3 parts
+
+name | val
+-----------
+ptr  |  ------> index | val
+len  |  5 |     -------------
+cap  |  5 |     | 0   | 'h' |
+-----------     | 1   | 'e' |
+
+
+string2 = string1;
+create a new string data structure
+have the pointer point to the same data as string1
+
+invalid:
+
+s2 = s1;
+println!("{s1}");
+
+there can't be two pointers to the same value!
+
+shallow copy is a move because the first pointer is invalidated
+
+clone is "deep copy"
+
+s2 = s1.clone();
+
+stack based vars don't need to clone, they `copy`, it's automatic
+
+drop is called to return memory from the heap when it's owner goes out of scope
+
+any type that implements the copy trait will auto copy.
+a type can not implement copy and drop...
+
+tuples will copy if all of their types support it, it will not if any one of them does not
+
+a function can take an immutable heap mounted variable and "recast" it is mutable
+
+https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html
+references
+
+rust has a method to let a function use a variable without moving / reassigning
+ownership: references
+
+& is a reference
+* is a dereference
+
+pass a reference to avoid _moving_ the value
+references are immutable by default
+
+&mut var // makes a mutable reference
+
+there can be one or multiple r/o references or only one mutable reference at a time
+
+https://doc.rust-lang.org/book/ch04-03-slices.html
+slices
+
+reference to a contiguous sequence of elements
+
+enumerate returns a tuple with counter and reference to thing (counter, &thing)
+
+slice is a pointer to a string, with a length
+
+let s = String::from("a a a a");
+slice = &s[0..2];
+
+you can drop the first number if it's zero: let slice = &s[..2];
+or the last number if it's the end of the string: let slice = &s[4..];
+or both numbers to slice the whole thing: let slice = &s[..];
+
+you can not create a slice that starts or ends within multibyte unicode parts
+
+String: a heap allocated vector of bytes that is stored on the heap. It is potentially mutable.
+&str: an immutable borrowed string slice.
+
+let s = "string"; // string literal (it's a slice)