bitte 0.0.1

Automatically desugar and set Send/Sync bounds on async traits
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

use bitte::bitte;
use std::sync::Arc;

#[bitte]
trait ArcService {
    async fn arc_method(self: Arc<Self>) -> String;
    async fn arc_ref_method(self: Arc<Self>) -> String;
    async fn regular_ref(&self) -> String;
    async fn regular_mut(&mut self) -> String;
    async fn by_value(self) -> String;
}

#[derive(Clone)]
struct ServiceImpl {
    name: String,
}

impl ArcService for ServiceImpl {
    fn arc_method(self: Arc<Self>) -> impl Future<Output = String> + Send
    where
        Self: Sync,
    {
        async move { format!("Arc: {}", self.name) }
    }

    fn arc_ref_method(self: Arc<Self>) -> impl Future<Output = String> + Send
    where
        Self: Sync,
    {
        async move { format!("Arc: {}", self.name) }
    }

    fn regular_ref(&self) -> impl Future<Output = String>
    where
        Self: Sync,
    {
        let name = self.name.clone();
        async move { format!("&self: {}", name) }
    }

    fn regular_mut(&mut self) -> impl Future<Output = String> + Send {
        self.name.push_str(" (modified)");
        let name = self.name.clone();
        async move { format!("&mut self: {}", name) }
    }

    fn by_value(self) -> impl Future<Output = String> {
        async move { format!("self: {}", self.name) }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_arc_methods() {
        let service = Arc::new(ServiceImpl {
            name: "test_service".to_string(),
        });

        // Test Arc<Self> method
        let result = service.clone().arc_method().await;
        assert_eq!(result, "Arc: test_service");

        // Test Arc<Self> method (both methods now take Arc<Self>)
        let result = service.clone().arc_ref_method().await;
        assert_eq!(result, "Arc: test_service");

        // Test regular &self method on Arc
        let result = service.regular_ref().await;
        assert_eq!(result, "&self: test_service");
    }

    #[tokio::test]
    async fn test_regular_methods() {
        let mut service = ServiceImpl {
            name: "mutable_service".to_string(),
        };

        // Test &mut self
        let result = service.regular_mut().await;
        assert_eq!(result, "&mut self: mutable_service (modified)");
        assert_eq!(service.name, "mutable_service (modified)");

        // Test by value
        let service2 = ServiceImpl {
            name: "consumed".to_string(),
        };
        let result = service2.by_value().await;
        assert_eq!(result, "self: consumed");
    }

    #[test]
    fn test_arc_futures_are_send_and_sync() {
        fn assert_send<T: Send>(_: T) {}
        fn assert_sync<T: Sync>(_: T) {}

        let service = Arc::new(ServiceImpl {
            name: "test".to_string(),
        });

        // Arc<Self> methods should produce Send + Sync futures
        let future1 = service.clone().arc_method();
        assert_send(future1);

        let future2 = service.clone().arc_method();
        assert_sync(future2);

        // Arc<Self> methods should also be Send + Sync
        let future3 = service.clone().arc_ref_method();
        assert_send(future3);

        let future4 = service.arc_ref_method();
        assert_sync(future4);
    }

    #[test]
    fn test_ref_futures_bounds() {
        fn assert_send<T: Send>(_: T) {}

        let service = ServiceImpl {
            name: "test".to_string(),
        };

        // &self methods should produce Send futures when Self: Sync
        let future = service.regular_ref();
        assert_send(future);
    }
}

// Test with generic Arc<Self>
#[bitte]
trait GenericArcService<T: Send + Sync + 'static> {
    async fn process(self: Arc<Self>, value: T) -> T;
}

struct GenericServiceImpl;

impl<T: Send + Sync + 'static> GenericArcService<T> for GenericServiceImpl {
    fn process(self: Arc<Self>, value: T) -> impl Future<Output = T> + Send
    where
        Self: Sync,
    {
        async move {
            // Simulate some async work
            tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
            value
        }
    }
}

#[cfg(test)]
mod generic_arc_tests {
    use super::*;

    #[tokio::test]
    async fn test_generic_arc() {
        let service = Arc::new(GenericServiceImpl);

        let result = service.clone().process(42).await;
        assert_eq!(result, 42);

        let result = service.process("hello".to_string()).await;
        assert_eq!(result, "hello");
    }
}