A Handy Rust Cheat Sheet for Beginners

1. Variables and Data Types

Declare a variable (immutable by default):
```
  let variable_name = value;
```
Declare a mutable variable:
```
  let mut variable_name = value;
```

Specify a data type:

  let variable_name: data_type = value;

Common data types:
- Integer: i32, u32, i64, u64
- Floating-point: f32, f64
- Boolean: bool
- Character: char
- String: String
- Array: [T; N] (T: type, N: length)
- Tuple: (T1, T2, T3) (T1, T2, T3: types)

2. Control Flow

if statement:

  if condition {
      // code
  } else if other_condition {
      // code
  } else {
      // code
  }

loop statement (infinite loop):
```
  loop {
      // code
  }
```
while loop:
```
  while condition {
      // code
  }
```

for loop:

  for variable in iterable {
      // code
  }

3. Functions

Define a function:

  fn function_name(parameter: data_type) -> return_type {
      // code
  }

Call a function:
```
  function_name(argument);
```

4. Enums and Pattern Matching

Define an enum:

  enum EnumName {
      Variant1,
      Variant2,
      Variant3(data_type),
  }

match statement:

  match value {
      EnumName::Variant1 => {
          // code
      },
      EnumName::Variant2 => {
          // code
      },
      EnumName::Variant3(variable) => {
          // code
      },
      _ => {
          // code
      },
  }

5. Error Handling

Result enum for error handling:

  enum Result<T, E> {
      Ok(T),
      Err(E),
  }

match statement with Result:

  match result {
      Ok(value) => {
          // code
      },
      Err(error) => {
          // code
      },
  }

? operator for propagating errors:

  let result = function_returning_result()?;

6. Collections

Create a vector:

  let mut vector = Vec::new();
  // or
  let vector = vec![value1, value2, value3];

Create a hash map:

  use std::collections::HashMap;
  let mut hash_map = HashMap::new();

Create a hash set:

  use std::collections::HashSet;
  let mut hash_set = HashSet::new();

Detailed CheatSheet:
https://cheats.rs/