test lens macro

Cargo.lock

···
 checksum = "1c7a8fb8a9fbf66c1f703fe16184d10ca0ee9d23be5b4436400408ba54a95005"
 
 [[package]]
-name = "fx-rs"
+name = "fx"
 version = "0.0.0-git"
 dependencies = [
  "dyn-clone",
 ]
 
 [[package]]
-name = "integration"
+name = "fx-lens"
 version = "0.0.0-git"
 dependencies = [
- "fx-rs",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
-name = "lens_macros"
+name = "integration"
 version = "0.0.0-git"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "fx",
+ "fx-lens",
 ]
 
 [[package]]

Cargo.toml

···
 [workspace]
+resolver = "3"
+
 members = [
     "fx",
     "integration",

fx/Cargo.toml

···
 [package]
-name = "fx-rs"
+name = "fx"
 description = "Algebraic Effects inspired by Kyo and Fx.go"
 readme = "README.md"
 keywords.workspace = true

integration/Cargo.toml

···
 edition.workspace = true
 
 [dependencies]
-fx-rs = { path = "../fx" }
+fx = { path = "../fx" }
+fx-lens = { path = "../lens_macros" }

integration/src/main.rs

···
-fn main() {
-    // Integration tests or binaries can be placed here.
-    println!("Integration crate ready.");
-}

integration/tests/lens_macro_test.rs

···
+use fx::{Fx, State};
+use fx_lens::Lenses;
+
+#[derive(Clone, Debug, PartialEq, Lenses)]
+struct ST {
+    a: i32,
+    b: String,
+}
+
+#[test]
+fn integration_focus_out() {
+    let e: Fx<String, ()> = State::set("hello".to_string()).then(Fx::value(()));
+    let e: Fx<ST, ()> = e.via(ST::lens_b().zoom_out());
+    let e = e.then(State::get());
+    let result = e
+        .provide(ST {
+            a: 0,
+            b: "world".to_string(),
+        })
+        .eval();
+    assert_eq!(
+        result,
+        ST {
+            a: 0,
+            b: "hello".to_string()
+        }
+    );
+}
+
+#[test]
+fn integration_focus_in() {
+    let e: Fx<ST, ()> = Fx::immediate(
+        ST {
+            a: 42,
+            b: "hello".to_string(),
+        },
+        (),
+    );
+    let e: Fx<ST, ()> = e.via(ST::lens_b().zoom_in(|()| State::set("bye".to_string()).map(|_| ())));
+    let e = e.then(State::get());
+    let result = e
+        .provide(ST {
+            a: 0,
+            b: "bad".to_string(),
+        })
+        .eval();
+    assert_eq!(
+        result,
+        ST {
+            a: 42,
+            b: "bye".to_string()
+        }
+    );
+}
+
+#[test]
+fn integration_focus_in_and_out() {
+    let inner: Fx<i32, ()> = Fx::immediate(10, ());
+    let outer: Fx<ST, ()> = inner
+        .via(ST::lens_a().zoom_out())
+        .then(State::map(|s: ST| ST { a: s.a * 2, ..s }))
+        .then(Fx::value(()));
+    let back: Fx<ST, i32> = outer.via(ST::lens_a().zoom_in(|_| State::<i32>::map(|n| n + 10)));
+    let e = back.then(State::get());
+    let result = e
+        .provide(ST {
+            a: 0,
+            b: "hello".to_owned(),
+        })
+        .eval();
+    assert_eq!(
+        result,
+        ST {
+            a: 30,
+            b: "hello".to_owned()
+        }
+    );
+}

lens_macros/Cargo.toml

···
 [package]
-name = "lens_macros"
+name = "fx-lens"
 keywords.workspace = true
 license.workspace = true
 authors.workspace = true

lens_macros/src/lib.rs

···
 use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::{Data, DeriveInput, Fields, parse_macro_input};
 
-#[proc_macro_derive(Lens)]
-pub fn derive_lens(_input: TokenStream) -> TokenStream {
-    // Implementation will go here
-    TokenStream::new()
+#[proc_macro_derive(Lenses)]
+pub fn derive_lens(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+    let vis = &input.vis;
+    let generics = &input.generics;
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    let fields = match &input.data {
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => &fields.named,
+            _ => panic!("Lens can only be derived for structs with named fields"),
+        },
+        _ => panic!("Lens can only be derived for structs"),
+    };
+
+    let lenses = fields.iter().map(|f| {
+        let fname = f.ident.as_ref().unwrap();
+        let fty = &f.ty;
+        let lens_name = format_ident!("lens_{}", fname);
+        quote! {
+            #vis fn #lens_name<'f>() -> ::fx::Lens<'f, #name #ty_generics, #fty> {
+                ::fx::Lens::new(|s: #name #ty_generics| s.#fname.clone(), |mut s, v| { s.#fname = v; s })
+            }
+        }
+    });
+
+    let expanded = quote! {
+        impl #impl_generics #name #ty_generics #where_clause {
+            #(#lenses)*
+        }
+    };
+    TokenStream::from(expanded)
 }