rust: refined loop notes

docs/rust/rust.md

@@ -1,12 +1,5 @@
 # Rust
 
-## Compiling and running
-
-```ps1
-rustc file.rs  # compilation
-file.exe  # running
-```
-
 ## Basics
 
 ```rs
@@ -310,11 +303,11 @@ fn func() {
 
 ```rs
 if condition {
-    // code here
+    // [...]
 } else if condition {
-    // code here
+    // [...]
 } else {
-    // code here
+    // [...]
 }
 ```
 
@@ -327,37 +320,30 @@ let var = if condition { value } else { value };  // returned types must be the
 ### [if-let](https://doc.rust-lang.org/rust-by-example/flow_control/if_let.html)
 
 ```rs
-if let <pattern> = <value> {
+if let <pattern> = <expr> {
-  /* do something */
+    <block1>
+} else {
+    <block2>
 }
 
 // same as
-let optional = Some(value);
+match <expr> {
-match optional {
+    <pattern> => { block1 }
-    Some(param) => { /* do something */ },
+    _ => { block2 }
-    Some(ref param) => { /* borrow value instead of moving */ }
+}
-    _ => {},
-};
 ```
 
 ### loop
 
 ```rs
-loop {  // loop's forever if not explicitly stopped
+// loop's forever if not explicitly stopped (return or break)
-    // code here
+loop { }
-
-    if condition {
-        break returned_value
-    }
-}
 ```
 
 ### while
 
 ```rs
-while condition {  // runs while condition is true
+while condition { }
-    // code here
-}
 ```
 
 ### for
@@ -366,10 +352,52 @@ while condition {  // runs while condition is true
 for item in sequence.iter() { }
 for item in sequence.iter_mut() { }  // iterate over mutable items
 
-// item is a reference to the value in the sequence, use & and * to access the value or address
+for item in sequence { }  // consumes the values (moved into item)
+for item in &sequence { }  // doesn't consumes the values (item is a reference)
+for item in &mut sequence { }
 
-for i in (start..end) {  // (start..stop) is like python's range(start, stop)
+// for (i = start; i < end; i += 1)
-    // code here
+for i in (start..end) { }
+```
+
+### Range
+
+```rs
+..  // RangeFull
+a ..  // RangeFrom { start: a }
+.. b  // RangeTo { end: b }
+a .. b  // Range { start: a, end: b }
+..= b  // RangeToInclusive { end: b }
+a ..= b  // RangeInclusive::new(a, b)
+```
+
+### `break` & `continue`
+
+```rs
+while <condition> {
+    // [...]
+
+    continue;  // jump to condition evaluation
+}
+
+let loop_result = loop {
+    // [...]
+
+    break <loop-value>;
+}
+
+'outer: loop {
+    // [...]
+    loop {}
+
+    break 'outer;  // break labeled loop
+}
+
+let loop_result = 'outer: loop {
+    // [...]
+    loop {}
+
+    break 'outer <loop-value>; // break labeled loop and return value
 }
 ```
 
@@ -527,7 +555,7 @@ fn borrow2(var: &mut Type) {
 The `.` operator can **implicitly borrow or dereference** a reference
 
 ```rs
-let struct = Struct { field: /* ... */ }
+let struct = Struct { field: /* [...] */ }
 let ref = &struct;
 
 ref.field  // implicit deref
@@ -694,7 +722,7 @@ Derivable Traits:
 #[derive(Trait)]  // derive a trait for the struct
 #[derive(Trait, Trait, ...)]  // derive multiple traits
 struct Struct {
-    /* ... */
+    // [...]
 }
 ```