v0.2.0: remove decompose_* ops

- Drop decompose_json / decompose_schema from the Rust crate (breaking).
- Drop them from bench harness and refresh the side-by-side numbers.
- Bench compares against synalinks _py_<op> reference implementations.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: YoanSallami

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "synaops"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "Apache-2.0"
 description = "Native Rust implementations of synalinks JSON/schema operations."

Cargo.toml

@@ -11,7 +11,7 @@ callers do not need to know there is Rust underneath.
 
 Parity with the Python reference is asserted on every op and payload size
 (see `bench/test_parity.py`). Headline speedups on realistic payloads:
-**~470× on `factorize_schema`**, **~290× on `factorize_json`** at 600 keys,
+**~485× on `factorize_schema`**, **~280× on `factorize_json`** at 600 keys,
 4–8× on masking ops, 2–4× on simple key rewrites. Full table below.
 
 ## Build
@@ -34,8 +34,7 @@ import synaops
 | `prefix_json` | `(json, prefix)` | Prepend `prefix_` to every top-level key. |
 | `suffix_json` | `(json, suffix)` | Append `_suffix` to every top-level key. |
 | `concatenate_json` | `(json1, json2)` | Merge two objects; on key collision append `_1`, `_2`, … to disambiguate. |
-| `factorize_json` | `(json)` | Group keys sharing a singular base into a single array under the plural key. Inverse of `decompose_json`. |
-| `decompose_json` | `(json)` | Expand plural-keyed array properties into individual singular-keyed properties with numerical suffixes. Inverse of `factorize_json`. |
+| `factorize_json` | `(json)` | Group keys sharing a singular base into a single array under the plural key. |
 | `out_mask_json` | `(json, mask=None, pattern=None, recursive=True)` | Drop keys whose base name is in `mask` or whose base name matches the regex `pattern`. Numerical suffixes are ignored when matching. |
 | `in_mask_json` | `(json, mask=None, pattern=None, recursive=True)` | Keep only the keys whose base name is in `mask` or matches `pattern`. In recursive mode, arrays are preserved and their object items are filtered in place. |
 
