Intro to Rust

Daniel Mason

What is Rust

Systems Programming Language

Systems programming
Web Servers and Web Assembly
Embedded and IoT
AI and ML
Anything!

A Quick look

Hello World

 $ cargo new hello
     Created binary (application) `hello` package
$ cd hello
$ vi src/main.rs $ cargo new hello
     Created binary (application) `hello` package
$ cd hello
$ vi src/main.rs $ cargo new hello
     Created binary (application) `hello` package
$ cd hello
$ vi src/main.rs $ cargo new hello
     Created binary (application) `hello` package
$ cd hello
$ vi src/main.rs

 fn main() {
    println!("Hello, world!");
} fn main() {
    println!("Hello, world!");
} fn main() {
    println!("Hello, world!");
}

$ cargo run
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.95s
     Running `target/debug/hello`
Hello, world!

Lets start by creating a quick Hello World
We can use cargo (Rust's equivalent of Yarn) to create a new project, we'll call it hello
Cargo puts the project in a directory with the same name
Inside that we can see its already created a source file
And the source file already contains a hello world program
This is how a function is written in Rust, the main function is special as its the entry point to our program
Note: println! is not a Rust function but a macro... don't worry about it
I'm not going to go into the difference here but you're going to use println! a lot when you start and its worth calling out that its special
When we run the program, Rust will compile it first, then run it, so far so good

Strong Strict Types

 fn say_hello(to: &str) {
    println!("Hello, {}!", to);
}
 
fn main() {
    let name = "Beamery";
    say_hello(name);
} fn say_hello(to: &str) {
    println!("Hello, {}!", to);
}
 
fn main() {
    let name = "Beamery";
    say_hello(name);
} fn say_hello(to: &str) {
    println!("Hello, {}!", to);
}
 
fn main() {
    let name = "Beamery";
    say_hello(name);
}

$ cargo run
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/hello`
Hello, Beamery!

Compiler Errors

 fn say_hello(to: &str) {
    println!("Hello, {}!", to);
}
 
fn main() {
    let name = 100;
    say_hello(name);
} fn say_hello(to: &str) {
    println!("Hello, {}!", to);
}
 
fn main() {
    let name = 100;
    say_hello(name);
} fn say_hello(to: &str) {
    println!("Hello, {}!", to);
}
 
fn main() {
    let name = 100;
    say_hello(name);
}

 $ cargo run
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
error[E0308]: mismatched types
 --> src/main.rs:7:15
  |
7 |     say_hello(name);
  |     --------- ^^^^ expected `&str`, found integer
  |     |
  |     arguments to this function are incorrect
  |
note: function defined here
 --> src/main.rs:1:4
  |
1 | fn say_hello(to: &str) {
  |    ^^^^^^^^^ --------
 
For more information about this error, try `rustc --explain E0308`.
error: could not compile `hello` due to previous error $ cargo run
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
error[E0308]: mismatched types
 --> src/main.rs:7:15
  |
7 |     say_hello(name);
  |     --------- ^^^^ expected `&str`, found integer
  |     |
  |     arguments to this function are incorrect
  |
note: function defined here
 --> src/main.rs:1:4
  |
1 | fn say_hello(to: &str) {
  |    ^^^^^^^^^ --------
 
For more information about this error, try `rustc --explain E0308`.
error: could not compile `hello` due to previous error $ cargo run
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
error[E0308]: mismatched types
 --> src/main.rs:7:15
  |
7 |     say_hello(name);
  |     --------- ^^^^ expected `&str`, found integer
  |     |
  |     arguments to this function are incorrect
  |
note: function defined here
 --> src/main.rs:1:4
  |
1 | fn say_hello(to: &str) {
  |    ^^^^^^^^^ --------
 
For more information about this error, try `rustc --explain E0308`.
error: could not compile `hello` due to previous error

Complex Types

 struct Person {
    name: String,
    age: u8,
    favorite_animal: Animal
}
 
enum Animal {
    Cat,
    OrangeCat,
} struct Person {
    name: String,
    age: u8,
    favorite_animal: Animal
}
 
enum Animal {
    Cat,
    OrangeCat,
} struct Person {
    name: String,
    age: u8,
    favorite_animal: Animal
}
 
enum Animal {
    Cat,
    OrangeCat,
}

 let daniel = Person {
    name: "Daniel".to_string(),
    age: 40, //ish
    favorite_animal: Animal::Cat,
};

More complex types are available too, for example we have a struct
Structs are a bit like TypeScript interfaces
One thing you might notice is that the type for name is a String, not a "borrowed string slice"... don't worry about it
We use an unsigned 8bit integer for age because we don't expect people to live past 255
Finally we have this "Animal" type to represent the persons favourite animal
The Animal type is an enum. This is similar to enums in other languages where its a kind of "on of selection", however unlike many other languages, it's not a stand in for an integer, in fact, you can store data inside the enum variants
For now our two variants are Cat and Orange Cat as these are the only acceptable options for favourite animal
This is how we instantiate a struct, name, 40ish, fave animal
Note we need to turn the "borrowed string slice" into an actual string, don't worry about it

Generic Types

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

Documentation

 /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
} /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
}

 $ cargo doc --open
   Documenting hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.76s
     Opening /Users/Daniel.Mason/projects/hello/target/doc/hello/index.html

Testing

 /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_say_hello() {
        let greeting = say_hello("Beamery");
        assert_eq!(greeting, "Hello, Beamery!")
    }
} /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_say_hello() {
        let greeting = say_hello("Beamery");
        assert_eq!(greeting, "Hello, Beamery!")
    }
} /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_say_hello() {
        let greeting = say_hello("Beamery");
        assert_eq!(greeting, "Hello, Beamery!")
    }
} /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_say_hello() {
        let greeting = say_hello("Beamery");
        assert_eq!(greeting, "Hello, Beamery!")
    }
} /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_say_hello() {
        let greeting = say_hello("Beamery");
        assert_eq!(greeting, "Hello, Beamery!")
    }
} /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_say_hello() {
        let greeting = say_hello("Beamery");
        assert_eq!(greeting, "Hello, Beamery!")
    }
}

 $ cargo test
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
    Finished test [unoptimized + debuginfo] target(s) in 0.83s
     Running unittests src/lib.rs (target/debug/deps/hello-40d6e0ec3fbb5e8f)
 
running 1 test
test tests::test_say_hello ... ok
 
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
   Doc-tests hello
 
running 0 tests
 
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s $ cargo test
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
    Finished test [unoptimized + debuginfo] target(s) in 0.83s
     Running unittests src/lib.rs (target/debug/deps/hello-40d6e0ec3fbb5e8f)
 
running 1 test
test tests::test_say_hello ... ok
 
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
   Doc-tests hello
 
running 0 tests
 
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s $ cargo test
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
    Finished test [unoptimized + debuginfo] target(s) in 0.83s
     Running unittests src/lib.rs (target/debug/deps/hello-40d6e0ec3fbb5e8f)
 
running 1 test
test tests::test_say_hello ... ok
 
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
   Doc-tests hello
 
running 0 tests
 
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s $ cargo test
   Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
    Finished test [unoptimized + debuginfo] target(s) in 0.83s
     Running unittests src/lib.rs (target/debug/deps/hello-40d6e0ec3fbb5e8f)
 
running 1 test
test tests::test_say_hello ... ok
 
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
   Doc-tests hello
 
running 0 tests
 
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

 /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
///
/// ```
/// use hello::say_hello;
///
/// let greeting = say_hello("Beamery");
///
/// assert_eq!(greeting, "Hello, Beamery!")
/// ```
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
} /// Returns a string that greets someone passes as the `to` parameter
///
/// Use this function to increase politeness
///
/// ```
/// use hello::say_hello;
///
/// let greeting = say_hello("Beamery");
///
/// assert_eq!(greeting, "Hello, Beamery!")
/// ```
pub fn say_hello(to: &str) -> String {
    format!("Hello, {}!", to)
}

 running 0 tests
 
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
   Doc-tests hello
 
