#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Candidate<Id, Metadata = ()> {
pub id: Id,
pub metadata: Metadata,
}
impl<Id, Metadata> Candidate<Id, Metadata> {
pub fn new(id: Id, metadata: Metadata) -> Self {
Self { id, metadata }
}
}
impl<Id> Candidate<Id> {
pub fn bare(id: Id) -> Self {
Self { id, metadata: () }
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Scored<Id, Metadata = ()> {
pub candidate: Candidate<Id, Metadata>,
pub score: f32,
}
impl<Id, Metadata> Scored<Id, Metadata> {
pub fn new(id: Id, score: f32, metadata: Metadata) -> Self {
Self {
candidate: Candidate::new(id, metadata),
score,
}
}
pub fn id(&self) -> &Id {
&self.candidate.id
}
pub fn cmp_score_desc(&self, other: &Self) -> std::cmp::Ordering {
other.score.total_cmp(&self.score)
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RankedList<Id, Metadata = ()> {
pub items: Vec<Candidate<Id, Metadata>>,
}
impl<Id, Metadata> RankedList<Id, Metadata> {
pub fn new(items: Vec<Candidate<Id, Metadata>>) -> Self {
Self { items }
}
pub fn len(&self) -> usize {
self.items.len()
}
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
}
impl<Id, Metadata> Default for RankedList<Id, Metadata> {
fn default() -> Self {
Self { items: Vec::new() }
}
}
impl<Id> FromIterator<Id> for RankedList<Id> {
fn from_iter<T: IntoIterator<Item = Id>>(iter: T) -> Self {
Self::new(iter.into_iter().map(Candidate::bare).collect())
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScoredList<Id, Metadata = ()> {
pub items: Vec<Scored<Id, Metadata>>,
}
impl<Id, Metadata> ScoredList<Id, Metadata> {
pub fn new(items: Vec<Scored<Id, Metadata>>) -> Self {
Self { items }
}
pub fn len(&self) -> usize {
self.items.len()
}
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
}
impl<Id, Metadata> Default for ScoredList<Id, Metadata> {
fn default() -> Self {
Self { items: Vec::new() }
}
}
impl<Id, Metadata> From<ScoredList<Id, Metadata>> for RankedList<Id, Metadata> {
fn from(scored: ScoredList<Id, Metadata>) -> Self {
Self {
items: scored.items.into_iter().map(|s| s.candidate).collect(),
}
}
}
pub trait MergePolicy<Metadata> {
fn merge(&self, kept: &mut Metadata, incoming: Metadata);
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct FirstWins;
impl<Metadata> MergePolicy<Metadata> for FirstWins {
fn merge(&self, _kept: &mut Metadata, _incoming: Metadata) {}
}
impl<Metadata, F> MergePolicy<Metadata> for F
where
F: Fn(&mut Metadata, Metadata),
{
fn merge(&self, kept: &mut Metadata, incoming: Metadata) {
self(kept, incoming);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn generic_ids() {
let a = Candidate::bare(42u64);
let b = Candidate::bare("doc-1".to_string());
let c = Candidate::new(7u32, "payload");
assert_eq!(a.id, 42);
assert_eq!(b.id, "doc-1");
assert_eq!(c.metadata, "payload");
}
#[test]
fn empty_and_single_element_lists() {
let empty: RankedList<u64> = RankedList::default();
assert!(empty.is_empty());
let single: RankedList<u64> = [1u64].into_iter().collect();
assert_eq!(single.len(), 1);
let scored = ScoredList::new(vec![Scored::new(1u64, 0.5, ())]);
assert_eq!(scored.len(), 1);
}
#[test]
fn scored_list_converts_to_ranked_list() {
let scored = ScoredList::new(vec![Scored::new("a", 0.9, ()), Scored::new("b", 0.4, ())]);
let ranked: RankedList<&str> = scored.into();
let ids: Vec<&str> = ranked.items.iter().map(|c| c.id).collect();
assert_eq!(ids, ["a", "b"]);
}
#[test]
fn first_wins_keeps_earliest_metadata() {
let mut kept = "from-list-0";
MergePolicy::merge(&FirstWins, &mut kept, "from-list-1");
assert_eq!(kept, "from-list-0");
}
#[test]
fn closure_merge_policy_overrides() {
let concat = |kept: &mut String, incoming: String| {
kept.push('+');
kept.push_str(&incoming);
};
let mut kept = String::from("v1");
MergePolicy::merge(&concat, &mut kept, String::from("v2"));
assert_eq!(kept, "v1+v2");
}
#[test]
fn nan_score_ordering_is_total_and_deterministic() {
let mut items = [
Scored::new("nan", f32::NAN, ()),
Scored::new("low", -1.0, ()),
Scored::new("high", 10.0, ()),
Scored::new("neg-inf", f32::NEG_INFINITY, ()),
Scored::new("pos-inf", f32::INFINITY, ()),
];
items.sort_by(Scored::cmp_score_desc);
let ids: Vec<&str> = items.iter().map(|s| *s.id()).collect();
assert_eq!(ids, ["nan", "pos-inf", "high", "low", "neg-inf"]);
let before = ids.clone();
items.sort_by(Scored::cmp_score_desc);
let after: Vec<&str> = items.iter().map(|s| *s.id()).collect();
assert_eq!(before, after);
}
#[test]
fn duplicate_candidate_across_lists_is_representable() {
let list_a: RankedList<u64, &str> = RankedList::new(vec![
Candidate::new(1, "meta-a"),
Candidate::new(2, "meta-a"),
]);
let list_b: RankedList<u64, &str> = RankedList::new(vec![Candidate::new(1, "meta-b")]);
assert_eq!(list_a.items[0].id, list_b.items[0].id);
assert_ne!(list_a.items[0].metadata, list_b.items[0].metadata);
}
}