Advanced Traits

You're already familiar with implementing traits in Rust, let's explore some special traits from the standard library - specifically those that allow operator overloading through the std::ops module.

One such trait is Add, which allows you to implement custom behavior for the + operator. This is particularly useful when working with types that have a natural addition operation, like measurements or mathematical types.

Your Task

Let's implement custom addition between different units of measurement. You'll create a system where you can add meters to millimeters, with automatic unit conversion.

Your job is to implement a Millimeters struct and a Meters struct, then implement the Add trait to allow adding a Meters value to a Millimeters value. The result should be a new Millimeters value.

Requirements

Define two structs: Millimeters and Meters, each holding a single u32 value
Implement the Add<Meters> trait for Millimeters to handle addition with Meters
Conversion rules:
- 1 meter = 1000 millimeters
- When adding, convert meters to millimeters first
- Return the result as Millimeters

Hints

If you're stuck, here are some hints to help you solve the challenge!

Click here to reveal hints

The Add trait requires you to specify:

type Output = Millimeters;
fn add(self, other: Meters) -> Self::Output;

Remember that meters must be multiplied by 1000 to convert to millimeters
Access tuple struct fields with .0

Editor not available on Mobile!

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

Solutions

Chih Ying Yen

xavierforge

2 days ago

3.84ms

87.94kb