running 1 test
test src/lib.rs - say_hello (line 5) ... ok
 
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.27s running 0 tests
 
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
   Doc-tests hello
 
running 1 test
test src/lib.rs - say_hello (line 5) ... ok
 
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.27s running 0 tests
 
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
   Doc-tests hello
 
running 1 test
test src/lib.rs - say_hello (line 5) ... ok
 
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.27s running 0 tests
 
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
 
   Doc-tests hello
 
running 1 test
test src/lib.rs - say_hello (line 5) ... ok
 
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.27s

Pattern Matching

 fn meaning_of_life(are_you_sure: bool) -> Option<u32> {
    if are_you_sure {
        Some(42)
    } else {
        None
    }
} fn meaning_of_life(are_you_sure: bool) -> Option<u32> {
    if are_you_sure {
        Some(42)
    } else {
        None
    }
} fn meaning_of_life(are_you_sure: bool) -> Option<u32> {
    if are_you_sure {
        Some(42)
    } else {
        None
    }
} fn meaning_of_life(are_you_sure: bool) -> Option<u32> {
    if are_you_sure {
        Some(42)
    } else {
        None
    }
} fn meaning_of_life(are_you_sure: bool) -> Option<u32> {
    if are_you_sure {
        Some(42)
    } else {
        None
    }
}

 fn get_meaning() {
    match meaning_of_life(true) {
        Some(value) => println!("It is {}", value),
        None => println!("Who knows"),
    }
} fn get_meaning() {
    match meaning_of_life(true) {
        Some(value) => println!("It is {}", value),
        None => println!("Who knows"),
    }
} fn get_meaning() {
    match meaning_of_life(true) {
        Some(value) => println!("It is {}", value),
        None => println!("Who knows"),
    }
} fn get_meaning() {
    match meaning_of_life(true) {
        Some(value) => println!("It is {}", value),
        None => println!("Who knows"),
    }
} fn get_meaning() {
    match meaning_of_life(true) {
        Some(value) => println!("It is {}", value),
        None => println!("Who knows"),
    }
} fn get_meaning() {
    match meaning_of_life(true) {
        Some(value) => println!("It is {}", value),
        None => println!("Who knows"),
    }
} fn get_meaning() {
    match meaning_of_life(true) {
        Some(value) => println!("It is {}", value),
        None => println!("Who knows"),
    }
}

 fn get_meaning() {
    if let Some(value) = meaning_of_life(true) {
        println!("The meaning of life is {}", value);
        // ...
    }
} fn get_meaning() {
    if let Some(value) = meaning_of_life(true) {
        println!("The meaning of life is {}", value);
        // ...
    }
} fn get_meaning() {
    if let Some(value) = meaning_of_life(true) {
        println!("The meaning of life is {}", value);
        // ...
    }
} fn get_meaning() {
    if let Some(value) = meaning_of_life(true) {
        println!("The meaning of life is {}", value);
        // ...
    }
} fn get_meaning() {
    if let Some(value) = meaning_of_life(true) {
        println!("The meaning of life is {}", value);
        // ...
    }
} fn get_meaning() {
    if let Some(value) = meaning_of_life(true) {
        println!("The meaning of life is {}", value);
        // ...
    }
}

 fn get_meaning() {
    let Some(value) = meaning_of_life(true) else {
        return
    };
    println!("The meaning of life is {}", value);
    // ...
} fn get_meaning() {
    let Some(value) = meaning_of_life(true) else {
        return
    };
    println!("The meaning of life is {}", value);
    // ...
} fn get_meaning() {
    let Some(value) = meaning_of_life(true) else {
        return
    };
    println!("The meaning of life is {}", value);
    // ...
} fn get_meaning() {
    let Some(value) = meaning_of_life(true) else {
        return
    };
    println!("The meaning of life is {}", value);
    // ...
} fn get_meaning() {
    let Some(value) = meaning_of_life(true) else {
        return
    };
    println!("The meaning of life is {}", value);
    // ...
} fn get_meaning() {
    let Some(value) = meaning_of_life(true) else {
        return
    };
    println!("The meaning of life is {}", value);
    // ...
}

