zips 0.1.7

Macros for wrapping up a bunch of Option<T>'s/Result<T, E>'s into a single Option<(T [, T...])>
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

// Copyright (c) 2024 Carter Canedy <cartercanedy42@gmail.com>
use zips::zip_result;

#[allow(unused_parens)]
#[test]
pub fn test_result_1_arg() -> () {
  let res1: Result<u32, ()> = Ok(1u32);
  let zipped = zip_result!(res1);

  assert_eq!(zipped, Some((1u32)));
}

#[test]
pub fn test_result_2_args() -> () {
  let res1: Result<u32, ()> = Ok(1u32);
  let res2: Result<&'static str, ()> = Ok("2");

  let zipped = zip_result!(res1, res2);

  assert_eq!(zipped, Some((1u32, "2")));
}

#[test]
pub fn test_result_3_args() -> () {
  let res1: Result<u32, ()> = Ok(1u32);
  let res2: Result<&'static str, ()> = Ok("2");
  let res3: Result<i32, ()> = Ok(3i32);

  let zipped = zip_result!(res1, res2, res3);

  assert_eq!(zipped, Some((1u32, "2", 3i32)));
}

#[allow(unused_parens)]
#[test]
pub fn test_result_ok_unaliased_args() -> () {
  fn return_ok() -> Result<i32, ()> {
    Ok(1i32)
  }

  let zipped = zip_result!(return_ok());

  assert_eq!(zipped, Some((1i32)));
}

#[test]
pub fn test_result_err_unaliased_args() -> () {
  fn return_err() -> Result<(), ()> {
    Err(())
  }

  let zipped = zip_result!(return_err());

  assert_eq!(zipped, None);
}

#[test]
pub fn test_result_1_arg_err() -> () {
  let res1: Result<i32, ()> = Err(());
  let zipped = zip_result!(res1);

  assert_eq!(zipped, None);
}

#[test]
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);
}

#[test]
pub fn test_result_3_args_mixed() -> () {
  let res1: Result<u32, ()> = Ok(1u32);
  let res2: Result<&'static str, ()> = Err(());
  let res3: Result<i32, ()> = Ok(3i32);

  let zipped = zip_result!(res1, res2, res3);

  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);
}