Day 15: Santa's Generic Obsession

“Bernard! Did I tell you? Trait bounds are the greatest thing since reindeer! The Display trick you pulled yesterday? Pure genius. I’m hooked.”

Bernard shuffled in, already regretting showing Santa Display. “What now?”

“The gifts won’t wrap themselves! I need a function—generic, reusable, beautiful. We slap on some bounds, and boom, wrapping perfection!”

Bernard peeked at the screen. “Santa, you’ve got mutable and immutable borrows fighting each other. And what’s with this raw pointer?”

Santa grinned. “Bounds solve everything, Bernard! I’ll slap a Display here, a Debug there—easy!”

The IDE chimed angrily. “Cannot borrow self as mutable while also borrowed as immutable.”

Bernard sighed. “Santa, that’s the compiler telling you no.”

Santa glared at the screen. “Warm up the sled. I’m giving the borrow checker a piece of my mind.”

Your mission

What you need to do is simple, Santa has written a function prepare_gift, but it doesn't work quite yet. The function must accept anything that implements the Display and Gift trait. And the Gift trait must have a method wrap that mutates the is_wrapped field to true.

Here's what you gotta do:

Add the new field to the structs is_wrapped: bool.
Finish the Gift trait definition, add a method called wrap.
Implement the Gift trait for KidsGift, ElvesGift, and ReindeerGift. Using the wrap method, it should set is_wrapped to true.
Update the prepare_gift function signature to accept any type that implements the Display and Gift traits.

Hints

If you're stuck or need a starting point, here are some hints to help you along the way!

Click here to show the hints.

The Gift trait should have a method wrap that takes a mutable reference of self. e.g.
```
pub trait Gift {
    fn wrap(&mut self);
}
```

To make a function accept any type that implements multiple traits, you can use the + operator. e.g.

  fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
      // code remains the same
  }

Make sure the argument takes a mutable reference &mut T to be able to call the wrap method since wrap also mutates the struct.

Editor not available on Mobile!

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

Solutions

zeitnut

5 days ago

