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

0x0f1

Paul4673

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

4 days 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

4 days 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

4 days 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

6 days 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

15 days 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

17 days 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

19 days 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

20 days 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

23 days 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

24 days 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

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

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

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

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

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

2 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

2 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

2 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

2 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

3 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

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

Jason

chenjie1219

3 months ago

5.07ms

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

Aurimas Kuniutis

auriku

3 months ago

4.94ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
impl Add for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Self) -> Self::Output {
        Millimeters(self.0 + rhs.0)
    }
}
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 + rhs.0 * 1000)
    }
}
pub struct Meters(pub u32);
impl Add<Millimeters> for Meters {
    type Output = Millimeters;
    fn add(self, rhs: Millimeters) -> Self::Output {
        Millimeters(self.0 * 1000 + rhs.0)
    }
}
impl Add<Meters> for Meters {
    type Output = Millimeters;
    fn add(self, rhs: Meters) -> Self::Output {
        Millimeters(self.0 * 1000 + 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");
}

Yixian Du

duyixian1234

3 months ago

7.68ms

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

Artem

tich31337

3 months ago

8.93ms

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

Paulo Lins

pblins

3 months ago

6.27ms

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

Anna Komarova

Vlasanya

3 months ago

3.97ms

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

Icarus

IcarusxB

4 months ago

4.31ms

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, that: Meters) -> Self::Output {
        Millimeters(self.0 + (that.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");
}

Hung Dinh

nhdinh

4 months ago

4.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 = Millimeters;
    fn add(self, m: Meters) -> Millimeters {
        Millimeters(self.0 + m.0*1000)
    }
}
impl Add<Millimeters> for Meters {
    type Output = Meters;
    fn add(self, m: Millimeters) -> Meters {
        Meters(self.0 + m.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");
}

Matthew Li

circles-png

4 months ago

4.25ms

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 = Self;
    fn add(self, Meters(rhs): Meters) -> Self::Output {
        Self(self.0 + rhs * 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");
}

Kentaro Abe

abekem

4 months ago

5.92ms

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

Zeiion

4 months ago

3.62ms

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

Manuel Manjarres R.

manuelmj

4 months ago

3.22ms

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)-> Self::Output{
        let meters_to_milis: u32 = meters.0 * 1000; 
        Millimeters(self.0 + meters_to_milis)  
    }
}
// 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");
}

Manuel Manjarres R.

manuelmj

4 months ago

3.68ms

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)-> Self::Output{
        let meters_to_milis: u32 = meters.0 * 1000; 
        Millimeters(self.0 + meters_to_milis)  
    }
}
// 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");
}

amaneru

7ma8no9

4 months ago

3.98ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
use std::ops::Add;
// Implement the Add trait
impl 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");
}

AKA.MoneyTaker

M4Bo2

4 months ago

4.47ms

87.94kb

use std::ops::Add;
pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
// Implement the Add<Meters> trait for Millimeters
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");
    println!("Result: {}mm", result.0);
}

ludovicknecht

4 months ago

4.87ms

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

Muhammad Dennis Wijaya

Muhammad-Dennis

4 months ago

3.83ms

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 converted = rhs.0 * 1000;
        Self(converted + 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");
}

Ayushman Rathore

Spartan09

4 months ago

5.23ms

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

automata-studio

4 months ago

6.07ms

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 {
        let mm = self.0 + other.0 * 1000;
        Millimeters(mm)
    }
}
// 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");
}

Dyaa Adel

dyaa-adel

4 months ago

3.64ms

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

Jun Huang

leemars

5 months ago

3.69ms

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

Algorab

5 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, 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");
}

Kyle Diaz

kylediaz

5 months ago

3.89ms

87.94kb

pub struct Millimeters(pub u32);
pub struct Meters(pub u32);
use std::ops::Add;
// Implement the Add trait
impl Add<Meters> for Millimeters {
    type Output = Millimeters;
    fn add(self, other: Meters) -> Self::Output {
        Millimeters(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");
}

Jordan

Jordan-Haidee

5 months ago

3.60ms

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 = Self;
    fn add(self, other: Meters) -> Self::Output {
        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");
}

rawar089

5 months ago

4.39ms

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

Nikita Smirnov

Nismirno

5 months ago

4.03ms

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

alemack17

5 months ago

4.59ms

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, op2: Meters)-> Self::Output{
        Millimeters(self.0+op2.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");
}

Christopher Nielson

c-nielson

5 months ago

3.82ms

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, others: Meters) -> Self::Output {
        Millimeters(others.0 * 1000 + self.0)
    }
}