Rust Tuple Struct Pattern

struct Color(u8, u8, u8);

let background = Color(25, 50, 75);

// Destructuring via the tuple struct pattern in a `let` binding
let Color(r, g, b) = background;

struct Status(u32, String);

let current_status = Status(404, String::from("Not Found"));

match current_status {
    // Matching a literal value in the first position, binding the second
    Status(200, msg) => println!("Success: {}", msg),
    Status(404, msg) => println!("Error: {}", msg),
    // Binding all positions
    Status(code, msg) => println!("Code {}: {}", code, msg),
}

struct Point3D(f64, f64, f64);

let point = Point3D(1.5, 2.0, 3.5);

// Ignoring a single field at a specific index
let Point3D(x, _, z) = point;

// Ignoring all fields after the first matched field
let Point3D(x, ..) = point;

// Ignoring all fields before the last matched field
let Point3D(.., z) = point;

struct Wrapper(Option<i32>, Result<bool, String>);

let data = Wrapper(Some(42), Ok(true));

match data {
    // Deeply destructuring the inner Option and Result enums
    Wrapper(Some(val), Ok(flag)) => {
        // `val` is bound to 42, `flag` is bound to true
    },
    Wrapper(None, Err(e)) => {
        // Handles the case where the first field is None and the second is an Error
    },
    Wrapper(..) => {
        // Catch-all for any other combination
    }
}

struct Velocity(f64, f64);

// The pattern `Velocity(vx, vy)` destructures the argument immediately
fn calculate_speed(Velocity(vx, vy): Velocity) -> f64 {
    (vx.powi(2) + vy.powi(2)).sqrt()
}