Day 10: The Deref Debacle

The elves huddled in the workshop, their chatter buzzing with excitement.

"Have you seen the new ChatGPT model that just launched?" one elf asked, adjusting their tiny glasses.

"I did! But did you hear? It costs $200 a month!" another replied, shaking their head in disbelief.

“Two hundred dollars? That’s a fortune!” chimed in a third, tossing a tinsel garland into a storage box.

The discussion heated up as they debated whether the advanced features were worth the hefty price tag, but their conversation was abruptly interrupted by a booming voice.

“I can’t deref my snowballs! What’s going on?” Santa’s frustrated shout echoed through the workshop.

The elves froze mid-conversation, their heads snapping toward the jolly old man standing by his snowball workstation. He wore an expression of pure consternation as he jabbed a finger at the terminal screen displaying a stream of cryptic error messages.

One of the more tech-savvy elves hesitantly stepped forward. “Santa, you can just use snowball.0 to access the first value in the tuple.”

Santa’s frown deepened, and he waved a hand dismissively. “Nonsense! I need to deref all the structs. Every single one!”

The elves weren’t sure what Santa was coding, but they knew better than to argue with him when he was in debugging mode. Scrambling into action, they began reviewing his codebase, determined to find a solution before the big man lost his holiday cheer.

Your Mission

The code you wrote yesterday is a good start, but Santa needs easy access to the struct fields, instead of accessing them like this snowball.0, he wants to access them like this *snowball.

Here is what you need to do:

Implement Deref for SnowKg.
Implement Deref for SnowLb.
Implement Deref for Snowball.
Return the inner value of the tuple struct when dereferencing.

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.

Import the Deref trait from the std::ops module: use std::ops::Deref;.
Implement the Deref trait for SnowKg, SnowLb, and Snowball. e.g., impl Deref for SnowKg { ... }.
Define the associated type Target as the type of the inner value of the tuple struct. e.g.
```
type Target = f64;
```

Implement the deref method for each struct. e.g.

fn deref(&self) -> &Self::Target {
    &self.0
}

Editor not available on Mobile!

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

Solutions

João Paiva

jgpaiva

2 hours ago

3.54ms

89.22kb

const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
use std::ops::Deref;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Mingzhe Yang

mei28

18 hours ago

3.81ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self)-> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self)-> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Joseph Copenhaver

josephcopenhaver

20 hours ago

3.81ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

PangoSea

kapaseker

a day ago

3.49ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Francisco López

franlopezm

a day ago

3.73ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Ferdinand de Baecque

Ferdinanddb

a day ago

3.46ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

doroshtapgh

2 days ago

5.07ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Naoyuki Yamada

chokkoyamada

2 days ago

3.43ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Tengz Mao

MaoX-Yu

2 days ago

3.70ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

Martin

mrtnhwtt

2 days ago

