Moved out from Sync and Send for performance optimization

CASEPATHS_ENHANCEMENT.md

@@ -0,0 +1,149 @@
+# Casepaths Macro Enhancement
+
+## Overview
+
+The `Casepaths` derive macro has been updated to work with the new `rust-keypaths` API, providing automatic generation of enum variant keypaths.
+
+## Generated Methods
+
+For each enum variant, the macro generates:
+
+### Single-Field Variants
+```rust
+enum MyEnum {
+    Variant(InnerType),
+}
+
+// Generated methods:
+MyEnum::variant_case_fr() -> OptionalKeyPath<MyEnum, InnerType, ...>
+MyEnum::variant_case_fw() -> WritableOptionalKeyPath<MyEnum, InnerType, ...>
+```
+
+### Multi-Field Tuple Variants
+```rust
+enum MyEnum {
+    Variant(T1, T2, T3),
+}
+
+// Generated methods:
+MyEnum::variant_case_fr() -> OptionalKeyPath<MyEnum, (T1, T2, T3), ...>
+MyEnum::variant_case_fw() -> WritableOptionalKeyPath<MyEnum, (T1, T2, T3), ...>
+```
+
+### Named Field Variants
+```rust
+enum MyEnum {
+    Variant { field1: T1, field2: T2 },
+}
+
+// Generated methods:
+MyEnum::variant_case_fr() -> OptionalKeyPath<MyEnum, (T1, T2), ...>
+MyEnum::variant_case_fw() -> WritableOptionalKeyPath<MyEnum, (T1, T2), ...>
+```
+
+### Unit Variants
+```rust
+enum MyEnum {
+    Variant,
+}
+
+// Generated methods:
+MyEnum::variant_case_fr() -> OptionalKeyPath<MyEnum, (), ...>
+```
+
+## Attribute Support
+
+The macro supports the same attributes as `Keypaths`:
+
+- `#[Readable]` - Generate only readable methods (`_case_fr()`)
+- `#[Writable]` - Generate only writable methods (`_case_fw()`)
+- `#[All]` - Generate both readable and writable methods (default)
+
+### Example
+
+```rust
+#[derive(Casepaths)]
+#[Writable]  // Generate only writable methods
+enum MyEnum {
+    A(String),
+    B(Box<InnerStruct>),
+}
+
+// Usage:
+let path = MyEnum::b_case_fw()  // Returns WritableOptionalKeyPath
+    .for_box()                   // Unwrap Box<InnerStruct>
+    .then(InnerStruct::field_fw());
+```
+
+## Key Features
+
+1. **Type Safety**: Returns `OptionalKeyPath`/`WritableOptionalKeyPath` since variant extraction may fail
+2. **Container Support**: Works seamlessly with `Box<T>`, `Arc<T>`, `Rc<T>` via `.for_box()`, `.for_arc()`, `.for_rc()`
+3. **Chaining**: Can be chained with `.then()` for nested access
+4. **Attribute-Based Control**: Use `#[Readable]`, `#[Writable]`, or `#[All]` to control which methods are generated
+
+## Migration from Old API
+
+### Old API (key-paths-core)
+```rust
+#[derive(Casepaths)]
+enum MyEnum {
+    Variant(InnerType),
+}
+
+// Generated methods returned KeyPaths enum
+let path = MyEnum::variant_case_r();
+```
+
+### New API (rust-keypaths)
+```rust
+#[derive(Casepaths)]
+#[Writable]
+enum MyEnum {
+    Variant(InnerType),
+}
+
+// Generated methods return specific types
+let path = MyEnum::variant_case_fw();  // Returns WritableOptionalKeyPath
+```
+
+## Example: Deep Nesting with Box
+
+```rust
+#[derive(Keypaths)]
+#[Writable]
+struct Outer {
+    inner: Option<MyEnum>,
+}
+
+#[derive(Casepaths)]
+#[Writable]
+enum MyEnum {
+    B(Box<InnerStruct>),
+}
+
+#[derive(Keypaths)]
+#[Writable]
+struct InnerStruct {
+    field: Option<String>,
+}
+
+// Chain through Option -> Enum variant -> Box -> Option
+let path = Outer::inner_fw()
+    .then(MyEnum::b_case_fw())  // Extract variant
+    .for_box()                   // Unwrap Box
+    .then(InnerStruct::field_fw());
+
+// Use it
+if let Some(value) = path.get_mut(&mut instance) {
+    *value = "new value".to_string();
+}
+```
+
+## Implementation Details
+
+- **Variant Extraction**: Uses pattern matching to safely extract variant values
+- **Type Inference**: Automatically handles all variant field types
+- **Error Handling**: Returns `None` if the enum is not the expected variant
+- **Zero-Cost**: Compiles to direct pattern matching, no runtime overhead
+

Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "rust-key-paths"
-version = "1.8.0"
+version = "1.11.5"
 edition = "2024"
 authors = ["Codefonsi <[email protected]>"]
 license = "MPL-2.0"