348.83ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
// Subtrait pattern - everything that implements Gift must also implement Display
pub trait Gift: fmt::Display {
    fn wrap(&mut self);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: Gift>(gift: &mut T) {
    println!("Preparing gift for {}", gift);
    gift.wrap();
    println!("Gift wrapped for {}", gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

hoslo

6 days ago

366.53ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
pub trait Gift {
    fn wrap(&mut self);
} // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

DFC-Siege

8 days ago

449.44ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
} // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

yuiidev

10 days ago

409.82ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

diucicd

18 days ago

390.36ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Pumkko

22 days ago

381.70ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift // 2. Finish the trait definition //
{
    fn wrap(&mut self);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Erik Hollembeak

futureperfect

22 days ago

397.41ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Erik Hollembeak

futureperfect

22 days ago

400.72ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

deo2407

a month ago

408.19ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
pub trait Gift { // 2. Finish the trait definition //
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

David Phillips

Zantier

a month ago

381.67ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
// 2. Finish the trait definition //
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Viwaswat Raj Singh

viwaswatraj

a month ago

351.86ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
// 2. Finish the trait definition //
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Nelly Whads

NellyWhads

a month ago

362.67ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
// 2. Finish the trait definition //
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Yash Rawat

Yash-Rawat-IIT-D

a month ago

378.44ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped : bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped : bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped : bool,
}
//2. Implement the Gift Trait definition and implementation on structs
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature - Need Mutable Access !
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift{
    fn wrap(&mut self) { self.is_wrapped = true }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift{
    fn wrap(&mut self) { self.is_wrapped = true }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift{
    fn wrap(&mut self) { self.is_wrapped = true }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

theodoorscholte

a month ago

397.93ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift { // 2. Finish the trait definition //
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Khalifa

e1ec30

a month ago

397.18ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
// 2. Finish the trait definition //
pub trait Gift {
    fn wrap(& mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Pedro Diaz

pdiaz

2 months ago

432.50ms

87.23kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
        println!("Wrapping kids gift: {}", self.name);
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
        println!("Wrapping elves gift: {}", self.name);
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
        println!("Wrapping reindeer gift: {}", self.name);
    }
}
pub fn prepare_gift<T: Gift + fmt::Display>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

SalazarTh

2 months ago

378.67ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift // 2. Finish the trait definition //
{
    fn wrap(&mut self) -> (); 
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) -> () {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift{
    fn wrap(&mut self) -> () {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift{
    fn wrap(&mut self) -> () {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

EchosinEchos

2 months ago

374.09ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
pub trait Gift{ // 2. Finish the trait definition //
    fn wrap(&mut self)->();
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift{
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift{
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift{
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

huanderer

2 months ago

406.87ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool 
}
pub trait Gift {
    fn is_wrapped_mut(&mut self) -> &mut bool; //generic implementation
    fn wrap(&mut self) -> () {
        *self.is_wrapped_mut() = true; //not &self, not Self. need to deref and call the function
                                       //to expose the trait. 
    }
}
               
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) { //the syntax is gift: &mut T not &mut gift: T
                                                            //
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn is_wrapped_mut(&mut self) -> &mut bool {
        &mut self.is_wrapped
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn is_wrapped_mut(&mut self) -> &mut bool {
        &mut self.is_wrapped
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn is_wrapped_mut(&mut self) -> &mut bool {
        &mut self.is_wrapped
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

mednson

Mednson

2 months ago

379.33ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
// 2. Finish the trait definition //
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift{
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift{
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift{
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Aurimas Kuniutis

auriku

3 months ago

396.68ms

87.14kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display>(gift: &mut T) 
where
T: Gift
{
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Andrew Fruge

andrewf78

3 months ago

372.62ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

mroslander

3 months ago

399.38ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
// pub fn prepare_gift<T: fmt::Display>(gift: T) {
//     println!("Preparing gift for {}", &gift);
//     gift.wrap();
//     println!("Gift wrapped for {}", &gift);
// }
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self){
        self.is_wrapped = true;
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Cole LaCount

in-situ-clacount

3 months ago

448.97ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Hung Dinh

nhdinh

3 months ago

458.31ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

lugtester

3 months ago

421.79ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
pub trait Gift {
    fn wrap(&mut self) {} 
} // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    } 
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    } 
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    } 
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

dioponzio

3 months ago

389.07ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped : bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped : bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped : bool,
}
pub trait Gift {        // 2. Finish the trait definition //
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift{
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift{
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift{
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Ahmet Özcan

ahmetoozcan

3 months ago

375.17ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 2. Finish the trait definition //
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Skippy

SkippyoftheWired

4 months ago

367.27ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift // 2. Finish the trait definition //
{
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

AtlasVakyrie

4 months ago

346.51ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
pub trait Gift {
    fn wrap(&mut self);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Leif Hadsell

Booom775

4 months ago

442.68ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
} // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Harsha Aswath

raharsha

4 months ago

369.17ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift  {
    fn wrap(&mut self);
}
impl Gift for &mut KidsGift{
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for &mut ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for &mut ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for KidsGift{
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

SilentCanon

silentcanon

4 months ago

418.44ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Kishan Patel

KishanPatel4273

4 months ago

363.51ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift // 2. Finish the trait definition // 
{
    fn wrap(&mut self);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

FredoPo

4 months ago

455.90ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
// 2. Finish the trait definition //
pub trait Gift{
    fn wrap(&mut self);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift{
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift{
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift{
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Yi Hao

leongyihao

4 months ago

385.47ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
	pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
	pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
	pub is_wrapped: bool
}
pub trait Gift {
	fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
impl Gift for KidsGift {
	fn wrap(&mut self) {
		self.is_wrapped = true
	}
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
	fn wrap(&mut self) {
		self.is_wrapped = true
	}
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
	fn wrap(&mut self) {
		self.is_wrapped = true
	}
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Christopher Nielson

c-nielson

4 months ago

352.42ms

87.14kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T>(gift: &mut T) where T: Gift + fmt::Display{
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

codervijo

4 months ago

350.22ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Erik Werner

rikner

4 months ago

470.25ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub is_wrapped: bool,
    pub name: String,
}
pub struct ElvesGift {
    pub is_wrapped: bool,
    pub name: String,
}
pub struct ReindeerGift {
    pub is_wrapped: bool,
    pub name: String,
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: Gift + fmt::Display>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Paweł Stawicki

amorfis

4 months ago

357.15ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
pub trait Gift {// 2. Finish the trait definition // 
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift:&mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

adli daffa

addffa

5 months ago

365.29ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift { // 2. Finish the trait definition //
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Leandro Abreu

leandronowras

5 months ago

346.18ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
} // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Ido Barkan

barkanido

5 months ago

358.20ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
} // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Duncan Macharia

Devdannetworks

5 months ago

354.07ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
     fn wrap (&mut self);
}
impl Gift for KidsGift {
    fn wrap (&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap (&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap (&mut self){
        self.is_wrapped = true;
    }
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Jonathan

tato123

5 months ago

372.95ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
// 2. Finish the trait definition // 
pub trait Gift {
    fn wrap(&mut self);
} 
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

Omar Saber Talaat Abdelrahman

omar-s-ta

5 months ago

386.68ms

87.14kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = !self.is_wrapped
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = !self.is_wrapped
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = !self.is_wrapped
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

aey4

5 months ago

362.92ms

87.90kb

use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
#[derive(Debug)]
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
#[derive(Debug)]
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
#[derive(Debug)]
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}// 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: Gift + std::fmt::Display>(mut gift: T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift{
    fn wrap(&mut self) -> () {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift{
    fn wrap(&mut self) -> () {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift{
    fn wrap(&mut self) -> () {
        self.is_wrapped = true;
    }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(kids_gift);
    prepare_gift(elves_gift);
    prepare_gift(reindeer_gift);
}

Job Matheka

jobm

5 months ago

353.72ms

87.14kb

use std::fmt::{Debug, Display, Formatter, Result};
// 1. Add the `is_wrapped` field to the gift structs
#[derive(Debug)]
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
#[derive(Debug)]
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
#[derive(Debug)]
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
// 2. Finish the trait definition //
pub trait Gift {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift<T: Gift + Display + Debug>(mut gift: T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true
    }
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(kids_gift);
    prepare_gift(elves_gift);
    prepare_gift(reindeer_gift);
}

Antoine Plard

tylp

5 months ago

466.33ms

87.14kb

use std::fmt;
use std::fmt::Display;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool
}
// 2. Finish the trait definition //
pub trait Gift: Display {
    fn wrap(&mut self);
}
// 3. Update the function signature
pub fn prepare_gift(gift: &mut impl Gift) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl Gift for KidsGift {
    fn wrap(&mut self) { self.is_wrapped = true; }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) { self.is_wrapped = true; }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) { self.is_wrapped = true; }
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}

isaaclv

5 months ago

357.81ms

87.14kb


use std::fmt;
// 1. Add the `is_wrapped` field to the gift structs
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
pub trait Gift {
    fn wrap(&mut self);
}// 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(gift: &mut T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
pub fn main() {
    let mut kids_gift = KidsGift {
        name: "toy car".to_string(),
        is_wrapped: false,
    };
    let mut elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
        is_wrapped: false,
    };
    let mut reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
        is_wrapped: false,
    };
    prepare_gift(&mut kids_gift);
    prepare_gift(&mut elves_gift);
    prepare_gift(&mut reindeer_gift);
}