readme + fmt

Author: akashsoni01

README.md

@@ -70,9 +70,7 @@ fn main() {
 ### 2. Readable KeyPaths
 
 ```rust
-use key_paths_core::Readable;
-use key_paths_core::ReadableKeyPath;
-use key_paths_core::readable_keypath;
+use key_paths_core::{readable_keypath, ReadableKeyPath};
 
 #[derive(Debug)]
 struct User {
@@ -82,13 +80,31 @@ struct User {
 
 fn main() {
     let users = vec![
-        User { name: "Akash".into(), age: 25 },
-        User { name: "Soni".into(), age: 30 },
-        User { name: "Neha".into(), age: 20 },
+        User {
+            name: "Akash".into(),
+            age: 25,
+        },
+        User {
+            name: "Soni".into(),
+            age: 30,
+        },
+        User {
+            name: "Neha".into(),
+            age: 20,
+        },
     ];
 
+    // Read-only keypath
+    // let name_key = ReadableKeyPath::new(|u: &User| &u.name);
     let name_key = readable_keypath!(User, name);
 
+    // Writable keypath
+    // let age_key = WritableKeyPath::new(
+    //     |u: &User| &u.age,
+    //     |u: &mut User| &mut u.age,
+    // );
+    // let age_key = writable_keypath!(User, age);
+
     println!("Names:");
     for name in name_key.iter(&users) {
         println!("{}", name);
@@ -101,10 +117,7 @@ fn main() {
 ### 3. Writable KeyPaths
 
 ```rust
-use key_paths_core::writable_keypath;
-use key_paths_core::WritableKeyPath;
-use key_paths_core::Readable;
-use key_paths_core::Writable;
+use key_paths_core::{writable_keypath, WritableKeyPath};
 
 #[derive(Debug)]
 struct User {
@@ -114,29 +127,142 @@ struct User {
 
 fn main() {
     let mut users = vec![
-        User { name: "Akash".into(), age: 25 },
-        User { name: "Soni".into(), age: 30 },
-        User { name: "Neha".into(), age: 20 },
+        User {
+            name: "Akash".into(),
+            age: 25,
+        },
+        User {
+            name: "Soni".into(),
+            age: 30,
+        },
+        User {
+            name: "Neha".into(),
+            age: 20,
+        },
     ];
 
+    // Read-only keypath
+    // let name_key = ReadableKeyPath::new(|u: &User| &u.name);
+    // let name_key = readable_keypath!(User, name);
+
+    // Writable keypath
+    // let age_key = WritableKeyPath::new(
+    //     |u: & User| & u.age,
+    //     |u: &mut User| &mut u.age,
+    // );
     let age_key = writable_keypath!(User, age);
 
+    // println!("Names:");
+    // for name in name_key.iter(&users) {
+    //     println!("{}", name);
+    // }
+
     println!("Ages before:");
     for age in age_key.iter(&users) {
         println!("{}", age);
     }
 
+    // Mutate agesiter
     for age in age_key.iter_mut(&mut users) {
         *age += 1;
     }
 
     println!("Ages after:");
-    for age in age_key.iter(&users) {
+    for age in age_key.iter(&mut users) {
         println!("{}", age);
     }
 }
 ```
 
+### 4. Composability and failablity
+ ```rust
+ use key_paths_core::{FailableReadableKeyPath};
+
+#[derive(Debug)]
+struct Engine {
+    horsepower: u32,
+}
+#[derive(Debug)]
+struct Car {
+    engine: Option<Engine>,
+}
+#[derive(Debug)]
+struct Garage {
+    car: Option<Car>,
+}
+
+fn main() {
+    let garage = Garage {
+        car: Some(Car {
+            engine: Some(Engine { horsepower: 120 }),
+        }),
+    };
+
+    let kp_car = FailableReadableKeyPath::new(|g: &Garage| g.car.as_ref());
+    let kp_engine = FailableReadableKeyPath::new(|c: &Car| c.engine.as_ref());
+    let kp_hp = FailableReadableKeyPath::new(|e: &Engine| Some(&e.horsepower));
+
+    // Compose: Garage -> Car -> Engine -> horsepower
+    let kp = kp_car.compose(kp_engine).compose(kp_hp);
+
+    let kp2 = FailableReadableKeyPath::new(|g: &Garage| {
+        g.car
+            .as_ref()
+            .and_then(|c| c.engine.as_ref())
+            .and_then(|e| Some(&e.horsepower))
+    });
+
+    if let Some(hp) = kp.try_get(&garage) {
+        println!("{hp:?}");
+    }
+
+    if let Some(hp) = kp2.try_get(&garage) {
+        println!("{hp:?}");
+    }
+
+    println!("{garage:?}");
+}
+```
+### 4. Mutablity
+ ```rust
+ use key_paths_core::{FailableWritableKeyPath};
+
+#[derive(Debug)]
+struct Engine {
+    horsepower: u32,
+}
+#[derive(Debug)]
+struct Car {
+    engine: Option<Engine>,
+}
+#[derive(Debug)]
+struct Garage {
+    car: Option<Car>,
+}
+
+fn main() {
+    let mut garage = Garage {
+        car: Some(Car {
+            engine: Some(Engine { horsepower: 120 }),
+        }),
+    };
+
+    let kp_car = FailableWritableKeyPath::new(|g: &Garage| g.car.as_ref(), |g: &mut Garage| g.car.as_mut());
+    let kp_engine = FailableWritableKeyPath::new(|c: &Car| c.engine.as_ref(), |c: &mut Car| c.engine.as_mut());
+    let kp_hp = FailableWritableKeyPath::new(|e: &Engine| Some(&e.horsepower), |e: &mut Engine| Some(&mut e.horsepower));
+
+    // Compose: Garage -> Car -> Engine -> horsepower
+    let kp = kp_car.compose(kp_engine).compose(kp_hp);
+
+    println!("{garage:?}");
+    if let Some(hp) = kp.try_get_mut(&mut garage) {
+        *hp = 200;
+    }
+
+    println!("{garage:?}");
+}
+```
+
 ---
 
 ## 🔗 Helpful Links & Resources
@@ -160,10 +286,10 @@ fn main() {
 
 ## 🛠 Roadmap
 
-* [ ] `zip` support for combining multiple key paths (Upcoming).
+* [ ] `compose` support for combining multiple key paths.
 * [ ] Derive macros for automatic KeyPath generation (Upcoming).
-* [ ] Nested struct & enum traversal (Upcoming).
-* [ ] Optional chaining (`User?.profile?.name`) (Upcoming).
+* [ ] Nested struct & enum traversal.
+* [ ] Optional chaining (`User?.profile?.name`).
 
 ---
 

examples/basics.rs

@@ -35,7 +35,7 @@ fn main() {
 
     // Writable keypath for modifying fields:
     let width_mut: WritableKeyPath<Rectangle, u32> = WritableKeyPath::new(
-        |r: & Rectangle| & r.size.width,
+        |r: &Rectangle| &r.size.width,
         |r: &mut Rectangle| &mut r.size.width,
     );
     *(width_mut.get_mut)(&mut rect) = 100;

examples/compose.rs

@@ -40,8 +40,8 @@ fn main() {
     println!("Horsepower = {:?}", (city_hp2.get)(&city));
 
     // compose example ----
-    // compose keypath together 
-    
+    // compose keypath together
+
     let city_garage = FailableReadableKeyPath::new(|c: &City| c.garage.as_ref());
     let garage_car = FailableReadableKeyPath::new(|g: &Garage| g.car.as_ref());
     let car_engine = FailableReadableKeyPath::new(|c: &Car| c.engine.as_ref());

examples/failable.rs

@@ -1,4 +1,4 @@
-use key_paths_core::{FailableReadableKeyPath};
+use key_paths_core::FailableReadableKeyPath;
 
 #[derive(Debug)]
 struct Engine {

examples/failable_writable.rs

@@ -0,0 +1,41 @@
+use key_paths_core::FailableWritableKeyPath;
+
+#[derive(Debug)]
+struct Engine {
+    horsepower: u32,
+}
+#[derive(Debug)]
+struct Car {
+    engine: Option<Engine>,
+}
+#[derive(Debug)]
+struct Garage {
+    car: Option<Car>,
+}
+
+fn main() {
+    let mut garage = Garage {
+        car: Some(Car {
+            engine: Some(Engine { horsepower: 120 }),
+        }),
+    };
+
+    let kp_car =
+        FailableWritableKeyPath::new(|g: &Garage| g.car.as_ref(), |g: &mut Garage| g.car.as_mut());
+    let kp_engine =
+        FailableWritableKeyPath::new(|c: &Car| c.engine.as_ref(), |c: &mut Car| c.engine.as_mut());
+    let kp_hp = FailableWritableKeyPath::new(
+        |e: &Engine| Some(&e.horsepower),
+        |e: &mut Engine| Some(&mut e.horsepower),
+    );
+
+    // Compose: Garage -> Car -> Engine -> horsepower
+    let kp = kp_car.compose(kp_engine).compose(kp_hp);
+
+    println!("{garage:?}");
+    if let Some(hp) = kp.try_get_mut(&mut garage) {
+        *hp = 200;
+    }
+
+    println!("{garage:?}");
+}

examples/readable_keypath_example.rs

@@ -1,4 +1,4 @@
-use key_paths_core::{readable_keypath, ReadableKeyPath};
+use key_paths_core::{ReadableKeyPath, readable_keypath};
 
 #[derive(Debug)]
 struct User {

examples/writable_keypath_example.rs

@@ -1,5 +1,4 @@
-use key_paths_core::{writable_keypath, WritableKeyPath};
-
+use key_paths_core::{WritableKeyPath, writable_keypath};
 
 #[derive(Debug)]
 struct User {