Struct Pair 

pub struct Pair<F, S> {
    pub first: F,
    pub second: S,
}

A generic pair structure that holds two values.

Type Parameters

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

Pair vs. Tuple

While Rust’s native tuples (F, S) can also hold two values, Pair<F, S> provides several advantages:

Similarities

• Both can hold two values of different types
• Both support pattern matching and destructuring
• Both can be converted to each other via From/Into traits

Differences

Feature	Pair<F, S>	(F, S)
Named fields	✓ Uses .first and .second	✗ Uses .0 and .1
Semantic clarity	✓ More readable and self-documenting	✗ Less clear what each element represents
Method chaining	✓ Provides map_first(), map_second(), swap()	✗ No built-in transformation methods
Mutable access	✓ Provides first_mut() and second_mut()	✓ Direct field mutation
Type aliases	✓ Can create meaningful type aliases	✓ Can create type aliases
Pattern matching	✓ Pair { first, second }	✓ (first, second)

When to Use Pair

Use Pair<F, S> when:

• You want more readable code with named fields (.first, .second vs .0, .1)
• You need transformation methods like map_first() or swap()
• You’re building a public API where clarity is important
• You want to create semantic type aliases (e.g., type Coordinate = Pair<f64, f64>)

When to Use Tuples

Use native tuples (F, S) when:

• You need a quick, lightweight data structure for internal use
• You’re returning multiple values from a function temporarily
• You need to match Rust’s standard library APIs that use tuples
• Performance is critical (though the difference is negligible in practice)

Examples

use qubit_common::Pair;

let pair = Pair::new("name", 42);
assert_eq!(pair.first, "name");
assert_eq!(pair.second, 42);

let pair = Pair { first: 1, second: 2.5 };
assert_eq!(pair.first, 1);
assert_eq!(pair.second, 2.5);

Fields

first: F

The first element of the pair

second: S

The second element of the pair

Implementations

impl<F, S> Pair<F, S>

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

Creates a new Pair with the given values.

Arguments

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

Examples

use qubit_common::Pair;

let pair = Pair::new(1, "hello");
assert_eq!(pair.first, 1);
assert_eq!(pair.second, "hello");

Examples found in repository

examples/util_demo.rs (line 26)

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)

Consumes the pair and returns a tuple of its elements.

Examples

use qubit_common::Pair;

let pair = Pair::new(1, "hello");
let (first, second) = pair.into_tuple();
assert_eq!(first, 1);
assert_eq!(second, "hello");

Examples found in repository

examples/util_demo.rs (line 56)

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::Pair;

let pair = Pair::new(1, 2);
assert_eq!(pair.first(), &1);

Examples found in repository

examples/util_demo.rs (line 44)

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::Pair;

let pair = Pair::new(1, 2);
assert_eq!(pair.second(), &2);

Examples found in repository

examples/util_demo.rs (line 44)

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::Pair;

let mut pair = Pair::new(1, 2);
*pair.first_mut() = 10;
assert_eq!(pair.first, 10);

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

Returns a mutable reference to the second element.

Examples

use qubit_common::Pair;

let mut pair = Pair::new(1, 2);
*pair.second_mut() = 20;
assert_eq!(pair.second, 20);

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

where Fn: FnOnce(F) -> F2,

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

Examples

use qubit_common::Pair;

let pair = Pair::new(1, "hello");
let mapped = pair.map_first(|x| x * 2);
assert_eq!(mapped.first, 2);
assert_eq!(mapped.second, "hello");

Examples found in repository

examples/util_demo.rs (line 47)

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) -> Pair<F, S2>

where Fn: FnOnce(S) -> S2,

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

Examples

use qubit_common::Pair;

let pair = Pair::new(1, "hello");
let mapped = pair.map_second(|s| s.len());
assert_eq!(mapped.first, 1);
assert_eq!(mapped.second, 5);

Examples found in repository

examples/util_demo.rs (line 47)

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 swap(self) -> Pair<S, F>

Swaps the elements of the pair.

Examples

use qubit_common::Pair;

let pair = Pair::new(1, "hello");
let swapped = pair.swap();
assert_eq!(swapped.first, "hello");
assert_eq!(swapped.second, 1);

Examples found in repository

examples/util_demo.rs (line 52)

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> Clone for Pair<F, S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug, S: Debug> Debug for Pair<F, S>

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

Formats the value using the given formatter.

impl<F: Default, S: Default> Default for Pair<F, S>

fn default() -> Pair<F, S>

Returns the “default value” for a type.

impl<F: Display, S: Display> Display for Pair<F, S>

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

Formats the value using the given formatter.

impl<F, S> From<(F, S)> for Pair<F, S>

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

Creates a Pair from a tuple.

Examples

use qubit_common::Pair;

let pair: Pair<i32, &str> = (1, "hello").into();
assert_eq!(pair.first, 1);
assert_eq!(pair.second, "hello");

impl<F, S> From<Pair<F, S>> for (F, S)

fn from(pair: Pair<F, S>) -> Self

Converts a Pair into a tuple.

Examples

use qubit_common::Pair;

let pair = Pair::new(1, "hello");
let tuple: (i32, &str) = pair.into();
assert_eq!(tuple, (1, "hello"));

impl<F: Hash, S: Hash> Hash for Pair<F, S>

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> PartialEq for Pair<F, S>

fn eq(&self, other: &Pair<F, S>) -> 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> Copy for Pair<F, S>

impl<F: Eq, S: Eq> Eq for Pair<F, S>

impl<F, S> StructuralPartialEq for Pair<F, S>