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

SilentCanon

silentcanon

14 hours 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

a day 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 days 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

8 days 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

10 days 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

10 days 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

17 days 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

18 days 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

22 days 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

24 days 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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);
}

Derek Chen-Becker

dchenbecker

a month ago

374.54ms

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);
}

arilet

a month ago

382.01ms

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);
}

Y.

klllr

a month ago

407.77ms

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> (mut gift: T) where T: fmt::Display + 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)
    }
}
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;
    }
}
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);
}

jcorrie

a month ago

366.39ms

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);
}

BetkeJ

a month ago

341.46ms

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);
}

BetkeJ

a month ago

414.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 { // 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);
}

Bambalam

bambalamm

a month ago

367.95ms

87.14kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
    pub is_wrapped: bool,
}
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;
    }
}
pub struct ElvesGift {
    pub name: String,
    pub is_wrapped: bool,
}
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;
    }
}
pub struct ReindeerGift {
    pub name: String,
    pub is_wrapped: bool,
}
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;
    }
}
// 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>(mut gift: T) {
    println!("Preparing gift for {}", &gift);
    gift.wrap();
    println!("Gift wrapped for {}", &gift);
}
// 4. Implement the Gift trait to the gift structs
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
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,
    };
    // display_gift(&kids_gift);
    // display_gift(&elves_gift);
    // display_gift(&reindeer_gift);
    prepare_gift(kids_gift);
    prepare_gift(elves_gift);
    prepare_gift(reindeer_gift);
}

Sergei Chertkov

mamont

a month ago

345.35ms

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: 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);
}

ckab

ckab04

a month ago

356.34ms

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);
}

Francisco López

franlopezm

a month ago

372.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,
}
// 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);
}

Helene Semb

HelenSem723

a month ago

428.55ms

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);
}

Tengz Mao

MaoX-Yu

a month ago

393.57ms

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);
}

Saipranav Venkatakrishnan

Sai-Pra

a month ago

416.06ms

87.90kb

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 //
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>(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 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);
}

Morse

A1-exe

a month ago

338.21ms

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 //
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);
}

Mingzhe Yang

mei28

a month ago

344.96ms

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,
}
pub trait Gift {
    fn wrap(&mut self);
} // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: Gift + 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 Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
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 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);
}

Florian Gaudin-Delrieu

FlorianGD

a month ago

362.35ms

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);
}

sweet2honey

a month ago

362.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);
}

HSteffensen

a month ago

471.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 // 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);
}

Joseph Copenhaver

josephcopenhaver

a month ago

339.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 {
    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);
}

doroshtapgh

a month ago

386.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
}
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);
}

PangoSea

kapaseker

2 months ago

369.14ms

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,
}
pub trait Gift {
    fn wrap(&mut self);
} // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: Gift + 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 Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
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 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);
}

Ferdinand de Baecque

Ferdinanddb

2 months ago

348.48ms

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);
}

Sympatron GmbH

Sympatron

2 months ago

367.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);
}
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;
    }
}
    // 2. Finish the trait definition //
// 3. Update the function signature
pub fn prepare_gift<T: fmt::Display + Gift>(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 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);
}

Marius Gehrmann

MGehrmann

2 months ago

383.01ms

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 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);
}

kosay

sarub0b0

2 months ago

362.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,
}
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);
}

Rickard Jensen

rjensen

2 months ago

353.60ms

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);
}

Ljungg

2 months ago

336.43ms

87.14kb

use std::fmt;
//
// 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.
//
// 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);
}

Habu

habu1010

2 months ago

369.74ms

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);
}

ma3103yd-s

2 months ago

353.49ms

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>(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 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 ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for ElvesGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for &mut KidsGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for &mut ReindeerGift {
    fn wrap(&mut self) {
        self.is_wrapped = true;
    }
}
impl Gift for &mut ElvesGift {
    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);
}

Emmanuel Guefif

eguefif

2 months ago

384.61ms

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 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);
}

Ankit Kumar Jha

Ankit8848

2 months ago

409.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);
}

Kushneryk Pavel

KushnerykPavel

2 months ago

349.98ms

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);
}