-description = "Keypaths, ReadableKeyPath, WritableKeyPath and EnumKeypath for struct and enums in Rust."
+description = "Keypaths for Rust: Static dispatch implementation (rust-keypaths) and legacy dynamic dispatch (key-paths-core). Type-safe, composable access to nested data structures."
 repository = "https://github.com/codefonsi/rust-key-paths"
 homepage = "https://github.com/codefonsi/rust-key-paths"
 documentation = "https://docs.rs/rust-key-paths"
@@ -13,30 +13,51 @@ readme = "./README.md"
 include = ["src/**/*", "Cargo.toml", "../../README.md", "LICENSE"]
 
 [dependencies]
-key-paths-core = { path = "key-paths-core", version = "1.6.0", features = ["tagged_core"] }
-key-paths-derive = { path = "key-paths-derive", version = "1.0.8"}
+# Primary crates: rust-keypaths (static dispatch, faster) and keypaths-proc (proc macros)
+rust-keypaths = "1.0.7"
+keypaths-proc = "1.0.6"
+
+# Legacy crates: key-paths-core 1.6.0 for dynamic dispatch, multithreaded needs
+# Note: Use key-paths-core = "1.6.0" if you need dynamic dispatch or Send + Sync bounds
+# key-paths-core = { path = "key-paths-core", version = "1.6.0", features = ["tagged_core"] }
+# key-paths-derive = { path = "key-paths-derive", version = "1.1.0"}
 
 
 [workspace]
 resolver = "3" # or "3"
 members = [
+    "rust-keypaths",
+    "keypaths-proc",
+    # Legacy members (kept for backward compatibility)
     "key-paths-core",
-    "key-paths-derive"
-]
+    "key-paths-derive",
+    "key-paths-macros"
+, "keypaths-core"]
 
 [patch.crates-io]
-key-paths-core = { path = "key-paths-core" }
-key-paths-derive = { path = "key-paths-derive" }
-
+# key-paths-core = { path = "key-paths-core" }
+# key-paths-derive = { path = "key-paths-derive" }
+rust-keypaths = { path = "rust-keypaths" }
+keypaths-proc = { path = "keypaths-proc" }
 [features]
 default = []
