Struct Triple 

pub struct Triple<F, S, T> {
    pub first: F,
    pub second: S,
    pub third: T,
}

A generic triple structure that holds three values.

Type Parameters

• F - The type of the first element
• S - The type of the second element
• T - The type of the third element

Comparison with Native Tuples

While Rust’s native tuples (F, S, T) and Triple<F, S, T> both store three values, they differ in several key aspects:

Similarities

• Both can hold three values of different types
• Both support pattern matching and destructuring
• Both can be converted to each other via From/Into traits
• Both have similar memory layout and zero runtime overhead

Differences

Feature	Native Tuple (F, S, T)	Triple<F, S, T>
Field Access	.0, .1, .2 (positional)	.first, .second, .third (named)
Semantics	Anonymous, positional	Self-documenting, semantic
Methods	Limited built-in methods	Rich API (map, getters, setters)
Readability	Less clear in complex code	More expressive and maintainable
Type Alias	Hard to create meaningful aliases	Easy to create domain-specific types

When to Use Triple vs Native Tuples

Use Triple when:

• Field names improve code readability (e.g., triple.first vs tuple.0)
• You need additional methods like map_first(), map_second(), etc.
• Creating domain-specific types (e.g., type Coordinate = Triple<f64, f64, f64>)
• The triple represents a logical entity with semantic meaning
• You want to implement custom traits or behaviors

Use native tuples when:

• You need quick, temporary grouping of values
• Working with existing APIs that expect tuples
• Pattern matching is the primary use case
• Minimal overhead and simplicity are paramount

Examples

use qubit_common::Triple;

let triple = Triple::new("name", 42, true);
assert_eq!(triple.first, "name");
assert_eq!(triple.second, 42);
assert_eq!(triple.third, true);

let triple = Triple { first: 1, second: 2.5, third: "hello" };
assert_eq!(triple.first, 1);
assert_eq!(triple.second, 2.5);
assert_eq!(triple.third, "hello");

Fields

first: F

The first element of the triple

second: S

The second element of the triple

third: T

The third element of the triple

Implementations

impl<F, S, T> Triple<F, S, T>

pub fn new(first: F, second: S, third: T) -> Self

Creates a new Triple with the given values.

Arguments

• first - The first element
• second - The second element
• third - The third element

Examples

use qubit_common::Triple;

let triple = Triple::new(1, "hello", true);
assert_eq!(triple.first, 1);
assert_eq!(triple.second, "hello");
assert_eq!(triple.third, true);

Examples found in repository

examples/util_demo.rs (line 62)