4.65ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Snowball {
        let sw = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        return Snowball::new(sw);
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Snowball {
        let sw = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        return Snowball::new(sw);
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

Ankit Kumar Jha

Ankit8848

2 days ago

3.61ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Habu

habu1010

2 days ago

3.87ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Rickard Jensen

rjensen

2 days ago

3.92ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Sukrit Amornpornwiwat

arm01846

3 days ago

3.64ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

arilet

3 days ago

4.47ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Ankeet Parikh

ankeetparikh

3 days ago

3.74ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Emmanuel Guefif

eguefif

3 days ago

4.93ms

89.22kb

use core::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Nikita Smirnov

Nismirno

3 days ago

3.54ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

Tanguy Mazé

tvdu29

3 days ago

4.02ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

gsspdev

3 days ago

5.98ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Muhammad-Dennis

3 days ago

5.99ms

89.22kb

const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
use std::ops::Deref;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

hafihaf123

3 days ago

3.73ms

89.22kb

const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
use std::ops::Deref;
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

hafihaf123

3 days ago

17.19ms

89.22kb

const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
use std::ops::Deref;
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

hafihaf123

3 days ago

33.15ms

89.22kb

const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
use std::ops::Deref;
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Kushneryk Pavel

KushnerykPavel

3 days ago

5.26ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

Burnus

4 days ago

4.61ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Felipe Ribeiro Saruhashi

felipesaruhashi

4 days ago

3.58ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

gmvar

4 days ago

3.31ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Masayuki Sunahara

tamanishi

4 days ago

5.14ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &f64 {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &f64 {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &i64 {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Moloson

4 days ago

3.49ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl Deref for SnowKg{
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
pub struct SnowLb(pub f64);
impl Deref for SnowLb{
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Deref for Snowball{
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

jcorrie

4 days ago

3.61ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg{
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb{
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball{
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Sourabh Cheedella

rirze

4 days ago

4.30ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &f64 {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &f64 {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &i64 {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

KLcpb

4 days ago

3.52ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg{
    type Target=f64;
    fn deref(&self)-> &Self::Target{
        &self.0
    }
}
impl Deref for SnowLb{
    type Target=f64;
    fn deref(&self)-> &Self::Target{
        &self.0
    }
}
impl Deref for Snowball{
    type Target=i64;
    fn deref(&self)-> &Self::Target{
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Prafful

iamsahu

4 days ago

4.73ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb{
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball{
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

vaclav0411

5 days ago

5.87ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

Kanak Shilledar

kanakshilledar

5 days ago

4.56ms

89.22kb

const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
use std::ops::Deref;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(weight: SnowKg) -> Self {
        let snowballs = (*weight / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball::new(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(weight: SnowLb) -> Self {
        let snowballs = (*weight / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball::new(snowballs)
    }
}
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    // 2. Create a public associated function named `new()`
    pub fn new(logs: &'a Vec<String>) -> LogQuery<'a> {
        LogQuery { logs }
    }
    // 3. Create a public method named `search`
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        // Filter logs that contain the keyword and collect references
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    // Method to export logs matching a keyword to a file
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        use std::fs::File;
        use std::io::{self, Write};
        let matching_logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in matching_logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Sergey Martynov

martynovs

5 days ago

4.31ms

89.22kb

const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl std::ops::Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl std::ops::Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl std::ops::Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Phate45

phate45

5 days ago

3.72ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

sasha

sashaaKr

5 days ago

3.76ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

kosay

sarub0b0

5 days ago

3.51ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Will LaBranche

wlabranche

5 days ago

3.55ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Richmond Steele

RedNapPanda

5 days ago

4.48ms

89.22kb

use core::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

Guilherme Cesário Strachan

strachan

5 days ago

4.30ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Galen Seilis

galenseilis

5 days ago

4.08ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Wendy Kong

wendko

5 days ago

12.76ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Pascal Dietrich

Cameo007

5 days ago

3.81ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Luis Linares

lulingar

5 days ago

3.54ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
// 2. Implement the `Deref` trait for `SnowLb`
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
// 3. Implement the `Deref` trait for `Snowball`
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Dominic

DominicD

5 days ago

3.98ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
// 1. Implement the `Deref` trait for `SnowKg`
// 2. Implement the `Deref` trait for `SnowLb`
// 3. Implement the `Deref` trait for `Snowball`
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

jsdm13

5 days ago

4.23ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}

Joanne Muthoni

joanne-cmd

5 days ago

4.65ms

89.22kb

use std::ops::Deref;
const SNOWBALL_WEIGHT_KG: f64 = 0.2;
const SNOWBALL_WEIGHT_LB: f64 = 0.441;
pub struct SnowKg(pub f64);
impl SnowKg {
    pub fn new(kg: f64) -> Self {
        SnowKg(kg)
    }
}
impl Deref for SnowKg {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        return &self.0;
    }
}
impl Deref for SnowLb {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        return &self.0;
    }
}
impl Deref for Snowball {
    type Target = i64;
    fn deref(&self) -> &Self::Target {
        return &self.0;
    }
}
pub struct SnowLb(pub f64);
impl SnowLb {
    pub fn new(lb: f64) -> Self {
        SnowLb(lb)
    }
}
pub struct Snowball(pub i64);
impl Snowball {
    pub fn new(snowballs: i64) -> Self {
        Snowball(snowballs)
    }
}
impl From<SnowKg> for Snowball {
    fn from(kg: SnowKg) -> Self {
        let snowballs = (*kg / SNOWBALL_WEIGHT_KG).round() as i64;
        Snowball(snowballs)
    }
}
impl From<SnowLb> for Snowball {
    fn from(lb: SnowLb) -> Self {
        let snowballs = (*lb / SNOWBALL_WEIGHT_LB).round() as i64;
        Snowball(snowballs)
    }
}