Struct SimiFlow 

pub struct SimiFlow { /* private fields */ }

The SimiFlow: a declarative pipeline builder for similarity checks.

use simi::router::{SimiFlow, Strategy, Threshold, Algo};

let result = SimiFlow::new()
    .preprocess(true)
    .strategy(Strategy::Cascade)
    .tier_1(Algo::JaroWinkler, Threshold::GreaterThan(0.95), Threshold::LessThan(0.10))
    .tier_2(Algo::Bm25, Threshold::Between(0.60, 0.94))
    .compare("hello world", "hello there");

Implementations

impl SimiFlow

pub fn new() -> Self

Create a new SimiFlow with default settings.

pub fn for_intent(intent: Intent) -> Self

Create a SimiFlow pre-configured for a specific intent.

The intent picks the algorithm and reasonable default thresholds.

use simi::router::{SimiFlow, Intent};

let result = SimiFlow::for_intent(Intent::Names)
    .compare("MARTHA", "MARHTA")
    .unwrap();

pub fn auto() -> Self

Create a SimiFlow that auto-detects the best algorithm from inputs.

The algorithm is re-resolved at each compare() call based on the actual input lengths. Short equal-length strings get Hamming, short-medium get Jaro-Winkler, medium get BM25, long get SimHash.

pub fn compare_with_intent( &self, intent: Intent, a: &str, b: &str, ) -> Result<ComparisonResult, SimiError>

Compare two strings, picking the algorithm based on intent at call time.

This ignores any configured tiers and runs the intent-selected algorithm directly.

pub fn preprocess(self, enable: bool) -> Self

Enable or disable preprocessing.

pub fn with_preprocessor(self, pre: Preprocessor) -> Self

Set a custom preprocessor.

pub fn strategy(self, s: Strategy) -> Self

Set the comparison strategy.

pub fn tier_1( self, algo: Algo, match_threshold: Threshold, mismatch_threshold: Threshold, ) -> Self

Configure Tier 1 (Fast Pass) with algorithm and thresholds.

match_threshold: if score > this, return immediately as match. mismatch_threshold: if score < this, return immediately as mismatch.

pub fn tier_2(self, algo: Algo, threshold: Threshold) -> Self

Configure Tier 2 (Heavy Local Pass) with algorithm and threshold range.

pub fn fallback<F>(self, f: F) -> Self

where F: Fn(&str, &str) -> (Score, Option<String>) + Send + Sync + 'static,

Set the Tier 3 fallback (LLM/API hook).

pub fn compare(&self, a: &str, b: &str) -> Result<ComparisonResult, SimiError>

Compare two strings through the pipeline.

Returns a ComparisonResult with the final score and decision metadata.

When auto_mode is true (created via SimiFlow::auto()), the algorithm is selected per pair based on input lengths.

Trait Implementations

impl Default for SimiFlow

fn default() -> Self

Returns the “default value” for a type.