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

AKA.MoneyTaker

M4Bo2

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

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

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

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

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

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

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

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

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

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

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

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

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

16 days 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)
    }
}

Elliott Draper

ejdraper

19 days ago

3.63ms

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

kosay

sarub0b0

19 days ago

3.70ms

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

Oebelus

oebelus

20 days ago

6.47ms

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

Jonathan Voss

jvoss

21 days ago

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

Jim Lawton

jimlawton

22 days ago

4.34ms

87.94kb

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

Justin Maillet

justy777

23 days ago

3.84ms

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

Stefan Roas

sroas

23 days ago

6.12ms

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

TaiPoole

a month ago

3.43ms

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

dawwestk

a month ago

3.38ms

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

PangoSea

kapaseker

a month ago

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