Day 18: Sleigh builder pattern

The elves were huddled at a desk, deep in debate over their Neovim setups.

“I finally nailed my init.lua,” said Sparky. “Switched to bspwm, too. Total game-changer.”

“Pfft,” Tinker scoffed. “Real pros stick to Vimscript. You don’t need all those plugins.”

Jingle sipped his eggnog. “I wrote a whole game in Vim once. Problem? Couldn’t press two keys at the same time. Now it’s turn-based.”

Before they could laugh, the door slammed open. Santa stormed in once again. “Do I pay you to yap about text editors?”

The elves froze as Santa tossed a crumpled piece of code onto the table. “The sleigh builder is completely broken! I just tried to build a sleigh, and it’s missing half the parts. Magical enhancements? Gone. Gift capacity? Zero. Someone explain this!”

Sparky glanced at the code and gulped. “This… uh… looks like something from that old project nobody touched.”

“Exactly!” Santa growled. “And now it’s ruining everything. We’re rewriting this in Rust. Get to work, before I replace you all with AI!”

Your Mission

To help Santa build his new sleigh easily, we need to create him a SleighBuilder that can build and return Sleigh instances.

The SleighBuilder should have:

An associated function new that creates a new SleighBuilder instance.
red, reindeer-powered, 100, and false are the default values for the sleigh.
A method named color that takes a &str and sets the color of the sleigh.
A method named engine that takes a &str and sets the engine of the sleigh.
A method named gift_capacity that accepts a u32 and sets the gift capacity of the sleigh.
A method named magical_enhancements that sets the magical enhancements of the sleigh.
A final method that is going to return a Sleigh instance called build.

Make sure that each method takes ownership of the SleighBuilder instance and returns it after mutation.

Have a look at the end of the file to see how Santa wants to use this API.

Hints

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

Click here to show hints.

Store the settings in the SleighBuilder struct and return a Sleigh instance when the build method is called.

Editor not available on Mobile!

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

Solutions

Joseph Copenhaver

josephcopenhaver

10 hours ago

3.21ms