fn main() {
    println!("=== Pair Demo ===\n");

    // Create Pair using new method
    let pair1 = Pair::new("name", "Alice");
    println!("pair1 (using new): {}", pair1);

    // Create Pair using struct literal (public fields)
    let mut pair2 = Pair {
        first: 1,
        second: 100,
    };
    println!("pair2 (using struct literal): {}", pair2);

    // Direct field access (public fields)
    pair2.first = 42;
    pair2.second = 200;
    println!("pair2 (after modification): {}", pair2);

    // Using methods
    let pair3 = Pair::new(10, 20);
    println!("pair3: {}", pair3);
    println!("  first: {}, second: {}", pair3.first(), pair3.second());

    // Map operations
    let pair4 = pair3.map_first(|x| x * 2).map_second(|x| x * 3);
    println!("pair4 (after mapping): {}", pair4);

    // Swap
    let pair5 = Pair::new("key", 123);
    let swapped = pair5.swap();
    println!("pair5: {}, swapped: {}", pair5, swapped);

    // Convert to tuple
    let (f, s) = pair5.into_tuple();
    println!("Converted to tuple: ({}, {})", f, s);

    println!("\n=== Triple Demo ===\n");

    // Create Triple using new method
    let triple1 = Triple::new("Alice", 30, true);
    println!("triple1 (using new): {}", triple1);

    // Create Triple using struct literal (public fields)
    let mut triple2 = Triple {
        first: 1,
        second: 2,
        third: 3,
    };
    println!("triple2 (using struct literal): {}", triple2);

    // Direct field access (public fields)
    triple2.first = 10;
    triple2.second = 20;
    triple2.third = 30;
    println!("triple2 (after modification): {}", triple2);

    // Using methods
    let triple3 = Triple::new(100, 200, 300);
    println!("triple3: {}", triple3);
    println!(
        "  first: {}, second: {}, third: {}",
        triple3.first(),
        triple3.second(),
        triple3.third()
    );

    // Map operations
    let triple4 = triple3
        .map_first(|x| x / 10)
        .map_second(|x| x / 10)
        .map_third(|x| x / 10);
    println!("triple4 (after mapping): {}", triple4);

    // Convert to tuple
    let (f, s, t) = triple4.into_tuple();
    println!("Converted to tuple: ({}, {}, {})", f, s, t);

    println!("\n=== Advanced Usage ===\n");

    // Pair with different types
    let config = Pair {
        first: "database_url",
        second: "postgresql://localhost/mydb",
    };
    println!("Config: {}", config);

    // Triple as a record
    let record = Triple {
        first: "user_001",
        second: "Alice",
        third: 25,
    };
    println!(
        "User Record: ID={}, Name={}, Age={}",
        record.first, record.second, record.third
    );

    // Nested structures
    let nested = Pair {
        first: Pair::new(1, 2),
        second: Triple::new(3, 4, 5),
    };
    println!(
        "Nested: pair=({}, {}), triple=({}, {}, {})",
        nested.first.first,
        nested.first.second,
        nested.second.first,
        nested.second.second,
        nested.second.third
    );
}

pub fn into_tuple(self) -> (F, S, T)

Consumes the triple and returns a tuple of its elements.

Examples

use qubit_common::Triple;

let triple = Triple::new(1, "hello", true);
let (first, second, third) = triple.into_tuple();
assert_eq!(first, 1);
assert_eq!(second, "hello");
assert_eq!(third, true);

Examples found in repository

examples/util_demo.rs (line 97)

fn main() {
    println!("=== Pair Demo ===\n");

    // Create Pair using new method
    let pair1 = Pair::new("name", "Alice");
    println!("pair1 (using new): {}", pair1);

    // Create Pair using struct literal (public fields)
    let mut pair2 = Pair {
        first: 1,
        second: 100,
    };
    println!("pair2 (using struct literal): {}", pair2);

    // Direct field access (public fields)
    pair2.first = 42;
    pair2.second = 200;
    println!("pair2 (after modification): {}", pair2);

    // Using methods
    let pair3 = Pair::new(10, 20);
    println!("pair3: {}", pair3);
    println!("  first: {}, second: {}", pair3.first(), pair3.second());

    // Map operations
    let pair4 = pair3.map_first(|x| x * 2).map_second(|x| x * 3);
    println!("pair4 (after mapping): {}", pair4);

    // Swap
    let pair5 = Pair::new("key", 123);
    let swapped = pair5.swap();
    println!("pair5: {}, swapped: {}", pair5, swapped);

    // Convert to tuple
    let (f, s) = pair5.into_tuple();
    println!("Converted to tuple: ({}, {})", f, s);

    println!("\n=== Triple Demo ===\n");

    // Create Triple using new method
    let triple1 = Triple::new("Alice", 30, true);
    println!("triple1 (using new): {}", triple1);

    // Create Triple using struct literal (public fields)
    let mut triple2 = Triple {
        first: 1,
        second: 2,
        third: 3,
    };
    println!("triple2 (using struct literal): {}", triple2);

    // Direct field access (public fields)
    triple2.first = 10;
    triple2.second = 20;
    triple2.third = 30;
    println!("triple2 (after modification): {}", triple2);

    // Using methods
    let triple3 = Triple::new(100, 200, 300);
    println!("triple3: {}", triple3);
    println!(
        "  first: {}, second: {}, third: {}",
        triple3.first(),
        triple3.second(),
        triple3.third()
    );

    // Map operations
    let triple4 = triple3
        .map_first(|x| x / 10)
        .map_second(|x| x / 10)
        .map_third(|x| x / 10);
    println!("triple4 (after mapping): {}", triple4);

    // Convert to tuple
    let (f, s, t) = triple4.into_tuple();
    println!("Converted to tuple: ({}, {}, {})", f, s, t);

    println!("\n=== Advanced Usage ===\n");

    // Pair with different types
    let config = Pair {
        first: "database_url",
        second: "postgresql://localhost/mydb",
    };
    println!("Config: {}", config);

    // Triple as a record
    let record = Triple {
        first: "user_001",
        second: "Alice",
        third: 25,
    };
    println!(
        "User Record: ID={}, Name={}, Age={}",
        record.first, record.second, record.third
    );

    // Nested structures
    let nested = Pair {
        first: Pair::new(1, 2),
        second: Triple::new(3, 4, 5),
    };
    println!(
        "Nested: pair=({}, {}), triple=({}, {}, {})",
        nested.first.first,
        nested.first.second,
        nested.second.first,
        nested.second.second,
        nested.second.third
    );
}