Error Handling

 struct MyError(String);
 
fn may_not_work() -> Result<String, MyError> {
    if thread_rng().gen_bool(0.5) {
        Ok("Whoop!".to_string())
    } else {
        Err(MyError("Ohps".to_string()))
    }
} struct MyError(String);
 
fn may_not_work() -> Result<String, MyError> {
    if thread_rng().gen_bool(0.5) {
        Ok("Whoop!".to_string())
    } else {
        Err(MyError("Ohps".to_string()))
    }
} struct MyError(String);
 
fn may_not_work() -> Result<String, MyError> {
    if thread_rng().gen_bool(0.5) {
        Ok("Whoop!".to_string())
    } else {
        Err(MyError("Ohps".to_string()))
    }
} struct MyError(String);
 
fn may_not_work() -> Result<String, MyError> {
    if thread_rng().gen_bool(0.5) {
        Ok("Whoop!".to_string())
    } else {
        Err(MyError("Ohps".to_string()))
    }
} struct MyError(String);
 
fn may_not_work() -> Result<String, MyError> {
    if thread_rng().gen_bool(0.5) {
        Ok("Whoop!".to_string())
    } else {
        Err(MyError("Ohps".to_string()))
    }
} struct MyError(String);
 
fn may_not_work() -> Result<String, MyError> {
    if thread_rng().gen_bool(0.5) {
        Ok("Whoop!".to_string())
    } else {
        Err(MyError("Ohps".to_string()))
    }
} struct MyError(String);
 