87.39kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> SleighBuilder {
        let color = "red".to_string();
        let engine = "reindeer-powered".to_string();
        let gift_capacity = 100;
        let magical_enhancements = false;
        SleighBuilder{
            color,
            engine,
            gift_capacity,
            magical_enhancements,
        }
    }
    pub fn color(mut self, v: &str) -> Self {
        self.color = v.to_owned();
        self
    }
    pub fn engine(mut self, v: &str) -> Self {
        self.engine = v.to_owned();
        self
    }
    pub fn gift_capacity(mut self, v: u32) -> Self {
        self.gift_capacity = v;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        Sleigh{
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Ferdinand de Baecque

Ferdinanddb

10 hours ago

4.27ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        return self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        return self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        return self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        return self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Morse

A1-exe

12 hours ago

3.63ms

87.39kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: String::from("red"),
            engine: String::from("reindeer-powered"),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn build(&self) -> Sleigh {
        Sleigh {
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, cap: u32) -> Self {
        self.gift_capacity = cap;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Rickard Jensen

rjensen

13 hours ago

3.23ms

87.97kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        SleighBuilder {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(self, color: &str) -> Self {
        Self { color: color.into(), ..self }
    }
    pub fn engine(self, engine: &str) -> Self {
        Self { engine: engine.into(), ..self }
    }
    pub fn gift_capacity(self, gift_capacity: u32) -> Self {
        Self { gift_capacity: gift_capacity.into(), ..self }
    }
    pub fn magical_enhancements(self) -> Self {
        Self { magical_enhancements: true, ..self }
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Florian Gaudin-Delrieu

FlorianGD

14 hours ago

3.70ms

87.97kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        SleighBuilder::default()
    }
    pub fn color(mut self, color: &str) -> Self{
        self.color = color.to_string();
        return self
    }
    pub fn engine(mut self, engine: &str) -> Self{
        self.engine = engine.to_string();
        return self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        return self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        return self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
impl Default for SleighBuilder {
    fn default() -> Self {
        SleighBuilder {
            color: "red".to_string(), 
            engine: "reindeer-powered".to_string(), 
            gift_capacity: 100, 
            magical_enhancements: false,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Mingzhe Yang

mei28

15 hours ago

3.16ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn gift_capacity(self, capacity: u32) -> Self {
        Self {
            gift_capacity: capacity,
            ..self
        }
    }
    pub fn magical_enhancements(self) -> Self {
        Self {
            magical_enhancements: true,
            ..self
        }
    }
    pub fn color(self, color: &str) -> Self {
        Self {
            color: color.to_string(),
            ..self
        }
    }
    pub fn engine(self, engine: &str) -> Self {
        Self {
            engine: engine.to_string(),
            ..self
        }
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

sweet2honey

15 hours ago

4.16ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn gift_capacity(self, capacity: u32) -> Self {
        Self {
            gift_capacity: capacity,
            ..self
        }
    }
    pub fn magical_enhancements(self) -> Self {
        Self {
            magical_enhancements: true,
            ..self
        }
    }
    pub fn color(self, color: &str) -> Self {
        Self {
            color: color.to_string(),
            ..self
        }
    }
    pub fn engine(self, engine: &str) -> Self {
        Self {
            engine: engine.to_string(),
            ..self
        }
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

PangoSea

kapaseker

21 hours ago

4.36ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn gift_capacity(self, capacity: u32) -> Self {
        Self {
            gift_capacity: capacity,
            ..self
        }
    }
    pub fn magical_enhancements(self) -> Self {
        Self {
            magical_enhancements: true,
            ..self
        }
    }
    pub fn color(self, color: &str) -> Self {
        Self {
            color: color.to_string(),
            ..self
        }
    }
    pub fn engine(self, engine: &str) -> Self {
        Self {
            engine: engine.to_string(),
            ..self
        }
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

kosay

sarub0b0

a day ago

3.18ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool
}
impl SleighBuilder {
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, capacity: u32) -> Self {
        self.gift_capacity = capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Ljungg

a day ago

3.44ms

87.98kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    pub sleigh: Sleigh,
}
impl SleighBuilder {
    pub fn new() -> Self {
        SleighBuilder {
            sleigh: Sleigh {
                color: "red".to_string(),
                engine: "reindeer-powered".to_string(),
                gift_capacity: 100,
                magical_enhancements: false,
            },
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.sleigh.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.sleigh.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.sleigh.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        self.sleigh
    }
    // Your code here...
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Marius Gehrmann

MGehrmann

a day ago

3.58ms

87.98kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    // just return an instance of the Sleigh struct
    pub sleigh: Sleigh,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() ->Self {
        SleighBuilder {
            sleigh : Sleigh {
                color: "red".to_string(),
                engine: "reindeer-powered".to_string(),
                gift_capacity: 100,
                magical_enhancements: false,
            } 
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.sleigh.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.sleigh.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, capacity:u32) -> Self {
        self.sleigh.gift_capacity = capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh { 
        self.sleigh
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Aaron

aaron-otis

a day ago

3.36ms

87.97kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".into(),
            engine: "reindeer-powered".into(),
            gift_capacity: 100,
            magical_enhancements: false
        }
    }
    pub fn color(self, color: &str) -> Self {
        Self { color: color.into(), ..self }
    }
    pub fn engine(self, engine: &str) -> Self {
        Self { engine: engine.into(), ..self }
    }
    pub fn gift_capacity(self, capacity: u32) -> Self {
        Self { gift_capacity: capacity, ..self }
    }
    
    pub fn magical_enhancements(self) -> Self {
        Self { magical_enhancements: true, ..self}
    }
    
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Kushneryk Pavel

KushnerykPavel

a day ago

3.38ms

87.38kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() ->  SleighBuilder {
        SleighBuilder{
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) ->  SleighBuilder {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> SleighBuilder {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) ->  SleighBuilder {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> SleighBuilder {
        self.magical_enhancements = true;
        self
    }
    pub fn build( self) -> Sleigh {
        Sleigh{
            color: self.color.to_string(),
            engine: self.engine.to_string(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Kushneryk Pavel

KushnerykPavel

a day ago

3.61ms

87.38kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() ->  SleighBuilder {
        SleighBuilder{
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) ->  SleighBuilder {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> SleighBuilder {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) ->  SleighBuilder {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> SleighBuilder {
        self.magical_enhancements = true;
        self
    }
    pub fn build( self) -> Sleigh {
        Sleigh{
            color: self.color.to_string(),
            engine: self.engine.to_string(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

The Scooby

thescooby

a day ago

3.19ms

87.39kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    b_color: String,
    b_engine: String,
    b_gift_capacity: u32,
    b_magical_enhancements: bool,
}
impl SleighBuilder {
   pub fn new() -> SleighBuilder{
        SleighBuilder {
            b_color : "red".to_string(),
            b_engine : "reindeer-powered".to_string(),
            b_gift_capacity : 100,
            b_magical_enhancements : false,
        }
    }
   pub fn color(mut self, col: &str) -> SleighBuilder
    {
        self.b_color = col.to_string();
        self
    }
   pub fn engine(mut self, engine: &str ) -> SleighBuilder
    {
        self.b_engine = engine.to_string();
        self
    }
   pub fn gift_capacity(mut self, capa: u32 ) -> SleighBuilder
    {
        self.b_gift_capacity = capa;
        self
    }
   pub fn magical_enhancements(mut self) -> SleighBuilder
    {
        self.b_magical_enhancements = true;
        self
    }
   pub  fn build(&self) -> Sleigh {
        Sleigh {
            color: self.b_color.clone(),
            engine: self.b_engine.clone(),
            gift_capacity: self.b_gift_capacity,
            magical_enhancements: self.b_magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Habu

habu1010

a day ago

3.58ms

87.38kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: String::from("red"),
            engine: String::from("reindeer-powered"),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = String::from(color);
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = String::from(engine);
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        Sleigh {
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Emmanuel Guefif

eguefif

a day ago

3.32ms

87.39kb

#[derive(Default)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone, Default)]
pub struct SleighBuilder {
    bcolor: String,
    bengine: String,
    bgift_capacity: u32,
    bmagical_enhancements: bool,
}
impl SleighBuilder {
    pub fn new() -> SleighBuilder {
        SleighBuilder {
            bcolor: String::from("red"),
            bengine: "reindeer-powered".to_string(),
            bgift_capacity: 100,
            bmagical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> SleighBuilder {
        self.bcolor = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> SleighBuilder {
        self.bengine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, capacity: u32) -> SleighBuilder {
        self.bgift_capacity = capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> SleighBuilder {
        self.bmagical_enhancements = true;
        self
    }
   pub  fn build(&self) -> Sleigh {
        Sleigh {
            color: self.bcolor.clone(),
            engine: self.bengine.clone(),
            gift_capacity: self.bgift_capacity,
            magical_enhancements: self.bmagical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Stefano Cianciulli

CianciuStyles

2 days ago

3.46ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Kyaw Kyaw Khaing

Kyawkhaing444

2 days ago

4.11ms

87.98kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    sleigh: Sleigh
}
impl SleighBuilder {
    pub fn new() -> Self {
        Self {
            sleigh: Sleigh {
                color: "red".to_string(),
                engine: "reindeer-powered".to_string(),
                gift_capacity: 100,
                magical_enhancements: false
            }
        }
    }
    pub fn color(mut self, c: &str) -> Self {
        self.sleigh.color = c.to_string();
        self
    }
    pub fn engine(mut self, e: &str) -> Self {
        self.sleigh.engine = e.to_string();
        self
    }
    pub fn gift_capacity(mut self, g: u32) -> Self {
        self.sleigh.gift_capacity = g;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        self.sleigh
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

AliShenanigans

2 days ago

3.65ms

87.98kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    // just return an instance of the Sleigh struct
    pub sleigh: Sleigh,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() ->Self {
        SleighBuilder {
            sleigh : Sleigh {
                color: "red".to_string(),
                engine: "reindeer-powered".to_string(),
                gift_capacity: 100,
                magical_enhancements: false,
            } 
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.sleigh.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.sleigh.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, capacity:u32) -> Self {
        self.sleigh.gift_capacity = capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh { 
        self.sleigh
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Ankit Kumar Jha

Ankit8848

2 days ago

3.28ms

87.38kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    pub sleigh: Sleigh,
}
impl SleighBuilder {
    pub fn new() -> Self {
        Self { sleigh : Sleigh {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false
        }}
    }
    pub fn color(mut self, s: &str) -> Self {
        self.sleigh.color = s.to_string();
        self
    }
    
    pub fn engine(mut self, s: &str) -> Self {
        self.sleigh.engine = s.to_string();
        self
    }
    pub fn gift_capacity(mut self, s: u32) -> Self {
        self.sleigh.gift_capacity = s;
        self
    }
    
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        self.sleigh.clone()
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Wendy Kong

wendko

2 days ago

3.18ms

87.38kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    pub sleigh: Sleigh,
}
impl SleighBuilder {
    pub fn new() -> Self {
        Self { sleigh : Sleigh {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false
        }}
    }
    pub fn color(mut self, s: &str) -> Self {
        self.sleigh.color = s.to_string();
        self
    }
    
    pub fn engine(mut self, s: &str) -> Self {
        self.sleigh.engine = s.to_string();
        self
    }
    pub fn gift_capacity(mut self, s: u32) -> Self {
        self.sleigh.gift_capacity = s;
        self
    }
    
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        self.sleigh.clone()
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Dominic

DominicD

2 days ago

3.30ms

87.97kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
    // Define the fields of SleighBuilder here
}
impl SleighBuilder {
    pub fn new() -> Self {
        SleighBuilder {
            color: "red".into(),
            engine: "reindeer-powered".into(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    
    pub fn color(mut self, color: &str) -> Self
    {
        self.color = color.to_owned();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self
    {
        self.engine = engine.to_owned();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self
    {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self
    {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh
    {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Sukrit Amornpornwiwat

arm01846

2 days ago

3.60ms

87.38kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    pub fn new() -> Self {
        SleighBuilder {
            color: "red".into(), 
            engine: "reindeer-powered".into(), 
            gift_capacity: 100, 
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> SleighBuilder {
        self.color = color.into();
        self
    }
    pub fn engine(mut self, engine: &str) -> SleighBuilder {
        self.engine = engine.into();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> SleighBuilder {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> SleighBuilder {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color.to_string(),
            engine: self.engine.to_string(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Joanne Muthoni

joanne-cmd

2 days ago

3.11ms

87.38kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string().clone();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        Sleigh {
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Rounak Sen

rony0000013

2 days ago

3.47ms

87.98kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    sleigh: Sleigh,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        SleighBuilder {
            sleigh: Sleigh {
                color: "red".to_string(),
                engine: "reindeer-powered".to_string(),
                gift_capacity: 100u32,
                magical_enhancements: false,
            }
        }
    }
    pub fn color(mut self, col: &str) -> Self {
        self.sleigh.color = col.to_string();
        self
    }
    pub fn engine(mut self, eng: &str) -> Self {
        self.sleigh.engine = eng.to_string();
        self
    }
    pub fn gift_capacity(mut self, cap: u32) -> Self {
        self.sleigh.gift_capacity = cap;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        self.sleigh
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

pagyeman

2 days ago

3.61ms

87.98kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    sleigh: Sleigh,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        SleighBuilder {
            sleigh: Sleigh {
                color: "red".to_string(),
                engine: "reindeer-powered".to_string(),
                gift_capacity: 100u32,
                magical_enhancements: false,
            }
        }
    }
    pub fn color(mut self, col: &str) -> Self {
        self.sleigh.color = col.to_string();
        self
    }
    pub fn engine(mut self, eng: &str) -> Self {
        self.sleigh.engine = eng.to_string();
        self
    }
    pub fn gift_capacity(mut self, cap: u32) -> Self {
        self.sleigh.gift_capacity = cap;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        self.sleigh
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

vaclav0411

2 days ago

8.68ms

87.97kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    sleigh: Sleigh,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> SleighBuilder {
        SleighBuilder{
            sleigh: Sleigh{
                color: "red".into(),
                engine: "reindeer-powered".into(),
                gift_capacity: 100,
                magical_enhancements: false,
            }
        }
    }
    
    pub fn color(mut self, color: &str) -> Self {
        self.sleigh.color = color.into();
        self
    }
    
    pub fn engine(mut self, engine: &str) -> Self {
        self.sleigh.engine = engine.into();
        self
    }
    
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.sleigh.gift_capacity = gift_capacity;
        self
    }
    
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        self.sleigh
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Njerii

wamimi

2 days ago

6.37ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        // Initialize with default values
        SleighBuilder {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, capacity: u32) -> Self {
        self.gift_capacity = capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Michal Miškerník

miscer

2 days ago

3.17ms

87.97kb

#[derive(Clone)]
pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    sleigh: Sleigh,
}
impl SleighBuilder {
    pub fn new() -> Self {
        SleighBuilder{
            sleigh: Sleigh{
                color: "red".into(),
                engine: "reindeer-powered".into(),
                gift_capacity: 100,
                magical_enhancements: false,
            }
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.sleigh.color = color.into();
        self
    }
    
    pub fn engine(mut self, engine: &str) -> Self {
        self.sleigh.engine = engine.into();
        self
    }
    
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.sleigh.gift_capacity = gift_capacity;
        self
    }
    
    pub fn magical_enhancements(mut self) -> Self {
        self.sleigh.magical_enhancements = true;
        self
    }
    
    pub fn build(self) -> Sleigh {
        self.sleigh
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Masayuki Sunahara

tamanishi

2 days ago

3.68ms

87.38kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string().clone();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        Sleigh {
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Nikita Smirnov

Nismirno

3 days ago

3.69ms

87.39kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,    
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        SleighBuilder {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        Sleigh {
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Tim Toebrock

titoeb

3 days ago

3.27ms

87.38kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    pub fn new() -> Self {
        Self {
            color: "red".into(),
            engine: "reindeer-powered".into(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.into();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.into();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        Sleigh {
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

gmvar

3 days ago

4.04ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> SleighBuilder {
        SleighBuilder{
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self: SleighBuilder, color: &str) -> SleighBuilder {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self: SleighBuilder, engine: &str) -> SleighBuilder {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self: SleighBuilder, gift_capacity: u32) -> SleighBuilder {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self: SleighBuilder) -> SleighBuilder {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self: SleighBuilder) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Naohiro Fukudome

sakin97

3 days ago

3.71ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_owned(),
            engine: "reindeer-powered".to_owned(),
            gift_capacity: 100,
            magical_enhancements: false
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_owned();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_owned();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

hafihaf123

3 days ago

4.16ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_owned(),
            engine: "reindeer-powered".to_owned(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_owned();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_owned();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

hafihaf123

3 days ago

3.36ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_owned(),
            engine: "reindeer-powered".to_owned(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_owned();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_owned();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Burnus

3 days ago

4.15ms

87.84kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: Option<String>,
    engine: Option<String>,
    gift_capacity: Option<u32>,
    magical_enhancements: Option<bool>,
}
impl SleighBuilder {
    pub fn new() -> Self {
        Self {
            color: None,
            engine: None,
            gift_capacity: None,
            magical_enhancements: None,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = Some(color.into());
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = Some(engine.into());
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = Some(gift_capacity);
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = Some(true);
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color.unwrap_or("red".into()),
            engine: self.engine.unwrap_or("reindeer-powered".into()),
            gift_capacity: self.gift_capacity.unwrap_or(100),
            magical_enhancements: self.magical_enhancements.unwrap_or(false),
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

KLcpb

3 days ago

6.85ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new()->SleighBuilder{
        SleighBuilder{color:"red".to_string(),engine:"reindeer-powered".to_string(),gift_capacity:100,magical_enhancements:false}
    }
    pub fn color(mut self, c:&str)->SleighBuilder{
        self.color = c.to_string();
        self
    }
    pub fn engine(mut self, e:&str)->SleighBuilder{
        self.engine = e.to_string();
        self
    }
    pub fn gift_capacity(mut self, g:u32)->SleighBuilder{
        self.gift_capacity = g;
        self
    }
    pub fn magical_enhancements(mut self)->SleighBuilder{
        self.magical_enhancements = true;
        self
    }
    pub fn build(self)->Sleigh{
        Sleigh{ color:self.color,engine:self.engine,gift_capacity:self.gift_capacity,magical_enhancements:self.magical_enhancements}
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

joshvon44

3 days ago

3.67ms

87.97kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> SleighBuilder {
        SleighBuilder {
            color: "red".into(),
            engine: "reindeer-powered".into(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> SleighBuilder {
        self.color = color.into();
        self
    }
    pub fn engine(mut self, engine: &str) -> SleighBuilder {
        self.engine = engine.into();
        self
    }
    pub fn gift_capacity(mut self, gift_cap: u32) -> SleighBuilder {
        self.gift_capacity = gift_cap;
        self
    }
    pub fn magical_enhancements(mut self) -> SleighBuilder {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        // Onwership of object is taken over so we can move ownership of color and engine to the
        // Sleigh object
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

joshvon44

3 days ago

3.60ms

87.38kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> SleighBuilder {
        SleighBuilder {
            color: "red".into(),
            engine: "reindeer-powered".into(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> SleighBuilder {
        self.color = color.into();
        self
    }
    pub fn engine(mut self, engine: &str) -> SleighBuilder {
        self.engine = engine.into();
        self
    }
    pub fn gift_capacity(mut self, gift_cap: u32) -> SleighBuilder {
        self.gift_capacity = gift_cap;
        self
    }
    pub fn magical_enhancements(mut self) -> SleighBuilder {
        self.magical_enhancements = true;
        self
    }
    pub fn build(&self) -> Sleigh {
        Sleigh {
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Tõnis Kevvai

tonisk

3 days ago

3.91ms

87.97kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    pub fn new() -> SleighBuilder {
        SleighBuilder {
            color: "red".into(),
            engine: "reindeer-powered".into(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> SleighBuilder {
        self.color = color.into();
        self
    }
    pub fn engine(mut self, engine: &str) -> SleighBuilder {
        self.engine = engine.into();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> SleighBuilder {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> SleighBuilder {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Claus Guttesen

kometen

4 days ago

3.82ms

88.03kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        SleighBuilder {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(&mut self, color: &str) -> Self {
        self.color = color.to_string();
        self.clone()
    }
    pub fn engine(&mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self.clone()
    }
    pub fn gift_capacity(&mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self.clone()
    }
    pub fn magical_enhancements(&mut self) -> Self {
        self.magical_enhancements = true;
        self.clone()
    }
    pub fn build(&self) -> Sleigh {
        Sleigh {
            color: self.color.clone(),
            engine: self.engine.clone(),
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

James Bromley

jayber

4 days ago

2.98ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> SleighBuilder {
        SleighBuilder {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(self, color: &'static str) -> SleighBuilder {
        SleighBuilder {
            color: color.to_string(), 
            ..self
        }
    }
    pub fn engine(self, engine: &'static str) -> SleighBuilder {
        
        SleighBuilder {
            engine: engine.to_string(), 
            ..self
        }
    }
    pub fn gift_capacity(self, gift_capacity: u32) -> SleighBuilder {
        
        SleighBuilder {
            gift_capacity, 
            ..self
        }
    }
    pub fn magical_enhancements(self) -> SleighBuilder {
        
        SleighBuilder {
            magical_enhancements: true, 
            ..self
        }
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Guilherme Cesário Strachan

strachan

4 days ago

3.19ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh { color: self.color, engine: self.engine, gift_capacity: self.gift_capacity, magical_enhancements: self.magical_enhancements} 
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Luis Linares

lulingar

4 days ago

3.93ms

87.97kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    _color: String,
    _engine: String,
    _gift_capacity: u32,
    _magical_enhancements: bool,
    usable: bool,
}
impl SleighBuilder {
    pub fn new() -> Self {
        Self {
            _color: "red".to_string(),
            _engine: "reindeer-powered".to_string(),
            _gift_capacity: 100,
            _magical_enhancements: false,
            usable: true,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self._color = color.into();
        self.usable = false;
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self._engine = engine.into();
        self.usable = false;
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self._gift_capacity = gift_capacity;
        self.usable = false;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self._magical_enhancements = true;
        self.usable = false;
        self
    }
    pub fn build(mut self) -> Sleigh {
        // No validations requested
        self.usable = true;
        Sleigh {
            color: self._color,
            engine: self._engine,
            gift_capacity: self._gift_capacity,
            magical_enhancements: self._magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

wishkus

4 days ago

3.80ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
    // Define the fields of SleighBuilder here
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        SleighBuilder{
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false
            }
    }
    pub fn color(mut self, color_v: &str) -> Self {
        self.color = color_v.to_string();
        self
    }
    pub fn engine(mut self, engine_v: &str) -> Self {
        self.engine = engine_v.to_string();
        self
    }
    pub fn gift_capacity(mut self, cap: u32) -> Self {
        self.gift_capacity = cap;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh{
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Grant Kinney

creativecoder

4 days ago

3.66ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

GermanS

4 days ago

20.65ms

87.97kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    // Define the fields of SleighBuilder here
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    // Your code here...
    pub fn new() -> Self {
        Self::default()
    }
    pub fn default() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color( mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine( mut self, engine: &str ) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity( mut self, capacity: u32 ) -> Self {
        self.gift_capacity = capacity;
        self
    }
    pub fn magical_enhancements( mut self ) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}

Chris

chriswmann

4 days ago

3.22ms

87.98kb

pub struct Sleigh {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
#[derive(Clone)]
pub struct SleighBuilder {
    color: String,
    engine: String,
    gift_capacity: u32,
    magical_enhancements: bool,
}
impl SleighBuilder {
    pub fn new() -> Self {
        Self {
            color: "red".to_string(),
            engine: "reindeer-powered".to_string(),
            gift_capacity: 100,
            magical_enhancements: false,
        }
    }
    pub fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }
    pub fn engine(mut self, engine: &str) -> Self {
        self.engine = engine.to_string();
        self
    }
    pub fn gift_capacity(mut self, gift_capacity: u32) -> Self {
        self.gift_capacity = gift_capacity;
        self
    }
    pub fn magical_enhancements(mut self) -> Self {
        self.magical_enhancements = true;
        self
    }
    pub fn build(self) -> Sleigh {
        Sleigh {
            color: self.color,
            engine: self.engine,
            gift_capacity: self.gift_capacity,
            magical_enhancements: self.magical_enhancements,
        }
    }
}
// Don't Change this implementation
// It is used for the tests
impl Sleigh {
    pub fn color(&self) -> &str {
        &self.color
    }
    pub fn engine(&self) -> &str {
        &self.engine
    }
    pub fn gift_capacity(&self) -> u32 {
        self.gift_capacity
    }
    pub fn magical_enhancements(&self) -> bool {
        self.magical_enhancements
    }
}
pub fn main() {
    let sleigh = SleighBuilder::new()
        .color("gold")
        .engine("magic")
        .gift_capacity(350)
        .magical_enhancements()
        .build();
    assert_eq!(sleigh.color(), "gold");
    assert_eq!(sleigh.engine(), "magic");
    assert_eq!(sleigh.gift_capacity(), 350);
    assert_eq!(sleigh.magical_enhancements(), true);
}