Struct SortedPair

pub struct SortedPair<T: PartialOrd>(/* private fields */);

A pair of elements sorted in increasing order.

This structure guarantees that the first element is always less than or equal to the second element. It is useful for representing edges, connections, or any unordered pair where you want canonical ordering (e.g., ensuring that edge (A, B) and edge (B, A) are treated as the same edge).

The sorted pair implements Deref to (T, T) for convenient access to the elements.

Examples

Creating a Sorted Pair

// Create a pair - the elements will be sorted automatically
let pair1 = SortedPair::new(5, 2);
let pair2 = SortedPair::new(2, 5);

// Both pairs are equal because they contain the same sorted elements
assert_eq!(pair1, pair2);

// Access elements via dereferencing
assert_eq!(pair1.0, 2);
assert_eq!(pair1.1, 5);

Using as HashMap Keys

use std::collections::HashMap;

let mut edge_weights = HashMap::new();

// These represent the same edge, so they'll map to the same entry
edge_weights.insert(SortedPair::new(1, 3), 10.0);
edge_weights.insert(SortedPair::new(3, 1), 20.0); // Overwrites previous

assert_eq!(edge_weights.len(), 1);
assert_eq!(edge_weights.get(&SortedPair::new(1, 3)), Some(&20.0));

Representing Graph Edges

// Represent undirected edges in a graph
let edges = vec![
    SortedPair::new(0, 1),  // Edge between vertices 0 and 1
    SortedPair::new(1, 2),  // Edge between vertices 1 and 2
    SortedPair::new(2, 0),  // Edge between vertices 2 and 0
];

// Check if a specific edge exists (order doesn't matter)
let query_edge = SortedPair::new(2, 1);
assert!(edges.contains(&query_edge));

Ordering

let pair1 = SortedPair::new(1, 5);
let pair2 = SortedPair::new(2, 3);
let pair3 = SortedPair::new(1, 6);

// Pairs are compared lexicographically (first element, then second)
assert!(pair1 < pair2);  // (1, 5) < (2, 3)
assert!(pair1 < pair3);  // (1, 5) < (1, 6)

Implementations

impl<T: PartialOrd> SortedPair<T>

pub fn new(element1: T, element2: T) -> Self

Sorts two elements in increasing order into a new pair.

Arguments

• element1 - The first element
• element2 - The second element

Returns

A SortedPair where the smaller element comes first.

Examples

let pair = SortedPair::new(10, 5);

// Elements are automatically sorted
assert_eq!(pair.0, 5);
assert_eq!(pair.1, 10);

Trait Implementations

impl<T: Clone + PartialOrd> Clone for SortedPair<T>

fn clone(&self) -> SortedPair<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + PartialOrd> Debug for SortedPair<T>

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

Formats the value using the given formatter.

impl<T: PartialOrd> Deref for SortedPair<T>

type Target = (T, T)

The resulting type after dereferencing.

fn deref(&self) -> &(T, T)

Dereferences the value.

impl<T: Hash + PartialOrd> Hash for SortedPair<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<T: Ord + PartialOrd> Ord for SortedPair<T>

fn cmp(&self, other: &SortedPair<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + PartialOrd> PartialEq for SortedPair<T>

fn eq(&self, other: &SortedPair<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<T: PartialOrd + PartialOrd> PartialOrd for SortedPair<T>

fn partial_cmp(&self, other: &SortedPair<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy + PartialOrd> Copy for SortedPair<T>

impl<T: Eq + PartialOrd> Eq for SortedPair<T>

impl<T: PartialOrd> StructuralPartialEq for SortedPair<T>