pub fn first(&self) -> &F

Returns a reference to the first element.

Examples

use qubit_common::Triple;

let triple = Triple::new(1, 2, 3);
assert_eq!(triple.first(), &1);

Examples found in repository

examples/util_demo.rs (line 84)

fn main() {
    println!("=== Pair Demo ===\n");

    // Create Pair using new method
    let pair1 = Pair::new("name", "Alice");
    println!("pair1 (using new): {}", pair1);

    // Create Pair using struct literal (public fields)
    let mut pair2 = Pair {
        first: 1,
        second: 100,
    };
    println!("pair2 (using struct literal): {}", pair2);

    // Direct field access (public fields)
    pair2.first = 42;
    pair2.second = 200;
    println!("pair2 (after modification): {}", pair2);

    // Using methods
    let pair3 = Pair::new(10, 20);
    println!("pair3: {}", pair3);
    println!("  first: {}, second: {}", pair3.first(), pair3.second());

    // Map operations
    let pair4 = pair3.map_first(|x| x * 2).map_second(|x| x * 3);
    println!("pair4 (after mapping): {}", pair4);

    // Swap
    let pair5 = Pair::new("key", 123);
    let swapped = pair5.swap();
    println!("pair5: {}, swapped: {}", pair5, swapped);

    // Convert to tuple
    let (f, s) = pair5.into_tuple();
    println!("Converted to tuple: ({}, {})", f, s);

    println!("\n=== Triple Demo ===\n");

    // Create Triple using new method
    let triple1 = Triple::new("Alice", 30, true);
    println!("triple1 (using new): {}", triple1);

    // Create Triple using struct literal (public fields)
    let mut triple2 = Triple {
        first: 1,
        second: 2,
        third: 3,
    };
    println!("triple2 (using struct literal): {}", triple2);

    // Direct field access (public fields)
    triple2.first = 10;
    triple2.second = 20;
    triple2.third = 30;
    println!("triple2 (after modification): {}", triple2);

    // Using methods
    let triple3 = Triple::new(100, 200, 300);
    println!("triple3: {}", triple3);
    println!(
        "  first: {}, second: {}, third: {}",
        triple3.first(),
        triple3.second(),
        triple3.third()
    );

    // Map operations
    let triple4 = triple3
        .map_first(|x| x / 10)
        .map_second(|x| x / 10)
        .map_third(|x| x / 10);
    println!("triple4 (after mapping): {}", triple4);

    // Convert to tuple
    let (f, s, t) = triple4.into_tuple();
    println!("Converted to tuple: ({}, {}, {})", f, s, t);

    println!("\n=== Advanced Usage ===\n");

    // Pair with different types
    let config = Pair {
        first: "database_url",
        second: "postgresql://localhost/mydb",
    };
    println!("Config: {}", config);

    // Triple as a record
    let record = Triple {
        first: "user_001",
        second: "Alice",
        third: 25,
    };
    println!(
        "User Record: ID={}, Name={}, Age={}",
        record.first, record.second, record.third
    );

    // Nested structures
    let nested = Pair {
        first: Pair::new(1, 2),
        second: Triple::new(3, 4, 5),
    };
    println!(
        "Nested: pair=({}, {}), triple=({}, {}, {})",
        nested.first.first,
        nested.first.second,
        nested.second.first,
        nested.second.second,
        nested.second.third
    );
}

