Day 14: Gifts for Everyone

Santa glared at the terminal, baffled. “A simple println!! That’s all I needed! Why won’t it work?!” He tugged his beard, fuming. The elves had been cranking out code under his “motivational” leadership, but now even Santa’s Rust “expertise” was falling short.

Bernard, the Lead Elf, leaned over Santa’s shoulder, squinting at the code. “Wait… are those gifts for elves and reindeer too? Are you planning to give everyone presents this year?”

Santa slammed the laptop shut, his cheeks reddening. “It’s supposed to be a surprise! If Prancer finds out, she’ll livestream the announcement before the code even works. Now fix this, Bernard—discreetly.”

Bernard crossed his arms, smirking. “Santa, that’s ambitious. But this code is spaghetti. I’ll fix it—but you owe the elves an extra cocoa break.”

Santa growled. “Fine! Just fix it! And not a word to anyone until it’s done.”

Bernard chuckled, cracking his knuckles. “You got it, boss!”

Your Mission

If Bernard solves this problem, it will be likely that the elves and reindeer get gifts from Santa too, it'll be their lucky year, you just need to write a function so that Santa easily can log the gifts, the function should be able to take in either KidsGift, ElvesGift or ReindeerGift and print them out.

Make sure you update the signature of the display_gift function to accept any of the types.

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.

Use trait bounds to accept only those types that implement a specific trait.
Import the Display trait using use std::fmt::Display.
Implement the trait for each gift type.
In order for a type to be displayable, it needs to implement the Display trait.

Here is an example of a trait bound:

fn my_fn<T: fmt::Display>(arg: T) {
    println!("{}", arg);
}

Editor not available on Mobile!

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

Solutions

Mingzhe Yang

mei28

15 hours ago

341.26ms

87.17kb

use std::fmt::{Display, Formatter};
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Florian Gaudin-Delrieu

FlorianGD

15 hours ago

407.86ms

87.17kb

use std::fmt::Display;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: Display>(gift: &T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

sweet2honey

15 hours ago

372.90ms

87.17kb

use std::fmt::Display;
use std::fmt::Formatter;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> { write!(f, "{}", self.name) }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> { write!(f, "{}", self.name) }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> { write!(f, "{}", self.name) }
}
pub fn  display_gift<T: Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

HSteffensen

17 hours ago

383.56ms

87.17kb

use std::fmt::Display;
use std::fmt::Formatter;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> { write!(f, "{}", self.name) }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> { write!(f, "{}", self.name) }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> { write!(f, "{}", self.name) }
}
pub fn  display_gift<T: Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Joseph Copenhaver

josephcopenhaver

17 hours ago

411.47ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: impl fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

PangoSea

kapaseker

a day ago

363.29ms

87.17kb

use std::fmt::{Display, Formatter};
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Ferdinand de Baecque

Ferdinanddb

a day ago

349.38ms

86.67kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", format!("{}", self.name))
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", format!("{}", self.name))
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", format!("{}", self.name))
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Sympatron GmbH

Sympatron

a day ago

360.92ms

87.17kb

pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
// impl<'a> Into<&'a str> for &'a KidsGift {
//     fn into(self) -> &'a str {
//         &self.name
//     }
// }
// impl<'a> Into<&'a str> for &'a ElvesGift {
//     fn into(self) -> &'a str {
//         &self.name
//     }
// }
// impl<'a> Into<&'a str> for &'a ReindeerGift {
//     fn into(self) -> &'a str {
//         &self.name
//     }
// }
impl std::fmt::Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", &self.name)
    }
}
impl std::fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", &self.name)
    }
}
impl std::fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", &self.name)
    }
}
pub fn display_gift(gift: impl std::fmt::Display) {
    // let name: &str = gift.into();
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Marius Gehrmann

MGehrmann

a day ago

354.22ms

87.17kb


pub struct KidsGift {
    pub name: String,
}
impl std::fmt::Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl std::fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl std::fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: std::fmt::Display>(gift: &T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

kosay

sarub0b0

a day ago

399.16ms

87.17kb

pub struct KidsGift {
    pub name: String,
}
impl std::fmt::Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl std::fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl std::fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: std::fmt::Display>(gift: &T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Habu

habu1010

2 days ago

342.14ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        writeln!(f, "{}", self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        writeln!(f, "{}", self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        writeln!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

ma3103yd-s

2 days ago

362.98ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    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 fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", &self.name)
    }
}
pub fn display_gift(gift: impl fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

doroshtapgh

2 days ago

344.84ms

87.17kb

use std::fmt;
#[derive(Debug)]
pub struct KidsGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
#[derive(Debug)]
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
#[derive(Debug)]
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Ljungg

2 days ago

429.11ms

87.17kb

use std::fmt::{Display, Formatter, Result};
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Emmanuel Guefif

eguefif

2 days ago

336.18ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", 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 kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Ankit Kumar Jha

Ankit8848

2 days ago

339.00ms

87.17kb

use std::fmt::{Display, Formatter, Result};
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Kushneryk Pavel

KushnerykPavel

2 days ago

433.59ms

87.17kb


use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl std::fmt::Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl std::fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl std::fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Rickard Jensen

rjensen

2 days ago

415.70ms

87.17kb

use std::fmt::{Display};
pub struct KidsGift {
    pub name: String,
}
impl std::fmt::Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl std::fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl std::fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Rounak Sen

rony0000013

2 days ago

384.19ms

87.17kb

use std::fmt::Display;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

pagyeman

2 days ago

423.67ms

87.17kb

use std::fmt::Display;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Sukrit Amornpornwiwat

arm01846

3 days ago

411.04ms

87.17kb

use std::fmt::Display;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Tim Toebrock

titoeb

3 days ago

413.56ms

87.31kb

#[derive(Debug)]
pub struct KidsGift {
    pub name: String,
}
impl std::fmt::Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "{:?}", self)
    }
}
#[derive(Debug)]
pub struct ElvesGift {
    pub name: String,
}
impl std::fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "{:?}", self)
    }
}
#[derive(Debug)]
pub struct ReindeerGift {
    pub name: String,
}
impl std::fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "{:?}", self)
    }
}
pub fn display_gift(gift: &dyn std::fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

gmvar

3 days ago

337.09ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift(gift: impl fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Masayuki Sunahara

tamanishi

3 days ago

339.45ms

87.17kb

use std::fmt::{Display, Formatter, Result};
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift(gift: Unknown) {
pub fn display_gift<T: Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Nikita Smirnov

Nismirno

3 days ago

349.68ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: &dyn fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

gsspdev

3 days ago

351.93ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: impl fmt::Display<>) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

stanisgo

3 days ago

400.30ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: &T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

hafihaf123

3 days ago

368.27ms

87.17kb

use std::fmt::{Display, Formatter};
use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
        fmt.write_str(&self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
        fmt.write_str(&self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
        fmt.write_str(&self.name)
    }
}
pub fn display_gift<T: Display>(gift: T) {
    println!("{gift}");
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Burnus

3 days ago

340.71ms

87.17kb

use std::fmt::{Display, Formatter, Result};
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift<G: Display>(gift: &G) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

vaclav0411

3 days ago

445.42ms

87.17kb

use std::fmt::Display;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Joanne Muthoni

joanne-cmd

3 days ago

422.63ms

87.17kb

use std::fmt::Display;
use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Joanne Muthoni

joanne-cmd

3 days ago

360.00ms

87.17kb

use std::fmt::Display;
use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Felipe Ribeiro Saruhashi

felipesaruhashi

4 days ago

433.73ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

KLcpb

4 days ago

348.24ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

joshvon44

4 days ago

345.74ms

87.17kb

use std::fmt::Display;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

wishkus

4 days ago

344.17ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
     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 KidsGift {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Guilherme Cesário Strachan

strachan

4 days ago

366.67ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Guilherme Cesário Strachan

strachan

4 days ago

441.73ms

87.17kb

use std::fmt::Display;
use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Chris

chriswmann

5 days ago

369.14ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Chris

chriswmann

5 days ago

332.19ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Luis Linares

lulingar

5 days ago

368.07ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: fmt::Display>(gift: T) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Kanak Shilledar

kanakshilledar

5 days ago

326.31ms

87.17kb

use std::fmt::{Display, Formatter, Result};
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Stephan Lindner

Stephan-Lindner

5 days ago

362.66ms

87.17kb

use std::fmt::{Display, Formatter, Result};
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str(&self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Sergey Martynov

martynovs

5 days ago

338.76ms

87.17kb

pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
impl std::fmt::Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { f.write_str(&self.name) }
}
impl std::fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { f.write_str(&self.name) }
}
impl std::fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { f.write_str(&self.name) }
}
pub fn display_gift(gift: &impl std::fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Will LaBranche

wlabranche

5 days ago

367.42ms

87.25kb

use std::fmt::{Display, Formatter};
use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "Kid's Gift: {}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "Elf's Gift: {}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "Reindeer's Gift: {}", self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Richmond Steele

RedNapPanda

5 days ago

363.39ms

87.17kb

use std::fmt;
#[derive(Debug)]
pub struct KidsGift {
    pub name: String,
}
#[derive(Debug)]
pub struct ElvesGift {
    pub name: String,
}
#[derive(Debug)]
pub struct ReindeerGift {
    pub name: String,
}
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 display_gift(gift: impl fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Wendy Kong

wendko

5 days ago

344.88ms

87.17kb

use std::fmt::{self, Display};
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: impl Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Dominic

DominicD

5 days ago

333.27ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.name)
    }
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.name)
    }
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.name)
    }
}
pub fn display_gift(gift: impl fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

jsdm13

5 days ago

338.61ms

87.17kb

use std::fmt;
pub struct KidsGift {
    pub name: String,
}
impl fmt::Display for KidsGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift(gift: impl fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}

Aaron Seilis

seilis

5 days ago

391.54ms

87.17kb

use std::fmt::{Display, Formatter};
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
        write!(f, "{}", &self.name)
    }
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
        write!(f, "{}", &self.name)
    }
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
        write!(f, "{}", &self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
pub fn display_gift(gift: impl std::fmt::Display) {
    println!("{}", gift);
}
pub fn main() {
    let kids_gift = KidsGift {
        name: "toy car".to_string(),
    };
    let elves_gift = ElvesGift {
        name: "vertical monitor".to_string(),
    };
    let reindeer_gift = ReindeerGift {
        name: "carrot".to_string(),
    };
    display_gift(&kids_gift);
    display_gift(&elves_gift);
    display_gift(&reindeer_gift);
}