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.
```

| keyword | description                                                                  |
|---------|------------------------------------------------------------------------------|
| fn      | Define a function                                                            |
| return  | pass a value out of a function                                               |
| if      | Begin a conditional block                                                    |
| else    | Define an alternative path for code to follow if a condition is not met      |
| for     | Begin a loop                                                                 |
| in      | Devide the variable from the structure being looped over in a `for` statment |
| const   | Decalre a constent                                                           |
| let     | Declare a variable                                                           |
| mut     | Mark a variable as mutable                                                   |
```
Please also explain memory management in Rust and how lifetimes fit in to that, with examples.
Sure! Rust is unique in that it provides control over memory allocation and deallocation, while at the same time ensuring memory safety. It does this by using a system of ownership and borrowing, which is enforced at compile time by the Rust compiler.

In Rust, each value has a single owner at any given time, and when the owner goes out of scope, the value is dropped and its memory is deallocated. This prevents common memory issues like use-after-free and double-free errors.

However, in order to allow values to be used across different parts of the program, Rust allows for borrowing. Borrowing allows for temporary access to a value without taking ownership of it. In order to prevent invalid or unsafe references, Rust uses the concept of lifetimes to track the lifetime of a value and ensure that references are always valid.

For example, let's say we have a function that takes a reference to a string and returns the length of that string:
```rust
fn get_length(s: &str) -> usize {
    s.len()
}
```

In this function, `s` is a reference to a string. The lifetime of `s` is determined by its scope, which in this case is the function call. When the function returns, the reference `s` is no longer valid, but the memory it referred to is still owned by the original variable.

Here's an example of how to call this function:
```rust
fn main() {
    let s = String::from(Hello, world!);
    let len = get_length(&s);
    println!(Length of '{}' is {}., s, len);
}
```
In this example, we create a new `String` and pass a reference to it to `get_length()`. The reference is borrowed for the duration of the function call, and the function returns the length of the string. Finally, we print the length along with the original string.

I hope this helps! Let me know if you have any other questions.