pub fn second(&self) -> &S

Returns a reference to the second element.

Examples

use qubit_common::Triple;

let triple = Triple::new(1, 2, 3);
assert_eq!(triple.second(), &2);

Examples found in repository

examples/util_demo.rs (line 85)

fn main() {
    println!("=== Pair Demo ===\n");

    // Create Pair using new method
    let pair1 = Pair::new("name", "Alice");
    println!("pair1 (using new): {}", pair1);

    // Create Pair using struct literal (public fields)
    let mut pair2 = Pair {
        first: 1,
        second: 100,
    };
    println!("pair2 (using struct literal): {}", pair2);

    // Direct field access (public fields)
    pair2.first = 42;
    pair2.second = 200;
    println!("pair2 (after modification): {}", pair2);

    // Using methods
    let pair3 = Pair::new(10, 20);
    println!("pair3: {}", pair3);
    println!("  first: {}, second: {}", pair3.first(), pair3.second());

    // Map operations
    let pair4 = pair3.map_first(|x| x * 2).map_second(|x| x * 3);
    println!("pair4 (after mapping): {}", pair4);

    // Swap
    let pair5 = Pair::new("key", 123);
    let swapped = pair5.swap();
    println!("pair5: {}, swapped: {}", pair5, swapped);

    // Convert to tuple
    let (f, s) = pair5.into_tuple();
    println!("Converted to tuple: ({}, {})", f, s);

    println!("\n=== Triple Demo ===\n");

    // Create Triple using new method
    let triple1 = Triple::new("Alice", 30, true);
    println!("triple1 (using new): {}", triple1);

    // Create Triple using struct literal (public fields)
    let mut triple2 = Triple {
        first: 1,
        second: 2,
        third: 3,
    };
    println!("triple2 (using struct literal): {}", triple2);

    // Direct field access (public fields)
    triple2.first = 10;
    triple2.second = 20;
    triple2.third = 30;
    println!("triple2 (after modification): {}", triple2);

    // Using methods
    let triple3 = Triple::new(100, 200, 300);
    println!("triple3: {}", triple3);
    println!(
        "  first: {}, second: {}, third: {}",
        triple3.first(),
        triple3.second(),
        triple3.third()
    );

    // Map operations
    let triple4 = triple3
        .map_first(|x| x / 10)
        .map_second(|x| x / 10)
        .map_third(|x| x / 10);
    println!("triple4 (after mapping): {}", triple4);

    // Convert to tuple
    let (f, s, t) = triple4.into_tuple();
    println!("Converted to tuple: ({}, {}, {})", f, s, t);

    println!("\n=== Advanced Usage ===\n");

    // Pair with different types
    let config = Pair {
        first: "database_url",
        second: "postgresql://localhost/mydb",
    };
    println!("Config: {}", config);

    // Triple as a record
    let record = Triple {
        first: "user_001",
        second: "Alice",
        third: 25,
    };
    println!(
        "User Record: ID={}, Name={}, Age={}",
        record.first, record.second, record.third
    );

    // Nested structures
    let nested = Pair {
        first: Pair::new(1, 2),
        second: Triple::new(3, 4, 5),
    };
    println!(
        "Nested: pair=({}, {}), triple=({}, {}, {})",
        nested.first.first,
        nested.first.second,
        nested.second.first,
        nested.second.second,
        nested.second.third
    );
}

pub fn third(&self) -> &T

Returns a reference to the third element.

Examples

use qubit_common::Triple;

let triple = Triple::new(1, 2, 3);
assert_eq!(triple.third(), &3);

Examples found in repository

examples/util_demo.rs (line 86)

