logaritmiskandClaude Opus 5
7ca0daa48e
`Rating` already derived `PartialEq`, but that derive is only reachable through `D: PartialEq` — and `ConstantDrift`, the crate's own only `Drift` impl, did not satisfy it. So the derive was there and unusable. Found by writing the comparison from a consumer's position rather than reading the derive list. `ConstantDrift`, `ConvergenceOptions` and `GameOptions` now derive `PartialEq`. All three are pure configuration; comparing two is the natural thing to want and nothing about them makes equality ambiguous. `tests/trait_impls.rs` pins the surface, written the way the failure was reported: a consumer struct that *holds* a `History` and derives `Debug`. It also asserts `History`'s `Debug` summarises rather than dumping its skill stores, so a future derive cannot quietly replace the hand-written impl. `Clone` on `History` stays off. It is a decision, not an omission: a history owns every slice's skill store and arena, so cloning one is proportional to the whole fit, and no consumer has wanted it. Closes #76. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_011hcFjNDmHXZF8URGLku5zZ
97 lines
3.1 KiB
Rust
97 lines
3.1 KiB
Rust
//! The traits a consumer needs on the public types, pinned so they cannot be
|
|
//! removed by accident.
|
|
//!
|
|
//! This is written from a consumer's position — deriving `Debug` on a struct
|
|
//! that *holds* a `History` — because that is the thing that failed. Asserting
|
|
//! `History: Debug` in isolation would not have caught the generic-bound half:
|
|
//! `Rating` derives `PartialEq`, but that is only usable if `D: PartialEq`, and
|
|
//! the crate's own only `Drift` impl did not satisfy it.
|
|
|
|
use trueskill_tt::{
|
|
ConstantDrift, ConvergenceOptions, ConvergenceReport, Event, GameOptions, Gaussian, History,
|
|
HistoryBuilder, InferenceError, Member, Outcome, Rating, Team,
|
|
};
|
|
|
|
/// The reported failure, verbatim: a consumer holding a history in app state.
|
|
#[derive(Debug)]
|
|
#[allow(
|
|
dead_code,
|
|
reason = "held only so `derive(Debug)` has something to render"
|
|
)]
|
|
struct App {
|
|
history: History,
|
|
}
|
|
|
|
#[test]
|
|
fn a_struct_holding_a_history_can_derive_debug() {
|
|
let app = App {
|
|
history: History::default(),
|
|
};
|
|
|
|
let rendered = format!("{app:?}");
|
|
|
|
// Summarising, not a dump of every skill store — the same choice `Joint`'s
|
|
// manual `Debug` makes about its n² factorisation.
|
|
assert!(rendered.contains("competitors"), "{rendered}");
|
|
assert!(rendered.contains("time_slices"), "{rendered}");
|
|
assert!(
|
|
!rendered.contains("SkillStore"),
|
|
"History's Debug should summarise, not dump: {rendered}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn history_builder_is_debug_and_clone() {
|
|
let b: HistoryBuilder<i64, ConstantDrift, _, &'static str> = History::builder();
|
|
let cloned = b.clone();
|
|
assert!(!format!("{cloned:?}").is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn config_and_input_value_types_are_comparable() {
|
|
assert_eq!(ConstantDrift::new(0.1), ConstantDrift::new(0.1));
|
|
assert_ne!(ConstantDrift::new(0.1), ConstantDrift::new(0.2));
|
|
|
|
assert_eq!(ConvergenceOptions::default(), ConvergenceOptions::default());
|
|
assert_eq!(GameOptions::default(), GameOptions::default());
|
|
|
|
// `Rating: PartialEq` is only reachable through `D: PartialEq`.
|
|
assert_eq!(Rating::<i64, ConstantDrift>::default(), Rating::default());
|
|
assert_ne!(
|
|
Rating::default(),
|
|
Rating::<i64, ConstantDrift>::default().with_drift_scale(2.0)
|
|
);
|
|
|
|
assert_eq!(Member::new("a"), Member::new("a"));
|
|
assert_ne!(Member::new("a"), Member::new("b"));
|
|
assert_eq!(
|
|
Team::with_members([Member::new("a")]),
|
|
Team::with_members([Member::new("a")])
|
|
);
|
|
|
|
let event = || Event {
|
|
time: 1,
|
|
teams: [
|
|
Team::with_members([Member::new("a")]),
|
|
Team::with_members([Member::new("b")]),
|
|
]
|
|
.into_iter()
|
|
.collect(),
|
|
outcome: Outcome::winner(0, 2),
|
|
};
|
|
assert_eq!(event(), event());
|
|
|
|
assert_eq!(Gaussian::default(), Gaussian::default());
|
|
}
|
|
|
|
#[test]
|
|
fn a_history_is_send_and_sync_and_default() {
|
|
fn assert_send_sync<X: Send + Sync>() {}
|
|
assert_send_sync::<History>();
|
|
assert_send_sync::<InferenceError>();
|
|
|
|
let mut h = History::default();
|
|
let report: ConvergenceReport = h.converge().expect("an empty history converges");
|
|
assert_eq!(report, report.clone());
|
|
}
|