add nested invokation tests (#9)

Author: cartercanedy

Cargo.toml

@@ -3,8 +3,7 @@ name = "zips"
 description = "Macros for wrapping up a bunch of Option<T>'s/Result<T, E>'s into a single Option<(T [, T...])>"
 version = "0.1.5"
 edition = "2021"
-author = "Carter Canedy"
-email = "[email protected]"
+authors = ["Carter Canedy <[email protected]>"]
 repository = "https://github.com/cartercanedy/zips"
 license = "MIT"
 
@@ -14,4 +13,4 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0.86"
 quote = "1.0.36"
-syn = { version = "2.0.71", features = ["parsing", "derive", "proc-macro", "printing"], default-features = false }
+syn = { version = "~2.0.77", features = ["parsing", "derive", "proc-macro", "printing"], default-features = false }

tests/test_option.rs

@@ -1,14 +1,6 @@
 // Copyright (c) 2024 Carter Canedy <[email protected]>
 use zips::zip;
 
-fn return_some() -> Option<()> {
-  Some(())
-}
-
-fn return_none() -> Option<()> {
-  None
-}
-
 #[allow(unused_parens)]
 #[test]
 pub fn test_zip_1_option() -> () {
@@ -40,15 +32,15 @@ pub fn test_zip_3_options() -> () {
 
 #[test]
 pub fn test_zip_1_option_none() -> () {
-  let opt1 = return_none();
+  let opt1 = Option::<()>::None;
   let zipped = zip!(opt1);
   assert_eq!(zipped, None);
 }
 
 #[test]
 pub fn test_zip_2_options_mixed() -> () {
-  let opt1 = return_none();
-  let opt2 = return_some();
+  let opt1 = Option::<()>::None;
+  let opt2 = Option::<()>::None;
 
   let zipped = zip!(opt1, opt2);
 
@@ -57,9 +49,9 @@ pub fn test_zip_2_options_mixed() -> () {
 
 #[test]
 pub fn test_zip_3_options_mixed() -> () {
-  let opt1 = return_none();
-  let opt2 = return_some();
-  let opt3 = return_some();
+  let opt1 = Option::<()>::None;
+  let opt2 = Some(Option::<()>::None);
+  let opt3 = Some(());
 
   let zipped = zip!(opt1, opt2, opt3);
 
@@ -69,23 +61,23 @@ pub fn test_zip_3_options_mixed() -> () {
 #[allow(unused_parens)]
 #[test]
 pub fn test_zip_some_unaliased_arg() -> () {
-  let zipped = zip!(return_some());
-  
-  assert_eq!(zipped, Some((())));
+  let zipped = zip!(Some(()));
+
+  assert_eq!(zipped, Some(()));
 }
 
 #[test]
 pub fn test_zip_none_unaliased_arg() -> () {
-  let zipped = zip!(return_none());
-  
+  let zipped = zip!(Option::<()>::None);
+
   assert_eq!(zipped, None);
 }
 
 #[test]
 pub fn test_zip_mixed_unaliased_args() -> () {
   let zipped = zip!(
-    return_some(),
-    return_none()
+    Some(()),
+    Option::<()>::None
   );
 
   assert_eq!(zipped, None);
@@ -95,9 +87,31 @@ pub fn test_zip_mixed_unaliased_args() -> () {
 pub fn test_zip_some_unaliased_args() -> () {
   let zipped = zip!(
     Some(1u32),
-    Some("2"),
+    Some(()),
     Some(3usize)
   );
-  
-  assert_eq!(zipped, Some((1u32, "2", 3usize)));
+
+  assert_eq!(zipped, Some((1u32, (), 3usize)));
+}
+
+#[test]
+pub fn test_zip_some_nested_invokations() -> () {
+  let a = Some(1i32);
+  let b = Some(0usize);
+  let c = Some(());
+
+  let zipped = zip!(zip!(a, b), c);
+
+  assert_eq!(zipped, Some(((1i32, 0usize), ())));
+}
+
+#[test]
+pub fn test_zip_none_nested_invokations() -> () {
+  let a = Some(1i32);
+  let b = Some(0usize);
+  let c = Option::<()>::None;
+
+  let zipped = zip!(a, zip!(b, c));
+
+  assert_eq!(zipped, None);
 }

tests/test_result.rs

@@ -66,7 +66,7 @@ pub fn test_result_1_arg_err() -> () {
 pub fn test_result_2_args_mixed() -> () {
   let res1: Result<i32, ()> = Ok(1i32);
   let res2: Result<&'static str, ()> = Err(());
-  
+
   let zipped = zip_result!(res1, res2);
 
   assert_eq!(zipped, None);
@@ -82,3 +82,33 @@ pub fn test_result_3_args_mixed() -> () {
 
   assert_eq!(zipped, None);
 }
+
+#[test]
+pub fn test_result_ok_nested_invokations() -> () {
+  type Res = Result<(), ()>;
+  let a = Res::Ok(());
+  let b = Res::Ok(());
+  let c = Result::<i32, ()>::Ok(1i32);
+
+  let zipped = zip_result!(
+    Result::<_, ()>::Ok(zip_result!(a, b).unwrap()),
+    c
+  );
+
+  assert_eq!(zipped, Some((((), ()), 1i32)));
+}
+
+#[test]
+pub fn test_result_err_nested_invokations() -> () {
+  type Res = Result<(), ()>;
+  let a = Res::Ok(());
+  let b = Res::Ok(());
+  let c = Result::<(), i32>::Err(1i32);
+
+  let zipped = zip_result!(
+    Result::<_, ()>::Ok(zip_result!(a, b).unwrap()),
+    c
+  );
+
+  assert_eq!(zipped, None);
+}