add field_lens! macro

examples/convoluted.rs

@@ -0,0 +1,48 @@
+use bad_optics::{lenses::*, prisms::*, traversals::*};
+
+#[derive(Debug, PartialEq, Clone)]
+struct MyStruct {
+    hey: (u8, (u8, [Option<i32>; 5])),
+}
+
+fn main() {
+    // make a lens that accesses `hey` in `MyStruct`
+    let hey = lens(
+        |hello: MyStruct| hello.hey,
+        |mut hello: MyStruct, v| {
+            hello.hey = v;
+            hello
+        },
+    );
+
+    // the thing we want to access
+    let thing: (MyStruct, &'static str) = (
+        MyStruct {
+            hey: (1, (2, [None, Some(1), Some(2), None, Some(4)])),
+        },
+        "hello",
+    );
+
+    let array_lens = _0 // access the first element in the tuple
+              + hey // access hey
+              + _1 // access the second element in the tuple
+              + _1; // access the second element in the tuple
+
+    assert_eq!(array_lens(thing.clone()).len(), 5);
+
+    let lens = array_lens
+              + each // access each element of the [Option<i32>; 5] array
+              + _Some; // access the ones that are Some;
+
+    assert_eq!(lens(thing.clone()), vec![1, 2, 4]);
+
+    assert_eq!(
+        lens(thing, |v| v + 10),
+        (
+            MyStruct {
+                hey: (1, (2, [None, Some(11), Some(12), None, Some(14)])),
+            },
+            "hello",
+        )
+    );
+}

src/lenses/fields.rs

@@ -0,0 +1,12 @@
+#[macro_export]
+macro_rules! field_lens {
+    ($type:ident, $field:ident) => {
+        lens(
+            |v: $type| v.$field,
+            |mut u: $type, v| {
+                u.$field = v;
+                u
+            },
+        )
+    };
+}

src/lenses/mod.rs

@@ -1,3 +1,5 @@
+mod fields;
+
 mod identity;
 pub use identity::id;
 
@@ -164,6 +166,18 @@ mod tests {
         assert_eq!(l(hello), 8);
     }
 
+    #[test]
+    fn can_make_lens_for_field() {
+        // making a lens
+        let l = crate::field_lens!(Hello, hey);
+
+        let hello = Hello { hey: 8 };
+        assert_eq!(l(hello), 8);
+
+        let hello = Hello { hey: 8 };
+        assert_eq!(l(hello, |v| v + 1), Hello { hey: 9 });
+    }
+
     #[test]
     fn can_make_lens_out_of_funcs() {
         // making a lens