Rust Addition

The + operator in Rust serves two distinct syntactic roles: as an algebraic operator that desugars to the std::ops::Add trait for arithmetic and concatenation, and as a type-system operator for specifying compound trait and lifetime bounds.

The `std::ops::Add` Trait

When used as a binary operator between values (LHS + RHS), the + symbol is syntactic sugar for the add method of the std::ops::Add trait. The compiler translates a + b into a.add(b). The trait is defined in the standard library as follows:

pub trait Add<Rhs = Self> {
    type Output;

    fn add(self, rhs: Rhs) -> Self::Output;
}

Rhs (Right-Hand Side): A generic type parameter that defaults to Self. This allows the right operand to be a different type than the left operand.
Output: An associated type defining the type returned by the addition operation.
Ownership: The add method takes ownership of self (the left operand) by value. Whether rhs is consumed or borrowed depends on the specific type implementation.

To enable the + operator for custom types, you must implement this trait:

use std::ops::Add;

struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        Self {
            x: self.x + rhs.x,
            y: self.y + rhs.y,
        }
    }
}

String Concatenation Mechanics

When applied to strings, the + operator relies on a specific implementation of the Add trait: impl Add<&str> for String.

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2; 

Mechanically, this operation:

Takes ownership of s1 (self), meaning s1 is moved and can no longer be used.
Takes a string slice (&str) for the right operand.
Appends the contents of the right operand to the left operand’s memory buffer.
Returns the reused, now-concatenated String.

If the right operand is a &String (as in &s2), Rust applies deref coercion to convert &String into &str (&s2[..]) to satisfy the trait signature.

Compound Trait and Lifetime Bounds

In the context of the type system, the + operator acts as a logical AND (conjunction) for constraining generic types, opaque types (impl Trait), and trait objects (dyn Trait). Multiple Trait Bounds: It restricts a generic type parameter to types that implement all specified traits.

// T must implement both Display and Clone
fn print_and_clone<T: std::fmt::Display + Clone>(item: &T) {
    // ...
}

// Equivalent syntax using a where clause
fn print_and_clone_where<T>(item: &T) 
where 
    T: std::fmt::Display + Clone 
{
    // ...
}

Lifetime Bounds: It binds a type or trait object to a specific lifetime, ensuring that any references held within the type outlive the specified lifetime.

// The trait object must implement Debug and cannot contain 
// references that live shorter than the 'a lifetime.
fn store_debug<'a>(item: Box<dyn std::fmt::Debug + 'a>) {
    // ...
}

Tired of Poor Rust Skills? Fix That With Deep Grasping!Learn More

Functions

Traits

Closures

Generics

Enums

Pattern Matching

Structs

Macros

Lifetimes

Error Handling

Variables

Control Flow

Loops

Modules

Compound Types

Collection Types

Numeric Types

Text & Boolean Types

Attributes

Comments

Assignment Operators

Arithmetic Operators

Comparison Operators

Logical Operators

Unary Operators

Reference Operators

Access & Path Operators

Range Operators

Bitwise Operators

Type Cast Operators

The `std::ops::Add` Trait

String Concatenation Mechanics

Compound Trait and Lifetime Bounds

​The std::ops::Add Trait

​String Concatenation Mechanics

​Compound Trait and Lifetime Bounds

The `std::ops::Add` Trait

String Concatenation Mechanics

Compound Trait and Lifetime Bounds