fmt

Author: akashsoni01

examples/enum_keypath_example.rs

@@ -40,7 +40,7 @@ fn main() {
     }
 
     // let cp4 = enum_keypath!(SomeOtherStatus::Inactive);
-    let cp4 = KeyPaths::readable_enum(|u: ()| { SomeOtherStatus::Inactive }, |u| None);
+    let cp4 = KeyPaths::readable_enum(|u: ()| SomeOtherStatus::Inactive, |u| None);
     if let Some(x) = cp4.get(&SomeOtherStatus::Inactive) {
         println!("Inactive: {:?}", x);
     }

examples/prism.rs

@@ -5,8 +5,6 @@ enum Payment {
     Card { number: String, cvv: String },
 }
 
-
-
 fn main() {
     // let kp = KeyPaths::Prism {
     //     extract: Rc::new(|p: &Payment| match p {
@@ -26,7 +24,6 @@ fn main() {
             Payment::Cash { amount } => Some(amount),
             _ => None,
         },
-
     );
 
     let mut p = Payment::Cash { amount: 10 };
@@ -39,4 +36,4 @@ fn main() {
     // kp.get_mut(&mut p); // this will return none as kp is readable
 
     println!("{:?}", p);
-}
+}

examples/prism_compose.rs

@@ -30,27 +30,21 @@ struct Rectangle {
     name: String,
 }
 
-
-
 fn main() {
     let mut a_box = ABox {
         name: String::from("A box"),
         size: Size {
             width: 10,
             height: 20,
         },
-        color: Color::Other(
-            RGBU8(10, 20, 30)
-        ),
+        color: Color::Other(RGBU8(10, 20, 30)),
     };
 
-    let color_kp: KeyPaths<ABox, Color> = KeyPaths::failable_writable(|x: &mut ABox| Some(&mut x.color));
-    
-    
+    let color_kp: KeyPaths<ABox, Color> =
+        KeyPaths::failable_writable(|x: &mut ABox| Some(&mut x.color));
+
     let case_path = KeyPaths::writable_enum(
-        {
-            |v| Color::Other(v)
-        },
+        { |v| Color::Other(v) },
         |p: &Color| match p {
             Color::Other(rgb) => Some(rgb),
             _ => None,
@@ -59,22 +53,20 @@ fn main() {
             Color::Other(rgb) => Some(rgb),
             _ => None,
         },
-
     );
-    
-    // let's compose color with rgb 
-    
+
+    // let's compose color with rgb
+
     println!("{:?}", a_box);
     let color_rgb_kp = color_kp.compose(case_path);
     if let Some(value) = color_rgb_kp.get_mut(&mut a_box) {
         *value = RGBU8(0, 0, 0);
     }
 
     println!("{:?}", a_box);
-
 }
 
 /*
 ABox { name: "A box", size: Size { width: 10, height: 20 }, color: Other(RGBU8(10, 20, 30)) }
 ABox { name: "A box", size: Size { width: 10, height: 20 }, color: Other(RGBU8(0, 0, 0)) }
-*/
+*/

key-paths-core/src/lib.rs

@@ -107,7 +107,6 @@ impl<Root, Value> KeyPaths<Root, Value> {
         }
     }
 
-
     /// Iter over immutable references if `Value: IntoIterator`
     pub fn iter<'a, T>(&'a self, root: &'a Root) -> Option<<&'a Value as IntoIterator>::IntoIter>
     where
@@ -210,9 +209,9 @@ where
             //     //         // extract_mut(r).and_then(|m| f2(m))
             //     //         // let x = f2(m);
             //     //         extract_mut(r).and_then(|a| f2(a))
-            //     // 
+            //     //
             //     //     }
-            //     //     
+            //     //
             //     // ))
             //     // FailableWritable(Rc::new(move |r| extract_mut(r).and_then(|a| f2(a))))
             //     // FailableWritable(Rc::new(move |r: &mut Root| {
@@ -221,7 +220,7 @@ where
             //     //         None => None,
             //     //     }
             //     // }) as Rc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut Value>>)
-            // 
+            //
             //     FailableWritable(Rc::new(move |r: &mut Root| {
             //         // First extract the intermediate value using extract_mut
             //         extract_mut(r).and_then(|intermediate| {
@@ -250,12 +249,12 @@ where
             //     }))
             // }
 
-/*            (FailableWritable(f2), WritableEnum { extract_mut, .. }) => {
-                FailableWritable(Rc::new(move |r: &mut Root| {
-                    extract_mut(r).and_then(|intermediate_mid| f2(intermediate_mid))
-                }))
-            }
-*/
+            /*            (FailableWritable(f2), WritableEnum { extract_mut, .. }) => {
+                            FailableWritable(Rc::new(move |r: &mut Root| {
+                                extract_mut(r).and_then(|intermediate_mid| f2(intermediate_mid))
+                            }))
+                        }
+            */
             // (FailableWritable(f2), WritableEnum { extract_mut, .. }) => {
             //     // Here's the fix: f2 must be a function that operates on a Mid and returns a Value
             //     // It is already of this type since the 'mid' KeyPaths is KeyPaths<Mid, Value>
@@ -272,8 +271,13 @@ where
             //         f2(mid_ref)
             //     }))
             // }
-
-            (FailableWritable(f_root_mid), WritableEnum { extract_mut: exm_mid_val, .. }) => {
+            (
+                FailableWritable(f_root_mid),
+                WritableEnum {
+                    extract_mut: exm_mid_val,
+                    ..
+                },
+            ) => {
                 FailableWritable(Rc::new(move |r: &mut Root| {
                     // First, apply the function that operates on Root.
                     // This will give us `Option<&mut Mid>`.
@@ -285,7 +289,6 @@ where
                 }))
             }
 
-
             (WritableEnum { extract_mut, .. }, FailableWritable(f2)) => {
                 FailableWritable(Rc::new(move |r| extract_mut(r).and_then(|m| f2(m))))
             }