fn main() {
    println!("=== Pair Demo ===\n");

    // Create Pair using new method
    let pair1 = Pair::new("name", "Alice");
    println!("pair1 (using new): {}", pair1);

    // Create Pair using struct literal (public fields)
    let mut pair2 = Pair {
        first: 1,
        second: 100,
    };
    println!("pair2 (using struct literal): {}", pair2);

    // Direct field access (public fields)
    pair2.first = 42;
    pair2.second = 200;
    println!("pair2 (after modification): {}", pair2);

    // Using methods
    let pair3 = Pair::new(10, 20);
    println!("pair3: {}", pair3);
    println!("  first: {}, second: {}", pair3.first(), pair3.second());

    // Map operations
    let pair4 = pair3.map_first(|x| x * 2).map_second(|x| x * 3);
    println!("pair4 (after mapping): {}", pair4);

    // Swap
    let pair5 = Pair::new("key", 123);
    let swapped = pair5.swap();
    println!("pair5: {}, swapped: {}", pair5, swapped);

    // Convert to tuple
    let (f, s) = pair5.into_tuple();
    println!("Converted to tuple: ({}, {})", f, s);

    println!("\n=== Triple Demo ===\n");

    // Create Triple using new method
    let triple1 = Triple::new("Alice", 30, true);
    println!("triple1 (using new): {}", triple1);

    // Create Triple using struct literal (public fields)
    let mut triple2 = Triple {
        first: 1,
        second: 2,
        third: 3,
    };
    println!("triple2 (using struct literal): {}", triple2);

    // Direct field access (public fields)
    triple2.first = 10;
    triple2.second = 20;
    triple2.third = 30;
    println!("triple2 (after modification): {}", triple2);

    // Using methods
    let triple3 = Triple::new(100, 200, 300);
    println!("triple3: {}", triple3);
    println!(
        "  first: {}, second: {}, third: {}",
        triple3.first(),
        triple3.second(),
        triple3.third()
    );

    // Map operations
    let triple4 = triple3
        .map_first(|x| x / 10)
        .map_second(|x| x / 10)
        .map_third(|x| x / 10);
    println!("triple4 (after mapping): {}", triple4);

    // Convert to tuple
    let (f, s, t) = triple4.into_tuple();
    println!("Converted to tuple: ({}, {}, {})", f, s, t);

    println!("\n=== Advanced Usage ===\n");

    // Pair with different types
    let config = Pair {
        first: "database_url",
        second: "postgresql://localhost/mydb",
    };
    println!("Config: {}", config);

    // Triple as a record
    let record = Triple {
        first: "user_001",
        second: "Alice",
        third: 25,
    };
    println!(
        "User Record: ID={}, Name={}, Age={}",
        record.first, record.second, record.third
    );

    // Nested structures
    let nested = Pair {
        first: Pair::new(1, 2),
        second: Triple::new(3, 4, 5),
    };
    println!(
        "Nested: pair=({}, {}), triple=({}, {}, {})",
        nested.first.first,
        nested.first.second,
        nested.second.first,
        nested.second.second,
        nested.second.third
    );
}

pub fn first_mut(&mut self) -> &mut F

Returns a mutable reference to the first element.

Examples

use qubit_common::Triple;

let mut triple = Triple::new(1, 2, 3);
*triple.first_mut() = 10;
assert_eq!(triple.first, 10);

pub fn second_mut(&mut self) -> &mut S

Returns a mutable reference to the second element.

Examples

use qubit_common::Triple;

let mut triple = Triple::new(1, 2, 3);
*triple.second_mut() = 20;
assert_eq!(triple.second, 20);

pub fn third_mut(&mut self) -> &mut T

Returns a mutable reference to the third element.

Examples

use qubit_common::Triple;

let mut triple = Triple::new(1, 2, 3);
*triple.third_mut() = 30;
assert_eq!(triple.third, 30);

pub fn map_first<F2, Fn>(self, f: Fn) -> Triple<F2, S, T>

where Fn: FnOnce(F) -> F2,

Maps the first element to a new value using the provided function.

Examples

use qubit_common::Triple;

let triple = Triple::new(1, "hello", true);
let mapped = triple.map_first(|x| x * 2);
assert_eq!(mapped.first, 2);
assert_eq!(mapped.second, "hello");
assert_eq!(mapped.third, true);