@@ -49,7 +48,6 @@ Operate on JSON-Schema-shaped dicts (`properties`, `required`, `$defs`, `type`,
 | `suffix_schema` | `(schema, suffix)` | Append `_suffix` to every property key and update `title` / `required` accordingly. |
 | `concatenate_schema` | `(schema1, schema2)` | Merge two schemas (properties, `required`, `$defs`); on key collision append numeric suffixes and regenerate titles. |
 | `factorize_schema` | `(schema)` | Group similar singular-keyed properties into array-typed plural-keyed properties; folds heterogeneous `items` into `anyOf`. |
-| `decompose_schema` | `(schema)` | Expand plural-keyed array properties into a single singular-keyed property carrying the `items` schema. |
 | `out_mask_schema` | `(schema, mask=None, pattern=None, recursive=True)` | Remove properties whose base name is in `mask` or matches `pattern`. With `recursive=True`, descends into nested object/array properties and `$defs`, then prunes `$defs` entries no longer referenced. |
 | `in_mask_schema` | `(schema, mask=None, pattern=None, recursive=True)` | Keep only properties whose base name is in `mask` or matches `pattern`. Same recursive/`$defs`-pruning behavior as `out_mask_schema`. |
 | `standardize_schema` | `(schema)` | Placeholder for schema normalization (currently identity). |
@@ -58,7 +56,7 @@ Operate on JSON-Schema-shaped dicts (`properties`, `required`, `$defs`, `type`,
 
 ## Matching semantics
 
-Both `*_mask_*` families and `factorize_*` / `decompose_*` rely on the NLP
+Both `*_mask_*` families and `factorize_*` rely on the NLP
 helpers in `nlp_utils.rs`: they strip trailing numerical suffixes
 (`answer_3` → `answer`) and normalize singular/plural forms
 (`answers` ↔ `answer`) before comparing keys. The `pattern` argument is a
@@ -80,21 +78,19 @@ Ratio `py_median / rs_median` per op. Higher is better; dashed line is parity (1
 
 | Operation | small (12) | medium (96) | large (600) |
 |---|---:|---:|---:|
-| `factorize_schema` | 9.43× | 68.0× | 472× |
-| `factorize_json` | 10.3× | 48.9× | 291× |
-| `in_mask_json` | 8.11× | 7.37× | 7.75× |
-| `out_mask_json_pattern` | 4.16× | 4.27× | 4.49× |
-| `out_mask_json` | 4.37× | 4.17× | 4.42× |
-| `in_mask_schema` | 5.14× | 4.21× | 4.31× |
-| `out_mask_schema` | 4.67× | 3.92× | 4.16× |
-| `prefix_schema` | 3.91× | 3.79× | 4.16× |
-| `suffix_schema` | 3.90× | 3.80× | 4.10× |
-| `decompose_schema` | 2.65× | 2.44× | 3.33× |
-| `concatenate_schema` | 2.25× | 2.08× | 2.89× |
-| `decompose_json` | 2.74× | 2.48× | 2.56× |
-| `prefix_json` | 2.41× | 2.41× | 2.46× |
-| `suffix_json` | 2.63× | 2.40× | 2.42× |
-| `concatenate_json` | 2.44× | 2.46× | 2.30× |
+| `factorize_schema` | 8.78× | 64.8× | 485× |
+| `factorize_json` | 9.73× | 46.2× | 282× |
+| `in_mask_json` | 7.75× | 7.11× | 7.47× |
+| `out_mask_json` | 4.23× | 4.12× | 4.29× |
+| `out_mask_json_pattern` | 3.77× | 4.15× | 4.20× |
+| `in_mask_schema` | 4.83× | 4.12× | 4.15× |
+| `out_mask_schema` | 4.25× | 3.78× | 4.11× |
+| `prefix_schema` | 3.63× | 3.62× | 3.89× |
+| `suffix_schema` | 3.66× | 3.64× | 3.85× |
+| `concatenate_schema` | 2.21× | 2.15× | 2.85× |
+| `suffix_json` | 2.36× | 2.22× | 2.28× |
+| `concatenate_json` | 2.25× | 2.18× | 2.27× |
+| `prefix_json` | 2.26× | 2.25× | 2.26× |
 
 `factorize_*` scales super-linearly because the Python reference does
 repeated O(n) key scans per group; the Rust path groups in a single pass.

README.md

@@ -46,5 +46,5 @@ under `.benchmarks/` and renders a grouped speedup chart.
 Keys rotate through six realistic variants (`answer_*`, `item_*`,
 `items_*`, `nested_*` with depth-3 objects, `person_*` via `$ref`,
 `people_*` arrays of `$ref`-based objects) so every operation — including
-`factorize_*` / `decompose_*` / `*_mask_*` and the schema paths that walk
-`$defs` — has realistic work to do.
+`factorize_*` / `*_mask_*` and the schema paths that walk `$defs` — has
+realistic work to do.

bench/README.md

@@ -19,7 +19,6 @@
     ("suffix_json", lambda f, d, **kw: f(d, "s")),
     ("concatenate_json", lambda f, d, **kw: f(d, d)),
     ("factorize_json", lambda f, d, **kw: f(d)),
-    ("decompose_json", lambda f, d, **kw: f(d)),
     (
         "out_mask_json",
         lambda f, d, **kw: f(d, mask=["answer", "item"], recursive=True),
@@ -39,7 +38,6 @@
     ("suffix_schema", lambda f, s, **kw: f(s, "s")),
     ("concatenate_schema", lambda f, s, **kw: f(s, s)),
     ("factorize_schema", lambda f, s, **kw: f(s)),
-    ("decompose_schema", lambda f, s, **kw: f(s)),
     (
         "out_mask_schema",
         lambda f, s, **kw: f(s, mask=["answer", "item"], recursive=True),
@@ -51,8 +49,13 @@
 ]
 
 
-def _resolve(name: str, module):
+def _resolve_py(name: str, module):
     # strip "_pattern" variant suffix used only to pick a different call shape
+    base = name.removesuffix("_pattern")
+    return getattr(module, f"_py_{base}")
+
+
+def _resolve_rs(name: str, module):
     base = name.removesuffix("_pattern")
     return getattr(module, base)
 
@@ -61,15 +64,15 @@ def _resolve(name: str, module):
 def ops_json():
     """Returns list of (name, py_fn, rs_fn, call_shape)."""
     return [
-        (name, _resolve(name, py_json), _resolve(name, rs), call)
+        (name, _resolve_py(name, py_json), _resolve_rs(name, rs), call)
         for name, call in JSON_FNS
     ]
 
 
 @pytest.fixture
 def ops_schema():
     return [
-        (name, _resolve(name, py_sch), _resolve(name, rs), call)
+        (name, _resolve_py(name, py_sch), _resolve_rs(name, rs), call)
         for name, call in SCHEMA_FNS
     ]
 

bench/before_after.png

@@ -27,7 +27,7 @@ def test_json_py(benchmark, op, size_name, json_payload_by_size):
     from synalinks.src.backend.common import json_utils as py_json
 
     base = op_name.removesuffix("_pattern")
-    fn = getattr(py_json, base)
+    fn = getattr(py_json, f"_py_{base}")
     payload = json_payload_by_size[size_name]
 
     benchmark.group = f"{op_name}[{size_name}]"
@@ -57,7 +57,7 @@ def test_schema_py(benchmark, op, size_name, schema_payload_by_size):
     from synalinks.src.backend.common import json_schema_utils as py_sch
 
     base = op_name.removesuffix("_pattern")
-    fn = getattr(py_sch, base)
+    fn = getattr(py_sch, f"_py_{base}")
     payload = schema_payload_by_size[size_name]
 
     benchmark.group = f"{op_name}[{size_name}]"

bench/conftest.py

@@ -19,7 +19,7 @@ def test_json_parity(op, size_name, json_payload_by_size):
 
     base = op_name.removesuffix("_pattern")
     payload = json_payload_by_size[size_name]
-    py_out = call(getattr(py_json, base), payload)
+    py_out = call(getattr(py_json, f"_py_{base}"), payload)
     rs_out = call(getattr(rs, base), payload)
     assert py_out == rs_out, f"{op_name}[{size_name}]: py != rs"
 
@@ -33,6 +33,6 @@ def test_schema_parity(op, size_name, schema_payload_by_size):
 
     base = op_name.removesuffix("_pattern")
     payload = schema_payload_by_size[size_name]
-    py_out = call(getattr(py_sch, base), payload)
+    py_out = call(getattr(py_sch, f"_py_{base}"), payload)
     rs_out = call(getattr(rs, base), payload)
     assert py_out == rs_out, f"{op_name}[{size_name}]: py != rs"

bench/speedup.png

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "synaops"
-version = "0.1.0"
+version = "0.2.0"
 description = "Native Rust implementations of synalinks JSON/schema operations."
 readme = "README.md"
 license = "Apache-2.0"