Crate partial_cmp_derive 

partial-cmp-derive

A procedural macro crate for deriving PartialEq, Eq, PartialOrd, and Ord with fine-grained control over field comparison behavior.

Features

• Skip fields: Use #[ord(skip)] to exclude fields from all comparisons. Skipped fields are ignored in both equality and ordering checks.
• Sort order: Use #[ord(order = "asc")] or #[ord(order = "desc")] per field
• Explicit ordering: Use #[ord(by = [field1(desc), field2(asc)])] at struct level
• Field priority: Use #[ord(priority = N)] for implicit ordering (lower = first)
• Custom comparators: Use #[ord(compare_with = "path::to::fn")] for ordering
• Custom equality: Use #[ord(eq_with = "path::to::fn")] for equality checks
• Reverse all: Use #[ord(reverse)] at struct level to reverse entire comparison
• Enum ranking: Use #[ord(rank = N)] to control variant ordering
• Option handling: Use #[ord(none_order = "first")] or "last"
• Trait selection: Control which traits are generated with skip flags

Trait Generation

By default, all four comparison traits are generated: PartialEq, Eq, PartialOrd, and Ord. You can opt out of specific traits:

• #[ord(skip_partial_eq)] — Don’t generate PartialEq (implies no other traits)
• #[ord(skip_eq)] — Don’t generate Eq (implies no Ord)
• #[ord(skip_partial_ord)] — Don’t generate PartialOrd (implies no Ord)
• #[ord(skip_ord)] — Don’t generate Ord

Example

use partial_cmp_derive::PartialCmp;

// Generates PartialEq, Eq, PartialOrd, and Ord
#[derive(PartialCmp)]
struct Point {
    x: i32,
    y: i32,
}

// Skipped fields are excluded from all comparisons
// Use skip_eq and skip_ord when non-skipped fields don't implement Eq/Ord
#[derive(Debug, PartialCmp)]
#[ord(skip_eq, skip_ord)]
struct Measurement {
    #[ord(skip)]
    raw_value: f32,  // Ignored in eq and cmp
    timestamp: u64,
}

// Only generate PartialEq and PartialOrd (for types like f32)
#[derive(Debug, PartialCmp)]
#[ord(skip_eq, skip_ord)]
struct PartialOnly {
    #[ord(compare_with = "cmp_f32")]
    value: f32,
}

fn cmp_f32(a: &f32, b: &f32) -> std::cmp::Ordering {
    a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)
}

This generates consistent implementations where skipped fields are ignored in both equality and ordering comparisons.

Derive Macros

PartialCmp

Derives comparison traits with customizable field behavior.