-parking_lot = ["key-paths-core/parking_lot"]
-tagged_core = ["key-paths-core/tagged_core"]
+# Features for rust-keypaths (static dispatch)
+parking_lot = ["rust-keypaths/parking_lot"]
+tagged = ["rust-keypaths/tagged"]
+nightly = ["rust-keypaths/nightly"]
+# Legacy features for key-paths-core (dynamic dispatch)
+# parking_lot_legacy = ["key-paths-core/parking_lot"]
+# tagged_core = ["key-paths-core/tagged_core"]
 
 [dev-dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 parking_lot = "0.12"
-tagged-core = "0.7.0"
+tagged-core = "0.8.0"
 chrono = { version = "0.4", features = ["serde"] }
 uuid = { version = "1.0", features = ["v4", "serde"] }
+criterion = { version = "0.5", features = ["html_reports"] }
+
+[[bench]]
+name = "keypath_vs_unwrap"
+harness = false

EXAMPLES_FIXES_FINAL.md

@@ -0,0 +1,113 @@
+# Examples Fixes - Final Status
+
+## ✅ Completed Enhancements to rust-keypaths
+
+### 1. Added `to_optional()` Methods
+- **KeyPath::to_optional()** - Converts `KeyPath` to `OptionalKeyPath` for chaining
+- **WritableKeyPath::to_optional()** - Converts `WritableKeyPath` to `WritableOptionalKeyPath` for chaining
+
+### 2. Added Container Adapter Methods
+- **OptionalKeyPath::with_option()** - Execute closure with value inside `Option<T>`
+- **OptionalKeyPath::with_mutex()** - Execute closure with value inside `Mutex<T>`
+- **OptionalKeyPath::with_rwlock()** - Execute closure with value inside `RwLock<T>`
+- **OptionalKeyPath::with_arc_rwlock()** - Execute closure with value inside `Arc<RwLock<T>>`
+- **OptionalKeyPath::with_arc_mutex()** - Execute closure with value inside `Arc<Mutex<T>>`
+- **KeyPath::with_arc_rwlock_direct()** - Direct support for `Arc<RwLock<T>>`
+- **KeyPath::with_arc_mutex_direct()** - Direct support for `Arc<Mutex<T>>`
+
+### 3. Added `get()` to WritableKeyPath
+- **WritableKeyPath::get()** - Returns `&Value` (requires `&mut Root`)
+- Note: For optional fields, use `WritableOptionalKeyPath::get_mut()` which returns `Option<&mut Value>`
+
+## 📊 Current Status
+
+- ✅ **rust-keypaths library**: Compiles successfully
+- ✅ **keypaths-proc macro**: Compiles successfully  
+- ⚠️ **Examples**: ~41 errors remaining (down from 131)
+
+## 🔧 Remaining Issues
+
+### 1. Type Mismatches (29 errors)
+- **Issue**: Examples expect `WritableKeyPath::get()` to return `Option<&mut Value>`
+- **Reality**: `WritableKeyPath::get()` returns `&Value` (non-optional)
+- **Solution**: Examples should use:
+  - `WritableOptionalKeyPath::get_mut()` for optional fields
+  - Or convert using `.to_optional()` first
+
+### 2. Missing Methods (9 errors)
+- `with_arc_rwlock_direct` / `with_arc_mutex_direct` - ✅ **FIXED** (just added)
+- `extract_from_slice` - May need to be added if used in examples
+
+### 3. Clone Issues (2 errors)
+- Some `KeyPath` instances don't satisfy `Clone` bounds
+- This happens when the closure type doesn't implement `Clone`
+- **Solution**: Use `.clone()` only when the keypath is from derive macros (which generate Clone-able closures)
+
+### 4. Other Issues (1 error)
+- `Option<&mut T>` cannot be dereferenced - Need to use `if let Some(x) = ...` pattern
+- Missing `main` function in one example
+
+## 🎯 Next Steps
+
+1. **Fix WritableKeyPath usage**: Update examples to use `WritableOptionalKeyPath` for optional fields
+2. **Add missing methods**: Add `extract_from_slice` if needed
+3. **Fix type mismatches**: Update examples to match the actual API
+4. **Test all examples**: Run each example to verify it works correctly
+
+## 📝 API Summary
+
+### KeyPath API
+```rust
+// Direct access (non-optional)
+let kp = KeyPath::new(|r: &Root| &r.field);
+let value = kp.get(&root); // Returns &Value
+
+// Convert to optional for chaining
+let opt_kp = kp.to_optional(); // Returns OptionalKeyPath
+let value = opt_kp.get(&root); // Returns Option<&Value>
+
+// Container adapters
+kp.with_option(&opt, |v| ...);
+kp.with_mutex(&mutex, |v| ...);
+kp.with_rwlock(&rwlock, |v| ...);
+kp.with_arc_rwlock_direct(&arc_rwlock, |v| ...);
+```
+
+### WritableKeyPath API
+```rust
+// Direct mutable access (non-optional)
+let wk = WritableKeyPath::new(|r: &mut Root| &mut r.field);
+let value = wk.get_mut(&mut root); // Returns &mut Value
+let value_ref = wk.get(&mut root); // Returns &Value
+
+// Convert to optional for chaining
+let opt_wk = wk.to_optional(); // Returns WritableOptionalKeyPath
+```
+
+### OptionalKeyPath API
+```rust
+// Failable access
+let okp = OptionalKeyPath::new(|r: &Root| r.field.as_ref());
+let value = okp.get(&root); // Returns Option<&Value>
+
+// Chaining
+let chained = okp.then(other_okp);
+
+// Container adapters
+okp.with_option(&opt, |v| ...);
+okp.with_mutex(&mutex, |v| ...);
+okp.with_rwlock(&rwlock, |v| ...);
+```
+
+## 🚀 Migration Notes
+
+When migrating from `key-paths-core` to `rust-keypaths`:
+
+1. **KeyPaths enum** → Use specific types (`KeyPath`, `OptionalKeyPath`, etc.)
+2. **KeyPaths::readable()** → `KeyPath::new()`
+3. **KeyPaths::failable_readable()** → `OptionalKeyPath::new()`
+4. **.compose()** → `.then()` (only on `OptionalKeyPath`)
+5. **WithContainer trait** → Use `with_*` methods directly on keypaths
+6. **KeyPath.get()** → Returns `&Value` (not `Option`)
+7. **WritableKeyPath.get_mut()** → Returns `&mut Value` (not `Option`)
+