fn may_not_work() -> Result<String, MyError> {
    if thread_rng().gen_bool(0.5) {
        Ok("Whoop!".to_string())
    } else {
        Err(MyError("Ohps".to_string()))
    }
}

 fn show_work() -> Result<(), MyError> {
    match may_not_work() {
        Ok(work) => println!("{}", work),
        Err(err) => return Err(err),
    }
    Ok(())
} fn show_work() -> Result<(), MyError> {
    match may_not_work() {
        Ok(work) => println!("{}", work),
        Err(err) => return Err(err),
    }
    Ok(())
} fn show_work() -> Result<(), MyError> {
    match may_not_work() {
        Ok(work) => println!("{}", work),
        Err(err) => return Err(err),
    }
    Ok(())
} fn show_work() -> Result<(), MyError> {
    match may_not_work() {
        Ok(work) => println!("{}", work),
        Err(err) => return Err(err),
    }
    Ok(())
} fn show_work() -> Result<(), MyError> {
    match may_not_work() {
        Ok(work) => println!("{}", work),
        Err(err) => return Err(err),
    }
    Ok(())
} fn show_work() -> Result<(), MyError> {
    match may_not_work() {
        Ok(work) => println!("{}", work),
        Err(err) => return Err(err),
    }
    Ok(())
} fn show_work() -> Result<(), MyError> {
    match may_not_work() {
        Ok(work) => println!("{}", work),
        Err(err) => return Err(err),
    }
    Ok(())
}

 fn do_some_work() -> Result<(), MyError> {
    let work = may_not_work()?;
 
    println!("{}", work);
 
    Ok(())
} fn do_some_work() -> Result<(), MyError> {
    let work = may_not_work()?;
 
    println!("{}", work);
 
    Ok(())
} fn do_some_work() -> Result<(), MyError> {
    let work = may_not_work()?;
 
    println!("{}", work);
 
    Ok(())
} fn do_some_work() -> Result<(), MyError> {
    let work = may_not_work()?;
 
    println!("{}", work);
 
    Ok(())
} fn do_some_work() -> Result<(), MyError> {
    let work = may_not_work()?;
 
    println!("{}", work);
 
    Ok(())
}

From<T>

 struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
} struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
} struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
} struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
} struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
} struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
} struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
} struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
} struct MySimpleError(String);
 
enum MyComplexError {
    MySimpleError(MySimpleError),
    SomeOtherErrorType(/*...*/),
    YetAnotherErrorType(/*...*/),
}
 
impl From<MySimpleError> for MyComplexError {
    fn from(simple: MySimpleError) -> Self {
        MyComplexError::MySimpleError(simple)
    }
}

 fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
fn complex() -> Result<usize, MyComplexError> {
    let size = simple()?.len();
    todo!()
} fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
fn complex() -> Result<usize, MyComplexError> {
    let size = simple()?.len();
    todo!()
} fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
fn complex() -> Result<usize, MyComplexError> {
    let size = simple()?.len();
    todo!()
} fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
fn complex() -> Result<usize, MyComplexError> {
    let size = simple()?.len();
    todo!()
} fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
fn complex() -> Result<usize, MyComplexError> {
    let size = simple()?.len();
    todo!()
}

Async/Await

 async fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
async fn complex() -> Result<usize, MyComplexError> {
    let size = simple().await?.len();
    todo!()
} async fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
async fn complex() -> Result<usize, MyComplexError> {
    let size = simple().await?.len();
    todo!()
} async fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
async fn complex() -> Result<usize, MyComplexError> {
    let size = simple().await?.len();
    todo!()
} async fn simple() -> Result<String, MySimpleError> {
    todo!()
}
 
async fn complex() -> Result<usize, MyComplexError> {
    let size = simple().await?.len();
    todo!()
}

Intro to Rust

Before We Start

What is Rust

Systems Programming Language

What makes it stand out?

A Quick look

Hello World

Strong Strict Types

Compiler Errors

Primitive Types

Complex Types

Generic Types

I heard Rust is hard

Yeah... kinda

The spikes on the learning curve

Why won't I shut up about it

Documentation

Testing

Idioms