Examples found in repository

examples/util_demo.rs (line 91)

fn main() {
    println!("=== Pair Demo ===\n");

    // Create Pair using new method
    let pair1 = Pair::new("name", "Alice");
    println!("pair1 (using new): {}", pair1);

    // Create Pair using struct literal (public fields)
    let mut pair2 = Pair {
        first: 1,
        second: 100,
    };
    println!("pair2 (using struct literal): {}", pair2);

    // Direct field access (public fields)
    pair2.first = 42;
    pair2.second = 200;
    println!("pair2 (after modification): {}", pair2);

    // Using methods
    let pair3 = Pair::new(10, 20);
    println!("pair3: {}", pair3);
    println!("  first: {}, second: {}", pair3.first(), pair3.second());

    // Map operations
    let pair4 = pair3.map_first(|x| x * 2).map_second(|x| x * 3);
    println!("pair4 (after mapping): {}", pair4);

    // Swap
    let pair5 = Pair::new("key", 123);
    let swapped = pair5.swap();
    println!("pair5: {}, swapped: {}", pair5, swapped);

    // Convert to tuple
    let (f, s) = pair5.into_tuple();
    println!("Converted to tuple: ({}, {})", f, s);

    println!("\n=== Triple Demo ===\n");

    // Create Triple using new method
    let triple1 = Triple::new("Alice", 30, true);
    println!("triple1 (using new): {}", triple1);

    // Create Triple using struct literal (public fields)
    let mut triple2 = Triple {
        first: 1,
        second: 2,
        third: 3,
    };
    println!("triple2 (using struct literal): {}", triple2);

    // Direct field access (public fields)
    triple2.first = 10;
    triple2.second = 20;
    triple2.third = 30;
    println!("triple2 (after modification): {}", triple2);

    // Using methods
    let triple3 = Triple::new(100, 200, 300);
    println!("triple3: {}", triple3);
    println!(
        "  first: {}, second: {}, third: {}",
        triple3.first(),
        triple3.second(),
        triple3.third()
    );

    // Map operations
    let triple4 = triple3
        .map_first(|x| x / 10)
        .map_second(|x| x / 10)
        .map_third(|x| x / 10);
    println!("triple4 (after mapping): {}", triple4);

    // Convert to tuple
    let (f, s, t) = triple4.into_tuple();
    println!("Converted to tuple: ({}, {}, {})", f, s, t);

    println!("\n=== Advanced Usage ===\n");

    // Pair with different types
    let config = Pair {
        first: "database_url",
        second: "postgresql://localhost/mydb",
    };
    println!("Config: {}", config);

    // Triple as a record
    let record = Triple {
        first: "user_001",
        second: "Alice",
        third: 25,
    };
    println!(
        "User Record: ID={}, Name={}, Age={}",
        record.first, record.second, record.third
    );

    // Nested structures
    let nested = Pair {
        first: Pair::new(1, 2),
        second: Triple::new(3, 4, 5),
    };
    println!(
        "Nested: pair=({}, {}), triple=({}, {}, {})",
        nested.first.first,
        nested.first.second,
        nested.second.first,
        nested.second.second,
        nested.second.third
    );
}

pub fn map_second<S2, Fn>(self, f: Fn) -> Triple<F, S2, T>

where Fn: FnOnce(S) -> S2,

Maps the second element to a new value using the provided function.

Examples

use qubit_common::Triple;

let triple = Triple::new(1, "hello", true);
let mapped = triple.map_second(|s| s.len());
assert_eq!(mapped.first, 1);
assert_eq!(mapped.second, 5);
assert_eq!(mapped.third, true);

Examples found in repository

examples/util_demo.rs (line 92)

