Enum Fusion 

pub enum Fusion {
    Rrf {
        k: u32,
    },
    Weighted {
        weights: Vec<f32>,
    },
}

How to combine several ranked SearchHit lists into one — the join point for hybrid retrieval (e.g. a dense branch plus a sparse/lexical branch).

Choose by whether the branches’ scores are comparable. Rrf looks only at ranks, so it is safe when the branches use different similarity measures (cosine vs inner product) or wildly different scales; Weighted sums raw scores and therefore assumes the branches are already on a shared scale.

Which to use for dense + sparse

A dense branch scores by cosine similarity (range roughly 0.0–1.0) while a learned-lexical sparse branch scores by inner product (BGE-M3 sparse weights commonly sum to the tens or hundreds). Their scales do not agree, so fusing them with Weighted directly lets the sparse branch dominate regardless of the chosen weights. Prefer Rrf when the branches disagree on scale — it is the default for exactly this reason. If you need Weighted, normalize each branch to a shared scale first (e.g. min-max to [0,1], or softmax over the branch’s scores).

Scores are carried in SearchHit as f32. Inner-product scores are large enough that the f64 → f32 narrowing in the backends can lose precision in the low digits; this does not affect Rrf (rank-only) but is a further reason to normalize before Weighted.

Variants

Rrf

Reciprocal Rank Fusion: score(d) = Σ 1 / (k + rank_i(d)) over the lists containing d, with 1-based ranks. Larger k flattens the advantage of top ranks; 60 is the conventional default.

Fields

k: u32

Rank damping constant — larger values flatten the advantage held by top-ranked hits. 60 is the conventional default.

Weighted

Convex combination of raw scores, one weight per input list. A list that does not contain a hit contributes nothing for it.

All input lists must share a score scale. Do not fuse a cosine branch with a raw inner-product branch without normalizing first — see the type-level docs and Rrf for the scale-safe option.

Fields

weights: Vec<f32>

One weight per input list, in the same order as the lists passed to fuse.

Implementations

impl Fusion

pub fn rrf() -> Self

Reciprocal Rank Fusion with the conventional k = 60.

This is the recommended default for hybrid dense + sparse retrieval: being rank-only, it is unaffected by the mismatched score scales of cosine and inner product. See the Fusion type docs.

pub fn fuse(&self, hit_sets: &[Vec<SearchHit>]) -> Vec<SearchHit>

Fuse ranked lists into a single list, best first.

Every input list is expected to be sorted best-first already — RRF derives its ranks from that order. The result uses the same ordering as SearchHit itself: descending score, then ascending id.

Panics

Weighted panics when the number of weights differs from the number of lists, mirroring search::weighted_sum_fuse: a mismatch means a branch would be silently dropped from the ranking.

Trait Implementations

impl Clone for Fusion

fn clone(&self) -> Fusion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fusion

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

Formats the value using the given formatter.

impl PartialEq for Fusion

fn eq(&self, other: &Fusion) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Fusion