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

SilentCanon

silentcanon

15 hours ago

479.89ms

87.17kb

use std::fmt::Display;
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 std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
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);
}

Kishan Patel

KishanPatel4273

a day ago

392.77ms

87.17kb

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

FredoPo

4 days ago

392.13ms

87.17kb

use std::fmt::Display;
pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
pub fn display_gift(gift: &impl Display) {
    println!("{}", gift);
}
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 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);
}

Yi Hao

leongyihao

8 days ago

343.05ms

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

Christopher Nielson

c-nielson

10 days ago

367.67ms

87.24kb

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, "Kids gift: {}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Elves gift: {}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Reindeer gift: {}", 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);
}

codervijo

10 days ago

366.16ms

87.25kb

use std::fmt::Display;
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, "Gift for Kid {}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Gift for Elf {}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Gift for Reindeer {}", self.name)
    }
}
pub fn display_gift<T>(gift: T)
where T: 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);
}

Erik Werner

rikner

17 days ago

352.88ms

87.25kb

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, "KidsGift for {}", self.name)
    }
}
pub struct ElvesGift {
    pub name: String,
}
impl fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "ElvesGift for {}", self.name)
    }
}
pub struct ReindeerGift {
    pub name: String,
}
impl fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "ReindeerGift for {}", 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);
}

adli daffa

addffa

22 days ago

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

Leandro Abreu

leandronowras

24 days ago

355.82ms

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

Ido Barkan

barkanido

a month ago

468.28ms

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

Duncan Macharia

Devdannetworks

a month ago

357.57ms

87.24kb

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, "Kids gift: {}", self.name)
    } 
}
impl fmt::Display for ElvesGift {
    fn fmt (&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Elves gift: {}", self.name)
    } 
}
impl fmt::Display for ReindeerGift {
    fn fmt (&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Reinder gift: {}", self.name)
    } 
}
pub enum GitfType {
    KidsGift,
    ElvesGift,
    ReindeerGift,
}
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);
}

Jonathan

tato123

a month ago

384.50ms

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

Omar Saber Talaat Abdelrahman

omar-s-ta

a month ago

338.73ms

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

aey4

a month ago

364.37ms

87.17kb

use std::fmt::Display;
#[derive(Debug)]
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift{
    fn fmt(&self, f:&mut std::fmt::Formatter) -> Result<(), std::fmt::Error>{
        write!(f,"{}",self.name)
    }
}
#[derive(Debug)]
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift{
    fn fmt(&self, f:&mut std::fmt::Formatter) -> Result<(), std::fmt::Error>{
        write!(f,"{}",self.name)
    }
}
#[derive(Debug)]
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift{
    fn fmt(&self, f:&mut std::fmt::Formatter) -> Result<(), std::fmt::Error>{
        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);
}

aey4

a month ago

355.30ms

87.17kb

use std::fmt::Display;
#[derive(Debug)]
pub struct KidsGift {
    pub name: String,
}
impl Display for KidsGift{
    fn fmt(&self, f:&mut std::fmt::Formatter) -> Result<(), std::fmt::Error>{
        write!(f,"{}",self.name)
    }
}
#[derive(Debug)]
pub struct ElvesGift {
    pub name: String,
}
impl Display for ElvesGift{
    fn fmt(&self, f:&mut std::fmt::Formatter) -> Result<(), std::fmt::Error>{
        write!(f,"{}",self.name)
    }
}
#[derive(Debug)]
pub struct ReindeerGift {
    pub name: String,
}
impl Display for ReindeerGift{
    fn fmt(&self, f:&mut std::fmt::Formatter) -> Result<(), std::fmt::Error>{
        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);
}

Job Matheka

jobm

a month ago

356.17ms

87.25kb

use std::fmt::Display;
#[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 Display for KidsGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ReindeerGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
impl Display for ElvesGift {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}
pub fn display_gift<T: std::fmt::Display + std::fmt::Debug>(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);
}

KamiTrades

kamixbt

a month ago

362.03ms

87.17kb

use std::fmt::{Display};
use std::fmt;
#[derive(Debug)]
pub struct KidsGift {
    pub name: String,
}
impl 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 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 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);
}

Antoine Plard

tylp

a month ago

353.97ms

87.17kb

use std::fmt::{Display};
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 Display for KidsGift {
    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)
    }
}
impl Display for ElvesGift {
    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);
}

isaaclv

a month ago

380.84ms

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

Derek Chen-Becker

dchenbecker

a month ago

366.99ms

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)
    }
}
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(gift: &dyn 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);
}

arilet

a month ago

370.26ms

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

Y.

klllr

a month ago

344.14ms

87.17kb

pub struct KidsGift {
    pub name: String,
}
pub struct ElvesGift {
    pub name: String,
}
pub struct ReindeerGift {
    pub name: String,
}
pub struct Gift <'a> {
    pub name: &'a String,
}
impl <'a> From<&'a KidsGift> for Gift <'a> {
    fn from (i: &'a KidsGift) -> Self {
        Self { name: &i.name }
    }
}
impl <'a> From<&'a ElvesGift> for Gift <'a> {
    fn from (i: &'a ElvesGift) -> Self {
        Self { name: &i.name }
    }
}
impl <'a> From<&'a ReindeerGift> for Gift <'a> {
    fn from (i: &'a ReindeerGift) -> Self {
        Self { name: &i.name }
    }
}
impl <'a> std::fmt::Display for Gift <'a> {
    fn fmt (&self, b: &mut std::fmt::Formatter <'_>) -> std::fmt::Result {
        write!(b, "{}", self.name)
    }
}
impl std::fmt::Display for KidsGift {
    fn fmt (&self, b: &mut std::fmt::Formatter <'_>) -> std::fmt::Result {
        write!(b, "{}", self.name)
    }
}
impl std::fmt::Display for ElvesGift {
    fn fmt (&self, b: &mut std::fmt::Formatter <'_>) -> std::fmt::Result {
        write!(b, "{}", self.name)
    }
}
impl std::fmt::Display for ReindeerGift {
    fn fmt (&self, b: &mut std::fmt::Formatter <'_>) -> std::fmt::Result {
        write!(b, "{}", self.name)
    }
}
pub fn display_gift <'a> (gift: impl Into<Gift<'a>>) {
    let gift = 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);
}

jcorrie

a month ago

442.98ms

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

Bambalam

bambalamm

a month ago

377.67ms

87.17kb

// use std::fmt::{Display, Result, Error, Formatter};
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);
}

Sergei Chertkov

mamont

a month ago

335.84ms

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

Sergei Chertkov

mamont

a month ago

404.54ms

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

ckab

ckab04

a month ago

342.25ms

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

Francisco López

franlopezm

a month ago

352.44ms

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

Tengz Mao

MaoX-Yu

a month ago

340.23ms

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

Saipranav Venkatakrishnan

Sai-Pra

a month ago

368.06ms

87.17kb

use std::fmt;
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 fmt::Formatter) -> fmt::Result {
        write!(f, "{}", &self.name)
    }
}
impl std::fmt::Display for ElvesGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", &self.name)
    }
}
impl std::fmt::Display for ReindeerGift {
    fn fmt(&self, f: &mut fmt::Formatter) -> 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);
}

Helene Semb

HelenSem723

a month ago

447.97ms

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

Mingzhe Yang

mei28

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

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

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

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

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

2 months 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

2 months 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

2 months 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

2 months 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

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