fn main() {
    println!("=== Pair Demo ===\n");

    // Create Pair using new method
    let pair1 = Pair::new("name", "Alice");
    println!("pair1 (using new): {}", pair1);

    // Create Pair using struct literal (public fields)
    let mut pair2 = Pair {
        first: 1,
        second: 100,
    };
    println!("pair2 (using struct literal): {}", pair2);

    // Direct field access (public fields)
    pair2.first = 42;
    pair2.second = 200;
    println!("pair2 (after modification): {}", pair2);

    // Using methods
    let pair3 = Pair::new(10, 20);
    println!("pair3: {}", pair3);
    println!("  first: {}, second: {}", pair3.first(), pair3.second());

    // Map operations
    let pair4 = pair3.map_first(|x| x * 2).map_second(|x| x * 3);
    println!("pair4 (after mapping): {}", pair4);

    // Swap
    let pair5 = Pair::new("key", 123);
    let swapped = pair5.swap();
    println!("pair5: {}, swapped: {}", pair5, swapped);

    // Convert to tuple
    let (f, s) = pair5.into_tuple();
    println!("Converted to tuple: ({}, {})", f, s);

    println!("\n=== Triple Demo ===\n");

    // Create Triple using new method
    let triple1 = Triple::new("Alice", 30, true);
    println!("triple1 (using new): {}", triple1);

    // Create Triple using struct literal (public fields)
    let mut triple2 = Triple {
        first: 1,
        second: 2,
        third: 3,
    };
    println!("triple2 (using struct literal): {}", triple2);

    // Direct field access (public fields)
    triple2.first = 10;
    triple2.second = 20;
    triple2.third = 30;
    println!("triple2 (after modification): {}", triple2);

    // Using methods
    let triple3 = Triple::new(100, 200, 300);
    println!("triple3: {}", triple3);
    println!(
        "  first: {}, second: {}, third: {}",
        triple3.first(),
        triple3.second(),
        triple3.third()
    );

    // Map operations
    let triple4 = triple3
        .map_first(|x| x / 10)
        .map_second(|x| x / 10)
        .map_third(|x| x / 10);
    println!("triple4 (after mapping): {}", triple4);

    // Convert to tuple
    let (f, s, t) = triple4.into_tuple();
    println!("Converted to tuple: ({}, {}, {})", f, s, t);

    println!("\n=== Advanced Usage ===\n");

    // Pair with different types
    let config = Pair {
        first: "database_url",
        second: "postgresql://localhost/mydb",
    };
    println!("Config: {}", config);

    // Triple as a record
    let record = Triple {
        first: "user_001",
        second: "Alice",
        third: 25,
    };
    println!(
        "User Record: ID={}, Name={}, Age={}",
        record.first, record.second, record.third
    );

    // Nested structures
    let nested = Pair {
        first: Pair::new(1, 2),
        second: Triple::new(3, 4, 5),
    };
    println!(
        "Nested: pair=({}, {}), triple=({}, {}, {})",
        nested.first.first,
        nested.first.second,
        nested.second.first,
        nested.second.second,
        nested.second.third
    );
}

pub fn map_third<T2, Fn>(self, f: Fn) -> Triple<F, S, T2>

where Fn: FnOnce(T) -> T2,

Maps the third element to a new value using the provided function.

Examples

use qubit_common::Triple;

let triple = Triple::new(1, "hello", true);
let mapped = triple.map_third(|b| if b { "yes" } else { "no" });
assert_eq!(mapped.first, 1);
assert_eq!(mapped.second, "hello");
assert_eq!(mapped.third, "yes");

Examples found in repository

examples/util_demo.rs (line 93)

