Rust for C-Programmers

9.4 Tuple Structs and Unit-Like Structs

Rust has two specialized struct forms—tuple structs and unit-like structs—that simplify certain use cases.

9.4.1 Tuple Structs

Tuple structs combine the simplicity of tuples with the clarity of named types. They differ from regular tuples in that Rust treats them as separate named types, even if they share the same internal types:

#![allow(unused)]
fn main() {
struct Color(u8, u8, u8);
let red = Color(255, 0, 0);
println!("Red component: {}", red.0);
}

Fields are accessed by index (e.g., red.0). Tuple structs are helpful when the positional meaning of each field is already clear or when creating newtype wrappers.

9.4.2 The Newtype Pattern

The newtype pattern is a common use of tuple structs where a single-field struct wraps a primitive type. This provides type safety while allowing custom implementations of various traits or behavior:

#![allow(unused)]
fn main() {
struct Inches(i32);
struct Centimeters(i32);

let length_in = Inches(10);
let length_cm = Centimeters(25);
}

Even though both contain an i32, Rust treats them as distinct types, preventing accidental mixing of different units.

A key advantage of the newtype pattern is that it allows implementing traits for the wrapped type, enabling custom behavior. For example, to enable adding two Inches values:

#![allow(unused)]
fn main() {
use std::ops::Add;

struct Inches(i32);

impl Add for Inches {
    type Output = Inches;
    
    fn add(self, other: Inches) -> Inches {
        Inches(self.0 + other.0)
    }
}

let len1 = Inches(5);
let len2 = Inches(10);
let total_length = len1 + len2;
println!("Total length: {} inches", total_length.0);
}

Similarly, you can define multiplication with a plain integer:

#![allow(unused)]
fn main() {
use std::ops::Mul;

struct Inches(i32);

impl Mul<i32> for Inches {
    type Output = Inches;

    fn mul(self, factor: i32) -> Inches {
        Inches(self.0 * factor)
    }
}

let len = Inches(4);
let double_len = len * 2;
println!("Double length: {} inches", double_len.0);
}

This pattern is particularly useful for enforcing strong type safety in APIs and preventing the accidental misuse of primitive values.

9.4.3 Unit-Like Structs

Unit-like structs have no fields and serve as markers or placeholders:

#![allow(unused)]
fn main() {
struct Marker;
}

They can still be instantiated:

let _m = Marker;

Though they hold no data, you can implement traits for them to indicate certain properties or capabilities. Because they have no fields, unit-like structs typically have no runtime overhead.