diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index d9e42f0..04b5131 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -1,6 +1,20 @@
 Changelog
 ---------
 
+[0.4.0] - 2023-12-01
+^^^^^^^^^^^^^^^^^^^^
+Changed
+~~~~~~~
+* rewrite of function signatures to reduce boilerplate
+  * return type now automatically deduced, so no more unwrapping needed
+    when ``score_cutoff`` is not used
+  * optional arguments now in Arg structs uisng the builder pattern to reduce amount
+    of extra arguments
+  * extra overload ``*_with_args`` for a variant with args, while the default version accepts
+    only two sequences
+
+  The signatures is expected to largely stay this way for the foreseeable future.
+
 [0.3.2] - 2023-11-29
 ^^^^^^^^^^^^^^^^^^^^
 Fixed
diff --git a/Cargo.toml b/Cargo.toml
index 5023104..d1acc84 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 description="rapid fuzzy string matching library"
 name = "rapidfuzz"
-version = "0.3.2"
+version = "0.4.0"
 authors = ["maxbachmann <oss@maxbachmann.de>"]
 edition = "2021"
 readme = "Readme.md"
diff --git a/fuzz/fuzz_targets/damerau_levenshtein.rs b/fuzz/fuzz_targets/damerau_levenshtein.rs
index 5289129..73db890 100644
--- a/fuzz/fuzz_targets/damerau_levenshtein.rs
+++ b/fuzz/fuzz_targets/damerau_levenshtein.rs
@@ -11,12 +11,9 @@ pub struct Texts {
 }
 
 fn fuzz(texts: Texts) {
-    damerau_levenshtein::distance(texts.s1.chars(), texts.s2.chars(), None, None)
-        .expect("does not return None");
+    damerau_levenshtein::distance(texts.s1.chars(), texts.s2.chars());
 
-    damerau_levenshtein::BatchComparator::new(texts.s1.chars())
-        .distance(texts.s2.chars(), None, None)
-        .expect("does not return None");
+    damerau_levenshtein::BatchComparator::new(texts.s1.chars()).distance(texts.s2.chars());
 }
 
 fuzz_target!(|texts: Texts| {
diff --git a/fuzz/fuzz_targets/indel.rs b/fuzz/fuzz_targets/indel.rs
index b42c03e..9f5c589 100644
--- a/fuzz/fuzz_targets/indel.rs
+++ b/fuzz/fuzz_targets/indel.rs
@@ -11,11 +11,9 @@ pub struct Texts {
 }
 
 fn fuzz(texts: Texts) {
-    indel::distance(texts.s1.chars(), texts.s2.chars(), None, None).expect("does not return None");
+    indel::distance(texts.s1.chars(), texts.s2.chars());
 
-    indel::BatchComparator::new(texts.s1.chars())
-        .distance(texts.s2.chars(), None, None)
-        .expect("does not return None");
+    indel::BatchComparator::new(texts.s1.chars()).distance(texts.s2.chars());
 }
 
 fuzz_target!(|texts: Texts| {
diff --git a/fuzz/fuzz_targets/jaro.rs b/fuzz/fuzz_targets/jaro.rs
index 2f994fc..477e198 100644
--- a/fuzz/fuzz_targets/jaro.rs
+++ b/fuzz/fuzz_targets/jaro.rs
@@ -11,11 +11,9 @@ pub struct Texts {
 }
 
 fn fuzz(texts: Texts) {
-    jaro::distance(texts.s1.chars(), texts.s2.chars(), None, None).expect("does not return None");
+    jaro::distance(texts.s1.chars(), texts.s2.chars());
 
-    jaro::BatchComparator::new(texts.s1.chars())
-        .distance(texts.s2.chars(), None, None)
-        .expect("does not return None");
+    jaro::BatchComparator::new(texts.s1.chars()).distance(texts.s2.chars());
 }
 
 fuzz_target!(|texts: Texts| {
diff --git a/fuzz/fuzz_targets/jaro_winkler.rs b/fuzz/fuzz_targets/jaro_winkler.rs
index f5884ba..e983adb 100644
--- a/fuzz/fuzz_targets/jaro_winkler.rs
+++ b/fuzz/fuzz_targets/jaro_winkler.rs
@@ -11,12 +11,9 @@ pub struct Texts {
 }
 
 fn fuzz(texts: Texts) {
-    jaro_winkler::distance(texts.s1.chars(), texts.s2.chars(), None, None, None)
-        .expect("does not return None");
+    jaro_winkler::distance(texts.s1.chars(), texts.s2.chars());
 
-    jaro_winkler::BatchComparator::new(texts.s1.chars(), None)
-        .distance(texts.s2.chars(), None, None)
-        .expect("does not return None");
+    jaro_winkler::BatchComparator::new(texts.s1.chars()).distance(texts.s2.chars());
 }
 
 fuzz_target!(|texts: Texts| {
diff --git a/fuzz/fuzz_targets/lcs_seq.rs b/fuzz/fuzz_targets/lcs_seq.rs
index a71c705..9a334be 100644
--- a/fuzz/fuzz_targets/lcs_seq.rs
+++ b/fuzz/fuzz_targets/lcs_seq.rs
@@ -11,12 +11,9 @@ pub struct Texts {
 }
 
 fn fuzz(texts: Texts) {
-    lcs_seq::distance(texts.s1.chars(), texts.s2.chars(), None, None)
-        .expect("does not return None");
+    lcs_seq::distance(texts.s1.chars(), texts.s2.chars());
 
-    lcs_seq::BatchComparator::new(texts.s1.chars())
-        .distance(texts.s2.chars(), None, None)
-        .expect("does not return None");
+    lcs_seq::BatchComparator::new(texts.s1.chars()).distance(texts.s2.chars());
 }
 
 fuzz_target!(|texts: Texts| {
diff --git a/fuzz/fuzz_targets/levenshtein.rs b/fuzz/fuzz_targets/levenshtein.rs
index e5755f6..89aace2 100644
--- a/fuzz/fuzz_targets/levenshtein.rs
+++ b/fuzz/fuzz_targets/levenshtein.rs
@@ -11,12 +11,9 @@ pub struct Texts {
 }
 
 fn fuzz(texts: Texts) {
-    levenshtein::distance(texts.s1.chars(), texts.s2.chars(), None, None, None)
-        .expect("does not return None");
+    levenshtein::distance(texts.s1.chars(), texts.s2.chars());
 
-    levenshtein::BatchComparator::new(texts.s1.chars(), None)
-        .distance(texts.s2.chars(), None, None)
-        .expect("does not return None");
+    levenshtein::BatchComparator::new(texts.s1.chars()).distance(texts.s2.chars());
 }
 
 fuzz_target!(|texts: Texts| {
diff --git a/rapidfuzz-benches/benches/bench_damerau_levenshtein.rs b/rapidfuzz-benches/benches/bench_damerau_levenshtein.rs
index 89ac302..aca29e3 100644
--- a/rapidfuzz-benches/benches/bench_damerau_levenshtein.rs
+++ b/rapidfuzz-benches/benches/bench_damerau_levenshtein.rs
@@ -36,8 +36,6 @@ fn benchmark(c: &mut Criterion) {
                 black_box(distance::damerau_levenshtein::distance(
                     val.0.bytes(),
                     val.1.bytes(),
-                    None,
-                    None,
                 ));
             })
         });
diff --git a/rapidfuzz-benches/benches/bench_generic_levenshtein.rs b/rapidfuzz-benches/benches/bench_generic_levenshtein.rs
index a62eee0..856b117 100644
--- a/rapidfuzz-benches/benches/bench_generic_levenshtein.rs
+++ b/rapidfuzz-benches/benches/bench_generic_levenshtein.rs
@@ -31,19 +31,19 @@ fn benchmark(c: &mut Criterion) {
     for i in lens {
         let s1 = generate(i);
         let s2 = generate(i);
+        let args =
+            distance::levenshtein::Args::default().weights(&distance::levenshtein::WeightTable {
+                insertion_cost: 1,
+                deletion_cost: 2,
+                substitution_cost: 3,
+            });
 
         group.bench_with_input(BenchmarkId::new("rapidfuzz", i), &(&s1, &s2), |b, val| {
             b.iter(|| {
-                black_box(distance::levenshtein::distance(
+                black_box(distance::levenshtein::distance_with_args(
                     val.0.bytes(),
                     val.1.bytes(),
-                    Some(distance::levenshtein::WeightTable {
-                        insertion_cost: 1,
-                        deletion_cost: 2,
-                        substitution_cost: 3,
-                    }),
-                    None,
-                    None,
+                    &args,
                 ));
             })
         });
diff --git a/rapidfuzz-benches/benches/bench_indel.rs b/rapidfuzz-benches/benches/bench_indel.rs
index 87c26f7..12fad4f 100644
--- a/rapidfuzz-benches/benches/bench_indel.rs
+++ b/rapidfuzz-benches/benches/bench_indel.rs
@@ -33,12 +33,7 @@ fn benchmark(c: &mut Criterion) {
 
         group.bench_with_input(BenchmarkId::new("rapidfuzz", i), &(&s1, &s2), |b, val| {
             b.iter(|| {
-                black_box(distance::indel::distance(
-                    val.0.bytes(),
-                    val.1.bytes(),
-                    None,
-                    None,
-                ));
+                black_box(distance::indel::distance(val.0.bytes(), val.1.bytes()));
             })
         });
 
@@ -48,7 +43,7 @@ fn benchmark(c: &mut Criterion) {
             &(&cached, &s2),
             |b, val| {
                 b.iter(|| {
-                    black_box(cached.distance(val.1.bytes(), None, None));
+                    black_box(cached.distance(val.1.bytes()));
                 })
             },
         );
diff --git a/rapidfuzz-benches/benches/bench_jaro.rs b/rapidfuzz-benches/benches/bench_jaro.rs
index 19a85c9..197d956 100644
--- a/rapidfuzz-benches/benches/bench_jaro.rs
+++ b/rapidfuzz-benches/benches/bench_jaro.rs
@@ -33,12 +33,7 @@ fn benchmark(c: &mut Criterion) {
 
         group.bench_with_input(BenchmarkId::new("rapidfuzz", i), &(&s1, &s2), |b, val| {
             b.iter(|| {
-                black_box(distance::jaro::similarity(
-                    val.0.bytes(),
-                    val.1.bytes(),
-                    None,
-                    None,
-                ));
+                black_box(distance::jaro::similarity(val.0.bytes(), val.1.bytes()));
             })
         });
 
@@ -48,7 +43,7 @@ fn benchmark(c: &mut Criterion) {
             &(&cached, &s2),
             |b, val| {
                 b.iter(|| {
-                    black_box(cached.similarity(val.1.bytes(), None, None));
+                    black_box(cached.similarity(val.1.bytes()));
                 })
             },
         );
diff --git a/rapidfuzz-benches/benches/bench_jaro_winkler.rs b/rapidfuzz-benches/benches/bench_jaro_winkler.rs
index d38e1ef..5f30ef2 100644
--- a/rapidfuzz-benches/benches/bench_jaro_winkler.rs
+++ b/rapidfuzz-benches/benches/bench_jaro_winkler.rs
@@ -36,20 +36,17 @@ fn benchmark(c: &mut Criterion) {
                 black_box(distance::jaro_winkler::similarity(
                     val.0.bytes(),
                     val.1.bytes(),
-                    None,
-                    None,
-                    None,
                 ));
             })
         });
 
-        let cached = distance::jaro_winkler::BatchComparator::new(s1.bytes(), None);
+        let cached = distance::jaro_winkler::BatchComparator::new(s1.bytes());
         group.bench_with_input(
             BenchmarkId::new("rapidfuzz (BatchComparator)", i),
             &(&cached, &s2),
             |b, val| {
                 b.iter(|| {
-                    black_box(cached.similarity(val.1.bytes(), None, None));
+                    black_box(cached.similarity(val.1.bytes()));
                 })
             },
         );
diff --git a/rapidfuzz-benches/benches/bench_lcs_seq.rs b/rapidfuzz-benches/benches/bench_lcs_seq.rs
index a989d3f..59490d3 100644
--- a/rapidfuzz-benches/benches/bench_lcs_seq.rs
+++ b/rapidfuzz-benches/benches/bench_lcs_seq.rs
@@ -33,12 +33,7 @@ fn benchmark(c: &mut Criterion) {
 
         group.bench_with_input(BenchmarkId::new("rapidfuzz", i), &(&s1, &s2), |b, val| {
             b.iter(|| {
-                black_box(distance::lcs_seq::similarity(
-                    val.0.bytes(),
-                    val.1.bytes(),
-                    None,
-                    None,
-                ));
+                black_box(distance::lcs_seq::similarity(val.0.bytes(), val.1.bytes()));
             })
         });
 
@@ -48,7 +43,7 @@ fn benchmark(c: &mut Criterion) {
             &(&cached, &s2),
             |b, val| {
                 b.iter(|| {
-                    black_box(cached.similarity(val.1.bytes(), None, None));
+                    black_box(cached.similarity(val.1.bytes()));
                 })
             },
         );
diff --git a/rapidfuzz-benches/benches/bench_levenshtein.rs b/rapidfuzz-benches/benches/bench_levenshtein.rs
index ca0e8fa..d30b473 100644
--- a/rapidfuzz-benches/benches/bench_levenshtein.rs
+++ b/rapidfuzz-benches/benches/bench_levenshtein.rs
@@ -27,15 +27,6 @@ impl<'a, 'b> IntoIterator for &'a StringWrapper<'b> {
 fn benchmark(c: &mut Criterion) {
     let mut group = c.benchmark_group("Levenshtein");
 
-    assert_eq!(
-        5,
-        levenshtein::distance(
-            "kitten".chars(),
-            "sitting".chars(),
-            &levenshtein::Args::default().weights(weights)
-        )
-    );
-
     for i in (2..128).step_by(2) {
         let s1 = generate(i);
         let s2 = generate(i);
@@ -45,9 +36,6 @@ fn benchmark(c: &mut Criterion) {
                 black_box(distance::levenshtein::distance(
                     val.0.bytes(),
                     val.1.bytes(),
-                    None,
-                    None,
-                    None,
                 ));
             })
         });
@@ -60,13 +48,13 @@ fn benchmark(c: &mut Criterion) {
             })
         });
 
-        let cached = distance::levenshtein::BatchComparator::new(s1.bytes(), None);
+        let cached = distance::levenshtein::BatchComparator::new(s1.bytes());
         group.bench_with_input(
             BenchmarkId::new("rapidfuzz (BatchComparator)", i),
             &(&cached, &s2),
             |b, val| {
                 b.iter(|| {
-                    black_box(cached.distance(val.1.bytes(), None, None));
+                    black_box(cached.distance(val.1.bytes()));
                 })
             },
         );
diff --git a/rapidfuzz-benches/benches/bench_osa.rs b/rapidfuzz-benches/benches/bench_osa.rs
index 7f03b46..ba374ab 100644
--- a/rapidfuzz-benches/benches/bench_osa.rs
+++ b/rapidfuzz-benches/benches/bench_osa.rs
@@ -33,12 +33,7 @@ fn benchmark(c: &mut Criterion) {
 
         group.bench_with_input(BenchmarkId::new("rapidfuzz", i), &(&s1, &s2), |b, val| {
             b.iter(|| {
-                black_box(distance::osa::distance(
-                    val.0.chars(),
-                    val.1.chars(),
-                    None,
-                    None,
-                ));
+                black_box(distance::osa::distance(val.0.chars(), val.1.chars()));
             })
         });
 
@@ -48,7 +43,7 @@ fn benchmark(c: &mut Criterion) {
             &(&cached, &s2),
             |b, val| {
                 b.iter(|| {
-                    black_box(cached.distance(val.1.chars(), None, None));
+                    black_box(cached.distance(val.1.chars()));
                 })
             },
         );