Implementing Debug Trait for Structs

In Rust, the Debug trait allows you to format your types using the {:?} formatter, making it easier to inspect and debug your code. Instead of manually implementing the Debug trait for every struct, Rust provides the convenient #[derive(Debug)] attribute to automatically generate a Debug implementation.

For this challenge, you will work with structs that represent different types of data. Your task is to implement the Debug trait using the derive macro and demonstrate its functionality with sample structs.

Your Task

Define several structs representing various entities (e.g., Person, Point, Rectangle).
Derive the Debug trait for each struct using #[derive(Debug)].

Requirements

Use the #[derive(Debug)] attribute for all structs.
Define at least three structs, each with different fields and types.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

murdurn

7 hours ago

2.83ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

mwheeleraus

14 hours ago

2.74ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8,
}
#[derive(Debug)]
pub struct Point {
    pub x: f64,
    pub y: f64,
  
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: usize,
    pub height: usize,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Piotr Baranowski

piotrbar250

20 hours ago

3.15ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Eliettetheegeek

a day ago

2.81ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

PreppyMiguel

lusuo9

a day ago

2.72ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32
}
#[derive(Debug)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

khadre07

a day ago

3.45ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8,
}
#[derive(Debug)]
pub struct Point {
    pub x:f64,
    pub y: f64,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Álex Frías

alexwebdev05

a day ago

3.28ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i16,
    pub height: i16
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Hariom

om-secadvice

2 days ago

2.75ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Kourosh Mozafari

kmozafari

2 days ago

3.09ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

humeey4

2 days ago

2.64ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

poppyer9

4 days ago

2.86ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

DjukicDragan01

4 days ago

2.79ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

azmahflameheart

4 days ago

3.14ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Vendra000

4 days ago

3.29ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i8
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

emiludenz

5 days ago

3.53ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Egu0

egu0

5 days ago

2.90ms

81.28kb

#[derive(Debug)] // required by this formatting parameter
pub struct Person {
    pub name: String,
    pub age: u8,
}
pub struct Point {
    pub x: f64,
    pub y: f64,
}
use std::fmt;
impl fmt::Debug for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        //使用默认的结构体格式化方法 debug_struct 来输出
        f.debug_struct("Point")
            .field("x", &self.x)
            .field("y", &self.y)
            .finish()
        //Point { x: 5.0, y: -3.2 }
        //自定义格式化方法输出
        //write!(f, "Point [{} {}]", self.x, self.y) // Point [5 -3.2]
    }
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: usize,
    pub height: usize,
}

LawisChen

6 days ago

3.04ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Özgür

AyikOzgur

6 days ago

3.05ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {pub name :String, pub age: u32}
#[derive(Debug)]
pub struct Point {pub x: f32, pub y: f32}
#[derive(Debug)]
pub struct Rectangle {pub width: u32, pub height: u32}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Alexey Lisov

BaldiSlayer

6 days ago

3.05ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Marouan Boulahtouf

MBoulahtouf

6 days ago

3.01ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u16,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u16,
    pub height: u16,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

ffrie

7 days ago

3.54ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {pub name: String, pub age: i32,}
#[derive(Debug)]
pub struct Point {pub x: f32, pub y: f32,}
#[derive(Debug)]
pub struct Rectangle {pub width: i32, pub height: i32,}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Ramon Silva

rsilva1

8 days ago

3.15ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u16,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u16,
    pub height: u16,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

0xMindset

ijustbuilddifferentdude

8 days ago

22.79ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Anthony Young

A-Young-Git

9 days ago

2.96ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8,
}
#[derive(Debug)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Timmy

sha2dow4

9 days ago

3.76ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Snoweuph

snoweuph

10 days ago

3.68ms

81.28kb

#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: usize,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: usize,
    pub height: usize,
}

Jan-hjh

10 days ago

2.88ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

winter

winter-08

10 days ago

3.70ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

penmanglewood

10 days ago

2.85ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Jinjiang

10 days ago

3.38ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

vqk-2003

11 days ago

5.04ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

exeris

11 days ago

2.86ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

makinpaper

11 days ago

3.31ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

vivek

vivek-inavalli

11 days ago

2.67ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

vivek

vivek-inavalli

11 days ago

2.94ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Dan Wayne

danwayne-me

12 days ago

3.11ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Amit Patel

amitpatel-wstf

12 days ago

3.17ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name : String,
    pub age : u8
}
#[derive(Debug)]
pub struct Point {
    pub x : f32,
    pub y : f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width : u32,
    pub height : u32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Rishika Sharma

Rishika-dev

12 days ago

2.75ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32, 
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width:i32,
    pub height:i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

fasolyee

fasolyeedev

12 days ago

2.97ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name :String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x :f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width:i32,
    pub height:i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Alex

ravsii

13 days ago

2.84ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

batblerone

13 days ago

2.77ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

DebroyeAntoine

14 days ago

3.19ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u32
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

fawhizy

fawizzy

14 days ago

4.03ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u32
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: u32,
    pub height: u32
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Corwin Dong

taigua

15 days ago

3.20ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

saadziasheikh

15 days ago

2.90ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Sameer

shaiksameer1604

15 days ago

3.08ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Roman Lee

Leerv474

16 days ago

3.32ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Retroz

Fungichi

16 days ago

2.67ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

Pristressia

16 days ago

2.82ms

81.28kb

// 1. Complete the definitions of the structs Person, Point, and Rectangle.
// have a look at the function below `debug_example` to get the fields of the structs.
//
// 2. Make sure you implement the Debug trait for each struct. using the derive attribute.
#[derive(Debug)]
pub struct Person {
    pub name : String,
    pub age : i32,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}

gtakacse

17 days ago

3.58ms

81.28kb

#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u8,
}
#[derive(Debug)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}
#[derive(Debug)]
pub struct Rectangle {
    pub width: i32,
    pub height: i32,
}
// Example function
pub fn debug_example() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    println!("{:?}", person);
    let point = Point { x: 5.0, y: -3.2 };
    println!("{:?}", point);
    let rectangle = Rectangle {
        width: 10,
        height: 20,
    };
    println!("{:?}", rectangle);
}