flutter_rust_bridge_codegen 2.14.0-beta.1

Flutter/Dart <-> Rust binding generator, feature-rich, but seamless and simple
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
115
116
117
118
119
120

// https://stackoverflow.com/questions/63644071/idiomatic-way-to-filter-values-matching-a-pattern-in-an-iterator
#[doc(hidden)] // only to be used within crate, not for end users
#[macro_export]
macro_rules! if_then_some {
    ($cond: expr, $val: expr) => {
        if $cond {
            Some($val)
        } else {
            None
        }
    };
    (let $pattern:pat = $expr: expr, $val: expr) => {
        if let $pattern = $expr {
            Some($val)
        } else {
            None
        }
    };
}

#[cfg(test)]
mod tests {
    /// Evaluates the value expression only when the condition is true.
    #[test]
    fn test_if_then_some_expression_arm_returns_some_or_none_lazily() {
        let mut condition_evaluations = 0;
        let mut value_evaluations = 0;

        let present = crate::if_then_some!(
            {
                condition_evaluations += 1;
                true
            },
            {
                value_evaluations += 1;
                "present"
            }
        );
        let absent = crate::if_then_some!(false, {
            value_evaluations += 1;
            "absent"
        });

        assert_eq!(present, Some("present"));
        assert_eq!(absent, None);
        assert_eq!(condition_evaluations, 1);
        assert_eq!(value_evaluations, 1);
    }

    /// Evaluates a false condition once without evaluating its value expression.
    #[test]
    fn test_if_then_some_expression_arm_evaluates_false_condition_once() {
        let mut condition_evaluations = 0;
        let mut value_evaluations = 0;

        let result = crate::if_then_some!(
            {
                condition_evaluations += 1;
                false
            },
            {
                value_evaluations += 1;
                "unreachable"
            }
        );

        assert_eq!(result, None);
        assert_eq!(condition_evaluations, 1);
        assert_eq!(value_evaluations, 0);
    }

    /// Returns Some only for matching patterns without evaluating absent values.
    #[test]
    fn test_if_then_some_pattern_arm_matches_and_is_lazy() {
        let mut expression_evaluations = 0;
        let mut value_evaluations = 0;

        let matched = crate::if_then_some!(
            let Some(value) = {
                expression_evaluations += 1;
                Some(3)
            },
            {
                value_evaluations += 1;
                value * 2
            }
        );
        let unmatched = crate::if_then_some!(let Some(value) = None::<u8>, {
            value_evaluations += 1;
            value * 2
        });

        assert_eq!(matched, Some(6));
        assert_eq!(unmatched, None);
        assert_eq!(expression_evaluations, 1);
        assert_eq!(value_evaluations, 1);
    }

    /// Evaluates an unmatched expression once without evaluating its value expression.
    #[test]
    fn test_if_then_some_pattern_arm_evaluates_unmatched_expression_once() {
        let mut expression_evaluations = 0;
        let mut value_evaluations = 0;

        let result = crate::if_then_some!(
            let Some(value) = {
                expression_evaluations += 1;
                None::<u8>
            },
            {
                value_evaluations += 1;
                value * 2
            }
        );

        assert_eq!(result, None);
        assert_eq!(expression_evaluations, 1);
        assert_eq!(value_evaluations, 0);
    }
}