user: Can you list all the important keywords of the Rust programming language and give a brief description of each one? Please return the results in markdown table format where the table headers are: keyword, description.

assistant: Keyword	Description
Crafting	Crafting allows players to create new items from resources gathered in the game. Players can craft items such as tools, weapons, and armor.
Building	Building allows players to create structures and shelters to protect themselves from the environment and other players.
Mining	Mining allows players to gather resources such as stone and metal ore from the world. These resources can be used to craft items.
Foraging	Foraging allows players to gather resources such as wood, berries, and cloth from the world. These resources can be used to craft items.
Combat	Combat allows players to engage in combat with other players or hostile animals in the game. Combat can range from melee combat to ranged combat.
Gathering	Gathering allows players to collect resources such as stone, wood, and metal ore from the world. These resources can be used to craft items.
Crafting Recipes	Crafting Recipes allow players to craft items from the resources gathered in the game. Recipes are unlockable by gathering resources and discovering new technologies.
Trading	Trading allows players to trade items with other players in the game. This is a great way to get new items and resources.

user: sorry but that's a list of keywords for the game rust, as I meant the programming language, could you please re-do it?

assistant: # Overview

Rust divides keywords into three categories:
- Strict keywords are keywords that can only be used in their correct contexts and cannot be used as names of items, variables, fields, variants, types, lifetime parameters, loop labels, macros, attributes, macro placeholders, or creates.
- Reserved keywords are keywords that aren't used yet, but they are reserved for future use and have the same restrictions as strict keywords. As of now the reserved keywords are `abstract`, `become`, `box`, `do`, `final`, `macro`, `override`, `priv`, `typeof`, `unsized`, `virtual`, and `yield` and do not have any meaning as of now.
- Weak keywords have special meaning only in certain contexts.

# Strict

| Keyword | Description |
|----------|-------------|
| `as` | Used to cast between types, pointer and address conversion, or rename an import |
| `break` | Used to exit early from a loop |
| `const` | Use for compile-time constants, compile-time evaluable functions, and raw pointers |
| `continue` | Skip to the next iteration of a loop |
| `crate` | Can be used as a part of a `extern` deceleration, to make an item public to other members of own crate with `pub(crate)`, or as the root of the current crate when specifying a module |
| `else` | The expression to evaluate when an `if` condition evaluates to `false` |
| `enum` | A type that can be any one of several variants |
| `extern` | Link to or import external code |
| `false` | A value of type `bool` representing logical **false**. It is the opposite of `true` |
| `fn` | Declares a function or function pointer |
| `for` | Used in for-in-loops and when implementing traits as in `inpl Trait for Type` |
| `if` | Evaluate a block if a condition holds |
| `impl` | Implement some functionality for a type |
| `in` | Iterate over a series of values with `for` |
| `let` | Bind a value to a variable |
| `loop` | Loop indefinitely |
| `match` | Control flow based on pattern matching |
| `mod` | Used to create new modules |
| `move` | Capture a closure’s environment by value |
| `mut` | Declare a variable, reference, or pointer as mutable |
| `pub` | Make an item visible to others |
| `ref` | Bind by reference during pattern matching |
| `return` | Return a value from a function |
| `Self` | The implementing type within a `trait` or `impl` block, or the current type within a type definition |
| `static` | A static item is a value which is valid for the entire duration of your program (a `'static` lifetime) |
| `struct` | A type that is composed of other types |
| `super` | The parent of the current module |
| `trait` | A common interface for a group of types |
| `true` | A value of type `bool` representing logical **true**. It is the opposite of `false` |
| `type` | Defines an alias for an existing type |
| `unsafe` | Allows code or interfaces whose memory safety cannot be verified by the type system |
| `use` | Import or rename items from other crates or modules |
| `while` | Loop while a condition is upheld |

# Weak

| Keyword | Description |
|----------|-------------|
| `macro_rules` | Used to create custom macros |
| `union` | Used to declare a union and is only a keyword when used in a union declaration |
| `'static` | Used for the static lifetime and cannot be used as a generic lifetime parameter or loop label |

If you require more detailed information about any specific keyword you can find documentation and examples at the [Standard Library Documentation](https://doc.rust-lang.org/std/index.html#keywords) or just by asking.