use std::ops::Add; 
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, other: Meters) -> Self::Output {
        Self(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

undefeated_

boyboi86

3 days ago

3.99ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Millimeters(self.0 + other.0 * 1000)
    } 
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

amdfxlucas

4 days ago

3.75ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output{
        Millimeters(self.0 + other.0*1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

GunGraveCpp

6 days ago

4.07ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl Add<Meters> for Millimeters  {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + rhs.0 * 1000)
    }
    
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

toto

8 days ago

3.44ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + (rhs.0 * 1000))
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Lvfalue

12 days ago

4.21ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, b: Meters) -> Millimeters {
        Millimeters(self.0 + b.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

manu3618

13 days ago

3.46ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add for Millimeters {
    
    type Output = Self;
    fn add(self, other: Self) -> Self {
        Self(self.0 + other.0)
    }
}
impl Add for Meters {
    type Output = Self;
    fn add(self, other: Self) -> Self {
        Self(self.0 + other.0)
    }
}
impl Add<Meters> for Millimeters {    
    type Output = Self;
    fn add(self, other: Meters) -> Self {
        Self(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

AtlasVakyrie

20 days ago

3.79ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Millimeters(self.0 + other.0 * 1000)
    } 
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}
// The `std::ops::Add` trait is used to specify the functionality of `+`.
// Here, we make `Add<Bar>` - the trait for addition with a RHS of type `Bar`.
// The following block implements the operation: Foo + Bar = FooBar

bzdula

22 days ago

3.50ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, rhs: Meters) -> Self::Output {
        Self(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Wouter

WouterMartens

a month ago

3.65ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, other: Meters) -> Self {
        Self(other.0 * 1000 + self.0)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Wouter

WouterMartens

a month ago

3.62ms

87.94kb

use std::ops::Add;
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Millimeters(pub u32);
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Meters(pub u32);
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, other: Meters) -> Self {
        Self(other.0 * 1000 + self.0)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Daniel Mestas

miel-codeai

a month ago

3.46ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Self(self.0 + (rhs.0 * 1000))
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

whhc

a month ago

3.43ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Millimeters(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Baron Curtin

baroncurtin2

a month ago

3.10ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, other: Meters) -> Self::Output {
        Self(other.0 * 1000 + self.0)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Evrins Hu

evrins

a month ago

3.99ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, rhs: Meters) -> Self::Output {
        Self(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

medzernik

a month ago

3.50ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, other: Meters) -> Self {
        Self((self.0) + (other.0*1000))
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

johndoe30bc

a month ago

4.61ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, rhs: Meters) -> Self::Output {
        Self(self.0 + 1000 * rhs.0)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Miguel Ángel Allende

maallende

a month ago

3.65ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Millimeters {
        // Convert Meters to Millimeters (1 meter = 1000 millimeters)
        Millimeters(self.0 + Millimeters::from(other).0)
    }
}
impl From<Meters> for Millimeters {
    fn from(meters: Meters) -> Millimeters {
        Millimeters(meters.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

FredoPo

a month ago

4.32ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Self(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Procybit

a month ago

3.83ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

xxxxsk

a month ago

3.79ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Millimeters {
        Millimeters(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

xxxxsk

a month ago

4.66ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Millimeters {
        Millimeters(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Evgenii Grigorenko

grevgeny

a month ago

3.65ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl std::ops::Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, other: Meters) -> Self {
        Self(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

brucecox01

a month ago

3.80ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, meters: Meters) -> Millimeters {
        let Millimeters(millimeters) = self;
        let Meters(meters) = meters;
        Millimeters(millimeters + 1000 * meters)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Krzysztof Atłasik

katlasik

2 months ago

5.40ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(rhs.0 * 1000 + self.0)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Ushakov Andrey

stdstring

2 months ago

3.60ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Millimeters(self.0 + 1000 * other.0)
    }
} 
// Implement the Add trait
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Philippe Massicotte

PMassicotte

2 months ago

4.19ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Self(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Tengz Mao

MaoX-Yu

2 months ago

4.02ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Self(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

0x0f1

Paul4673

2 months ago

4.09ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other : Meters) -> Self {
        Self(self.0 + (other.0 * 1000))
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

AnKarl

Zythophilus

2 months ago

4.43ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Millimeters {
        let other_mm = other.0 * 1000;
        Millimeters(other_mm + self.0)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

vanos001

2 months ago

3.66ms

87.94kb

 use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters{
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output{
        return Self(self.0 + 1000*other.0);
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Herman effendi

hrmneffdii

2 months ago

3.74ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

alexsavio

2 months ago

3.67ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

ikatlinsky

2 months ago

4.02ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, rhs: Meters) -> Self::Output {
        return Self(self.0 + rhs.0 * 1000);
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

diucicd

2 months ago

5.65ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
impl From<Meters> for Millimeters {
    fn from(meters: Meters) -> Self {
        Millimeters(meters.0 * 1000)
    }
}
impl From<Millimeters> for Meters {
    fn from(millimeters: Millimeters) -> Self {
        Meters(millimeters.0 / 1000)
    }
}
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + rhs.0 * 1000)
    }
}
// Implement the Add trait
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Sergey Matyash

matiaspub

2 months ago

3.86ms

87.94kb

use std::ops::{Add};
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Millimeters(self.0 + (other.0 * 1000))
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Prafful

iamsahu

2 months ago

4.28ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, others: Meters) -> Self::Output {
        Millimeters(self.0 + others.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Nicolai

Posmac

2 months ago

4.97ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

LeonardoPinheiro23

2 months ago

5.18ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

sjmellor

3 months ago

4.19ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, meters: Meters) -> Self::Output {
        Self(
            self.0 + (meters.0 * 1000),
        )
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

ggnne

3 months ago

5.06ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Self;
    fn add(self, other: Meters) -> Self {
        Self(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Tommytto

3 months ago

3.38ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, meters: Meters) -> Millimeters {
       Millimeters(self.0 + meters.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Viktor Merkurev

fennr

3 months ago

3.37ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Millimeters {
        Millimeters(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Elizabeth Doughty

Thymelizabeth

3 months ago

3.64ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        let Millimeters(millimetres) = self;
        let Meters(metres) = rhs;
        Millimeters(millimetres + metres * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Nguyen Vo Hoang Son

sonmessia

3 months ago

10.66ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Millimeters(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

shibu-t

4 months ago

3.75ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Millimeters(self.0 + other.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Liyqq

4 months ago

3.88ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self { 
        Self(other.0 * 1000 + self.0)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Trịnh Chấn Duy

Duyyy123

4 months ago

3.81ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Self(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

Jason

Jason-fy-wang

4 months ago

6.08ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl std::ops::Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + (rhs.0 * 1000))
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}

vijayabhaskar badireddi

ptcte

4 months ago

3.55ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Self(self.0 + rhs.0 * 1000)
    }
}
// Example usage
pub fn main() {
    let length1 = Millimeters(1500);
    let length2 = Meters(3);
    let result = length1 + length2;
    assert_eq!(result.0, 4500, "Expected 1500mm + 3000mm to equal 4500mm");
}