feat: add Arinae algorithm

.gitignore

@@ -22,3 +22,9 @@ codecov.json
 *.profraw
 
 benches/fixtures/*.txt
+
+# Profiling
+profile.json.gz
+perf.data.old
+perf.data
+flamegraph.svg

Cargo.toml

@@ -21,6 +21,11 @@ strip = true
 [profile.dist]
 inherits = "release"
 
+[profile.release-debug]
+inherits = "release"
+debug = true
+strip = false
+
 
 [lib]
 name = "skim"
@@ -57,6 +62,7 @@ thiserror = "=2.0.18"
 tempfile = "=3.25.0"
 crossterm = { version = ">=0.0.0", features = ["event-stream", "use-dev-tty", "libc"] }
 thread_local = "=1.1.9"
+memchr = "=2.8.0"
 clap_complete_nushell = "=4.5.10"
 interprocess = { version = "=2.4.0", features = ["tokio"] }
 serde = { version = "=1.0.228", features = ["derive"] }
@@ -95,3 +101,7 @@ harness = false
 [[bench]]
 name = "partial"
 harness = false
+
+[[bench]]
+name = "matcher_micro"
+harness = false

README.md

@@ -57,6 +57,7 @@ Skim provides a single executable called `sk`. Think of it as a smarter alternat
    * [Interactive mode](#interactive-mode)
       + [How does it work?](#how-does-it-work)
    * [Executing external programs](#executing-external-programs)
+   * [Algorithms](#algorithms)
    * [Preview Window](#preview-window)
       + [How does it work?](#how-does-it-work-1)
    * [Fields support](#fields-support)
@@ -84,7 +85,7 @@ The skim project contains several components:
 | macOS          | MacPorts          | `sudo port install skim`     |
 | Alpine         | apk               | `apk add skim`               |
 | Arch           | pacman            | `pacman -S skim`             |
-| Fedora         | COPR              |   see below                  | 
+| Fedora         | COPR              |   see below                  |
 | Gentoo         | Portage           | `emerge --ask app-misc/skim` |
 | Guix           | guix              | `guix install skim`          |
 | Void           | XBPS              | `xbps-install -S skim`       |
@@ -452,6 +453,14 @@ You can configure key bindings to start external processes without leaving Skim
 sk --bind 'f1:execute(less -f {}),ctrl-y:execute-silent(echo {} | pbcopy)+abort'
 ```
 
+## Algorithms
+
+Skim offers multiple algorithms, check the help or manpage for an exhaustive list. Among them are:
+- `skim_v2`, the default algorithm, loosely based on `fzf`'s algorithm
+- `frizbee`([crate](https://crates.io/frizbee), the typo-resistant algorithm used in the [blink.cmp](https://github.com/saghen/blink.cmp) neovim plugin
+- `fzy`, based on [fzy](https://github.com/jhawthorn/fzy/)'s algorithm expanded for basic typo-resistance
+- `arinae`, skim's newest algorithm, designed in-house with typo-resistance in mind, expanding on all the above to make typo-resistant matching feel more natural while keeping the per-item performance up to the best standards
+
 ## Preview Window
 
 This is a great feature of fzf that skim borrows. For example, we use 'ag' to

benches/filter.rs

@@ -75,6 +75,27 @@ fn criterion_benchmark_10m(c: &mut Criterion) {
             Skim::run_with(opts, None)
         });
     });
+    c.bench_function("filter_10M_skim_v3", |b| {
+        b.iter(|| {
+            let opts = SkimOptionsBuilder::default()
+                .cmd("cat benches/fixtures/10M.txt")
+                .filter("test")
+                .algorithm(FuzzyAlgorithm::Arinae)
+                .build()?;
+            Skim::run_with(opts, None)
+        });
+    });
+    c.bench_function("filter_10M_skim_v3_typos", |b| {
+        b.iter(|| {
+            let opts = SkimOptionsBuilder::default()
+                .cmd("cat benches/fixtures/10M.txt")
+                .filter("test")
+                .typos(Typos::Smart)
+                .algorithm(FuzzyAlgorithm::Arinae)
+                .build()?;
+            Skim::run_with(opts, None)
+        });
+    });
 }
 
 fn criterion_benchmark_1m(c: &mut Criterion) {
@@ -150,6 +171,27 @@ fn criterion_benchmark_1m(c: &mut Criterion) {
             Skim::run_with(opts, None)
         });
     });
+    c.bench_function("filter_1M_skim_v3", |b| {
+        b.iter(|| {
+            let opts = SkimOptionsBuilder::default()
+                .cmd("cat benches/fixtures/1M.txt")
+                .filter("test")
+                .algorithm(FuzzyAlgorithm::Arinae)
+                .build()?;
+            Skim::run_with(opts, None)
+        });
+    });
+    c.bench_function("filter_1M_skim_v3_typos", |b| {
+        b.iter(|| {
+            let opts = SkimOptionsBuilder::default()
+                .cmd("cat benches/fixtures/1M.txt")
+                .filter("test")
+                .typos(Typos::Smart)
+                .algorithm(FuzzyAlgorithm::Arinae)
+                .build()?;
+            Skim::run_with(opts, None)
+        });
+    });
 
     c.bench_function("filter_1M_andor", |b| {
         b.iter(|| {

benches/matcher_micro.rs

@@ -0,0 +1,133 @@
+//! Microbenchmark that isolates the fuzzy matcher DP from all other overhead
+//! (I/O, threading, sorting).
+
+use std::fs;
+
+use criterion::{Criterion, criterion_group, criterion_main};
+
+use skim::CaseMatching;
+use skim::fuzzy_matcher::FuzzyMatcher;
+use skim::fuzzy_matcher::arinae::ArinaeMatcher;
+use skim::fuzzy_matcher::frizbee::FrizbeeMatcher;
+use skim::prelude::SkimMatcherV2;
+
+fn load_lines() -> Vec<String> {
+    let data = fs::read_to_string("benches/fixtures/1M.txt").expect("1M.txt missing");
+    data.lines().map(|l| l.to_string()).collect()
+}
+
+fn bench_matcher(c: &mut Criterion) {
+    let lines = load_lines();
+
+    c.bench_function("micro_skim_v2", |b| {
+        let m = SkimMatcherV2::default().smart_case();
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_indices(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+    c.bench_function("micro_frizbee", |b| {
+        let m = FrizbeeMatcher::default().case(CaseMatching::Smart).max_typos(Some(0));
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_indices(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+    c.bench_function("micro_typos_frizbee", |b| {
+        let m = FrizbeeMatcher::default().case(CaseMatching::Smart).max_typos(Some(1));
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_indices(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+    c.bench_function("micro_arinae", |b| {
+        let m = ArinaeMatcher::new(CaseMatching::Smart, false);
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_indices(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+    c.bench_function("micro_arinae_range", |b| {
+        let m = ArinaeMatcher::new(CaseMatching::Smart, false);
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_match_range(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+    c.bench_function("micro_arinae_score", |b| {
+        let m = ArinaeMatcher::new(CaseMatching::Smart, false);
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_match(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+    c.bench_function("micro_typos_arinae", |b| {
+        let m = ArinaeMatcher::new(CaseMatching::Smart, true);
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_indices(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+    c.bench_function("micro_typos_arinae_range", |b| {
+        let m = ArinaeMatcher::new(CaseMatching::Smart, true);
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_match_range(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+    c.bench_function("micro_typos_arinae_score", |b| {
+        let m = ArinaeMatcher::new(CaseMatching::Smart, true);
+        b.iter(|| {
+            let mut count = 0u64;
+            for line in &lines {
+                if m.fuzzy_match(line, "test").is_some() {
+                    count += 1;
+                }
+            }
+            count
+        });
+    });
+}
+
+criterion_group!(benches, bench_matcher);
+criterion_main!(benches);