fn main() {
    println!("=== Pair Demo ===\n");

    // Create Pair using new method
    let pair1 = Pair::new("name", "Alice");
    println!("pair1 (using new): {}", pair1);

    // Create Pair using struct literal (public fields)
    let mut pair2 = Pair {
        first: 1,
        second: 100,
    };
    println!("pair2 (using struct literal): {}", pair2);

    // Direct field access (public fields)
    pair2.first = 42;
    pair2.second = 200;
    println!("pair2 (after modification): {}", pair2);

    // Using methods
    let pair3 = Pair::new(10, 20);
    println!("pair3: {}", pair3);
    println!("  first: {}, second: {}", pair3.first(), pair3.second());

    // Map operations
    let pair4 = pair3.map_first(|x| x * 2).map_second(|x| x * 3);
    println!("pair4 (after mapping): {}", pair4);

    // Swap
    let pair5 = Pair::new("key", 123);
    let swapped = pair5.swap();
    println!("pair5: {}, swapped: {}", pair5, swapped);

    // Convert to tuple
    let (f, s) = pair5.into_tuple();
    println!("Converted to tuple: ({}, {})", f, s);

    println!("\n=== Triple Demo ===\n");

    // Create Triple using new method
    let triple1 = Triple::new("Alice", 30, true);
    println!("triple1 (using new): {}", triple1);

    // Create Triple using struct literal (public fields)
    let mut triple2 = Triple {
        first: 1,
        second: 2,
        third: 3,
    };
    println!("triple2 (using struct literal): {}", triple2);

    // Direct field access (public fields)
    triple2.first = 10;
    triple2.second = 20;
    triple2.third = 30;
    println!("triple2 (after modification): {}", triple2);

    // Using methods
    let triple3 = Triple::new(100, 200, 300);
    println!("triple3: {}", triple3);
    println!(
        "  first: {}, second: {}, third: {}",
        triple3.first(),
        triple3.second(),
        triple3.third()
    );

    // Map operations
    let triple4 = triple3
        .map_first(|x| x / 10)
        .map_second(|x| x / 10)
        .map_third(|x| x / 10);
    println!("triple4 (after mapping): {}", triple4);

    // Convert to tuple
    let (f, s, t) = triple4.into_tuple();
    println!("Converted to tuple: ({}, {}, {})", f, s, t);

    println!("\n=== Advanced Usage ===\n");

    // Pair with different types
    let config = Pair {
        first: "database_url",
        second: "postgresql://localhost/mydb",
    };
    println!("Config: {}", config);

    // Triple as a record
    let record = Triple {
        first: "user_001",
        second: "Alice",
        third: 25,
    };
    println!(
        "User Record: ID={}, Name={}, Age={}",
        record.first, record.second, record.third
    );

    // Nested structures
    let nested = Pair {
        first: Pair::new(1, 2),
        second: Triple::new(3, 4, 5),
    };
    println!(
        "Nested: pair=({}, {}), triple=({}, {}, {})",
        nested.first.first,
        nested.first.second,
        nested.second.first,
        nested.second.second,
        nested.second.third
    );
}

Trait Implementations

impl<F: Clone, S: Clone, T: Clone> Clone for Triple<F, S, T>

fn clone(&self) -> Triple<F, S, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug, S: Debug, T: Debug> Debug for Triple<F, S, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Default, S: Default, T: Default> Default for Triple<F, S, T>

fn default() -> Triple<F, S, T>

Returns the “default value” for a type.

impl<F: Display, S: Display, T: Display> Display for Triple<F, S, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F, S, T> From<(F, S, T)> for Triple<F, S, T>

fn from(tuple: (F, S, T)) -> Self

Creates a Triple from a tuple.

Examples

use qubit_common::Triple;

let triple: Triple<i32, &str, bool> = (1, "hello", true).into();
assert_eq!(triple.first, 1);
assert_eq!(triple.second, "hello");
assert_eq!(triple.third, true);

impl<F, S, T> From<Triple<F, S, T>> for (F, S, T)

fn from(triple: Triple<F, S, T>) -> Self

Converts a Triple into a tuple.

Examples

use qubit_common::Triple;

let triple = Triple::new(1, "hello", true);
let tuple: (i32, &str, bool) = triple.into();
assert_eq!(tuple, (1, "hello", true));

impl<F: Hash, S: Hash, T: Hash> Hash for Triple<F, S, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: PartialEq, S: PartialEq, T: PartialEq> PartialEq for Triple<F, S, T>

fn eq(&self, other: &Triple<F, S, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: Copy, S: Copy, T: Copy> Copy for Triple<F, S, T>

impl<F: Eq, S: Eq, T: Eq> Eq for Triple<F, S, T>

impl<F, S, T> StructuralPartialEq for Triple<F, S, T>