fn describe(error: &MyError) -> Cow<'static, str> {
    match error {
        MyError::OutOfMemory => "out of memory".into(),
        MyError::FileNotFound(ref path) => {
            format!("file not found: {}", path.display()).into()
        }
    }
}

fn insert(&mut self, key: K, value: V) // command
fn get(&self, key: &K) -> Option<&V> // query

fn create_struct<'a>() -> &'a str {
   let tmp = String::from("Hello, Rust!"); // data owned by the current function

   &tmp // compilation error: cannot return reference to temporary value
} // tmp is dropped here

struct Path<'a> { // specifies that the reference must live at least as long as the instance of the struct
    point_x: &'a i32, // struct cannot live longer than references it holds
    point_y: &'a i32,
}

struct Person {
    first_name: String,
    last_name: String,
}

struct Age(u32);

impl Age {
    fn new(age: u32) -> Option<Self> {
        if age >= 0 {
            Some(Self(age))
        } else {
            None
        }
    }
}

impl<W: Write> WriteHtml for W { ... } // extension trait for Write trait

impl IsBlank for str { // adds is_blank() method for String and &str
    fn is_blank(&self) -> bool {
        self.trim().is_empty()
    }
}

pub trait Clone {
    fn clone(&self) -> Self; // type of `x.clone()` is the same as the type of `x`
}

let json_data: &str = r#"
    {
        "name": "John Doe",
        "age": 30,
        "city": "New York",
        "is_student": false,
        "grades": [90, 85, 95]
    }
"#;

let formatted_string = format!("Hello, {}! You are {} years old.", name, age);
println!("{}", formatted_string);
let mut buffer = Vec::new();
writeln!(buffer, formatted_string); // write a formatted string to the buffer

trait Future {
    type Output;

    // never waits, returns immediately
    // piñata model: whack it with a poll until a value falls out
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

enum Poll<T> {
    Ready(T), // once a future has returned `Poll::Ready` should be never be polled again
    Pending,
}

fn do_something(n: &[String]) { // either a vector or an array
do_something(&a); // works on arrays
do_something(&v); // works on vectors

fn diverging_function() -> ! {
    loop {
        // This loop never exits, representing a function that diverges.
    }
}

#[test]
#[allow(unconditional_panic)]
#[should_panic(expected = "expected panic message")]
fn test_panicking_function_with_message() {
    panic!("expected panic message");
}

#[test]
#[should_panic]
fn test_panic_macro() {
    panic!("This is a panic message");
}

#[test]
#[should_panic]
fn test_unreachable_macro() {
    unreachable!("This code is unreachable");
}

[package]
name = "my_project"
version = "0.1.0"
edition = "2021" // rust edition represents different releases of the Rust programming language

[dependencies]
uuid = { version = "1.6.1", features = ["v4"] } // "1.6.1" is shortcut for "^1.6.1"

[build-dependencies] // used only during the build process (e.g., build scripts)

[dev-dependencies] // used only for testing and development

[[package]]
name = "uuid"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5e395fcf16a7a3d8127ec99782007af141946b4795001f876d54fb0d55978560"
dependencies = [
 "getrandom",
]

#[launch] // compiled to #[rocket::main]
fn rocket() -> _ { // compiled to async fn main() -> Result<(), rocket::Error>
    rocket::build() // compiled to rocket().launch().await;
}

#[get("/customers/<id>")]
async fn get_customer(id: String) -> Option<String> { ... } // if None - an error of 404 - Not Found is returned to the client

#[post("/hello", data = "<data>")] // data = "<param>", where param is an argument in the handler means that a handler expects body data
async fn create_customer(
    data: Json<CustomerApiInput> // data needs to implement `FromData<'_>`, Json<_> implements it
) -> Result<Json<CustomerApiOutput>, Custom<Json<ErrorApiOutput>>>  { ... }

rocket::build().mount(base_path, routes![get_customer, create_customer, ...]); // route needs to be mounted

let client = Client::tracked(rocket).unwrap(); // construct a Client using the Rocket instance
let req = client.get("/"); // Construct requests using the Client instance
let response = req.dispatch(); // Dispatch the request to retrieve the response

/// # Get all users
///
/// Returns all users in the system.
#[openapi(tag = "Users")]
#[get("/user")]
fn get_all_users() -> ... {

#[derive(Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "camelCase")]
struct User {
    /// A unique user identifier.
    user_id: u64,
    /// The current username of the user.
    username: String,
    #[schemars(example = "example_email")]
    email: Option<String>,
}

fn hashmap() -> &'static HashMap<u32, &'static str> {
    static HASHMAP: OnceLock<HashMap<u32, &str>> = OnceLock::new();
    HASHMAP.get_or_init(|| {
        let mut m = HashMap::new();
        m.insert(0, "foo");
        m.insert(1, "bar");
        m.insert(2, "baz");
        m
    })
}