Pattern Matching

Error Handling

From<T>

Async/Await

Community

Getting Started

Rust Up

Rust Book

Rustlings

Thank You

Any Questions?

	$ cargo new hello
	Created binary (application) `hello` package
	$ cd hello
	$ vi src/main.rs

	fn say_hello(to: &str) {
	println!("Hello, {}!", to);
	}

	fn main() {
	let name = "Beamery";
	say_hello(name);
	}

	$ cargo run
	Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
	error[E0308]: mismatched types
	--> src/main.rs:7:15
	\|
	7 \| say_hello(name);
	\| --------- ^^^^ expected `&str`, found integer
	\| \|
	\| arguments to this function are incorrect
	\|
	note: function defined here
	--> src/main.rs:1:4
	\|
	1 \| fn say_hello(to: &str) {
	\| ^^^^^^^^^ --------

	For more information about this error, try `rustc --explain E0308`.
	error: could not compile `hello` due to previous error

	struct Person {
	name: String,
	age: u8,
	favorite_animal: Animal
	}

	enum Animal {
	Cat,
	OrangeCat,
	}

	let daniel = Person {
	name: "Daniel".to_string(),
	age: 40, //ish
	favorite_animal: Animal::Cat,
	};

	enum Option<T> {
	None,
	Some(T),
	}

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

	/// Returns a string that greets someone passes as the `to` parameter
	///
	/// Use this function to increase politeness
	pub fn say_hello(to: &str) -> String {
	format!("Hello, {}!", to)
	}

	$ cargo doc --open
	Documenting hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
	Finished dev [unoptimized + debuginfo] target(s) in 0.76s
	Opening /Users/Daniel.Mason/projects/hello/target/doc/hello/index.html

	$ cargo test
	Compiling hello v0.1.0 (/Users/Daniel.Mason/projects/hello)
	Finished test [unoptimized + debuginfo] target(s) in 0.83s
	Running unittests src/lib.rs (target/debug/deps/hello-40d6e0ec3fbb5e8f)

	running 1 test
	test tests::test_say_hello ... ok

	test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

	Doc-tests hello

	running 0 tests

	test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

	/// Returns a string that greets someone passes as the `to` parameter
	///
	/// Use this function to increase politeness
	///
	/// ```
	/// use hello::say_hello;
	///
	/// let greeting = say_hello("Beamery");
	///
	/// assert_eq!(greeting, "Hello, Beamery!")
	/// ```
	pub fn say_hello(to: &str) -> String {
	format!("Hello, {}!", to)
	}

	fn meaning_of_life(are_you_sure: bool) -> Option<u32> {
	if are_you_sure {
	Some(42)
	} else {
	None
	}
	}

	fn get_meaning() {
	match meaning_of_life(true) {
	Some(value) => println!("It is {}", value),
	None => println!("Who knows"),
	}
	}

	fn get_meaning() {
	if let Some(value) = meaning_of_life(true) {
	println!("The meaning of life is {}", value);
	// ...
	}
	}

	fn get_meaning() {
	let Some(value) = meaning_of_life(true) else {
	return
	};
	println!("The meaning of life is {}", value);
	// ...
	}

	struct MyError(String);

	fn may_not_work() -> Result<String, MyError> {
	if thread_rng().gen_bool(0.5) {
	Ok("Whoop!".to_string())
	} else {
	Err(MyError("Ohps".to_string()))
	}
	}

	fn show_work() -> Result<(), MyError> {
	match may_not_work() {
	Ok(work) => println!("{}", work),
	Err(err) => return Err(err),
	}
	Ok(())
	}

	fn do_some_work() -> Result<(), MyError> {
	let work = may_not_work()?;

	println!("{}", work);

	Ok(())
	}

	struct MySimpleError(String);

	enum MyComplexError {
	MySimpleError(MySimpleError),
	SomeOtherErrorType(/.../),
	YetAnotherErrorType(/.../),
	}

	impl From<MySimpleError> for MyComplexError {
	fn from(simple: MySimpleError) -> Self {
	MyComplexError::MySimpleError(simple)
	}
	}

	fn simple() -> Result<String, MySimpleError> {
	todo!()
	}

	fn complex() -> Result<usize, MyComplexError> {
	let size = simple()?.len();
	todo!()
	}

	async fn simple() -> Result<String, MySimpleError> {
	todo!()
	}

	async fn complex() -> Result<usize, MyComplexError> {
	let size = simple().await?.len();
	todo!()
	}