ark_r1cs_std/
macros.rs

1#[allow(unused_braces)]
2/// Implements arithmetic traits (eg: `Add`, `Sub`, `Mul`) for the given type
3/// using the impl in `$impl`.
4///
5/// Used primarily for implementing these traits for `FieldVar`s and
6/// `GroupVar`s.
7#[macro_export]
8macro_rules! impl_ops {
9    (
10        $type: ty,
11        $native: ty,
12        $trait: ident,
13        $fn: ident,
14        $assign_trait: ident,
15        $assign_fn: ident,
16        $impl: expr,
17        $constant_impl: expr,
18        $($args:tt)*
19    ) => {
20        impl_bounded_ops!($type, $native, $trait, $fn, $assign_trait, $assign_fn, $impl, $constant_impl, ($($args)+), );
21    };
22}
23
24/// Implements arithmetic traits (eg: `Add`, `Sub`, `Mul`) for the given type
25/// using the impl in `$impl`.
26///
27/// Used primarily for implementing these traits for `FieldVar`s and
28/// `GroupVar`s.
29///
30/// When compared to `impl_ops`, this macro allows specifying additional trait
31/// bounds.
32#[macro_export]
33macro_rules! impl_bounded_ops {
34    (
35        $type: ty,
36        $native: ty,
37        $trait: ident,
38        $fn: ident,
39        $assign_trait: ident,
40        $assign_fn: ident,
41        $impl: expr,
42        $constant_impl: expr,
43        ($($params:tt)+),
44        $($bounds:tt)*
45    ) => {
46        impl<'a, $($params)+> core::ops::$trait<&'a $type> for &'a $type
47        where
48            $($bounds)*
49        {
50            type Output = $type;
51
52            #[tracing::instrument(target = "r1cs", skip(self))]
53            #[allow(unused_braces, clippy::redundant_closure_call)]
54            fn $fn(self, other: &'a $type) -> Self::Output {
55                ($impl)(self, other)
56            }
57        }
58
59        impl<'a, $($params)+> core::ops::$trait<$type> for &'a $type
60        where
61            $($bounds)*
62        {
63            type Output = $type;
64
65            #[tracing::instrument(target = "r1cs", skip(self))]
66            #[allow(unused_braces)]
67            fn $fn(self, other: $type) -> Self::Output {
68                core::ops::$trait::$fn(self, &other)
69            }
70        }
71
72        impl<'a, $($params)+> core::ops::$trait<&'a $type> for $type
73        where
74            $($bounds)*
75        {
76            type Output = $type;
77
78            #[tracing::instrument(target = "r1cs", skip(self))]
79            #[allow(unused_braces)]
80            fn $fn(self, other: &'a $type) -> Self::Output {
81                core::ops::$trait::$fn(&self, other)
82            }
83        }
84
85        impl<$($params)+> core::ops::$trait<$type> for $type
86        where
87
88            $($bounds)*
89        {
90            type Output = $type;
91
92            #[tracing::instrument(target = "r1cs", skip(self))]
93            #[allow(unused_braces)]
94            fn $fn(self, other: $type) -> Self::Output {
95                core::ops::$trait::$fn(&self, &other)
96            }
97        }
98
99        impl<$($params)+> core::ops::$assign_trait<$type> for $type
100        where
101
102            $($bounds)*
103        {
104            #[tracing::instrument(target = "r1cs", skip(self))]
105            #[allow(unused_braces)]
106            fn $assign_fn(&mut self, other: $type) {
107                let result = core::ops::$trait::$fn(&*self, &other);
108                *self = result
109            }
110        }
111
112        impl<'a, $($params)+> core::ops::$assign_trait<&'a $type> for $type
113        where
114
115            $($bounds)*
116        {
117            #[tracing::instrument(target = "r1cs", skip(self))]
118            #[allow(unused_braces)]
119            fn $assign_fn(&mut self, other: &'a $type) {
120                let result = core::ops::$trait::$fn(&*self, other);
121                *self = result
122            }
123        }
124
125        impl<'a, $($params)+> core::ops::$trait<$native> for &'a $type
126        where
127
128            $($bounds)*
129        {
130            type Output = $type;
131
132            #[tracing::instrument(target = "r1cs", skip(self))]
133            #[allow(unused_braces, clippy::redundant_closure_call)]
134            fn $fn(self, other: $native) -> Self::Output {
135                ($constant_impl)(self, other)
136            }
137        }
138
139        impl<$($params)+> core::ops::$trait<$native> for $type
140        where
141
142            $($bounds)*
143        {
144            type Output = $type;
145
146            #[tracing::instrument(target = "r1cs", skip(self))]
147            #[allow(unused_braces)]
148            fn $fn(self, other: $native) -> Self::Output {
149                core::ops::$trait::$fn(&self, other)
150            }
151        }
152
153        impl<$($params)+> core::ops::$assign_trait<$native> for $type
154        where
155
156            $($bounds)*
157        {
158
159            #[tracing::instrument(target = "r1cs", skip(self))]
160            #[allow(unused_braces)]
161            fn $assign_fn(&mut self, other: $native) {
162                let result = core::ops::$trait::$fn(&*self, other);
163                *self = result
164            }
165        }
166    }
167}
168
169/// Implements arithmetic traits (eg: `Add`, `Sub`, `Mul`) for the given type
170/// using the impl in `$impl`.
171///
172/// Used primarily for implementing these traits for `FieldVar`s and
173/// `GroupVar`s.
174///
175/// When compared to `impl_ops`, this macro allows specifying additional trait
176/// bounds.
177#[macro_export]
178macro_rules! impl_bounded_ops_diff {
179    (
180        $type: ty,
181        $native: ty,
182        $other_type: ty,
183        $other_native: ty,
184        $trait: ident,
185        $fn: ident,
186        $assign_trait: ident,
187        $assign_fn: ident,
188        $impl: expr,
189        $constant_impl: expr,
190        ($($params:tt)+),
191        $($bounds:tt)*
192    ) => {
193        impl<'a, $($params)+> core::ops::$trait<&'a $other_type> for &'a $type
194        where
195            $($bounds)*
196        {
197            type Output = $type;
198
199            #[tracing::instrument(target = "r1cs", skip(self))]
200            #[allow(unused_braces, clippy::redundant_closure_call)]
201            fn $fn(self, other: &'a $other_type) -> Self::Output {
202                ($impl)(self, other)
203            }
204        }
205
206        impl<'a, $($params)+> core::ops::$trait<$other_type> for &'a $type
207        where
208            $($bounds)*
209        {
210            type Output = $type;
211
212            #[tracing::instrument(target = "r1cs", skip(self))]
213            #[allow(unused_braces)]
214            fn $fn(self, other: $other_type) -> Self::Output {
215                core::ops::$trait::$fn(self, &other)
216            }
217        }
218
219        impl<'a, $($params)+> core::ops::$trait<&'a $other_type> for $type
220        where
221            $($bounds)*
222        {
223            type Output = $type;
224
225            #[tracing::instrument(target = "r1cs", skip(self))]
226            #[allow(unused_braces)]
227            fn $fn(self, other: &'a $other_type) -> Self::Output {
228                core::ops::$trait::$fn(&self, other)
229            }
230        }
231
232        impl<$($params)+> core::ops::$trait<$other_type> for $type
233        where
234
235            $($bounds)*
236        {
237            type Output = $type;
238
239            #[tracing::instrument(target = "r1cs", skip(self))]
240            #[allow(unused_braces)]
241            fn $fn(self, other: $other_type) -> Self::Output {
242                core::ops::$trait::$fn(&self, &other)
243            }
244        }
245
246        impl<$($params)+> core::ops::$assign_trait<$other_type> for $type
247        where
248
249            $($bounds)*
250        {
251            #[tracing::instrument(target = "r1cs", skip(self))]
252            #[allow(unused_braces)]
253            fn $assign_fn(&mut self, other: $other_type) {
254                let result = core::ops::$trait::$fn(&*self, &other);
255                *self = result
256            }
257        }
258
259        impl<'a, $($params)+> core::ops::$assign_trait<&'a $other_type> for $type
260        where
261
262            $($bounds)*
263        {
264            #[tracing::instrument(target = "r1cs", skip(self))]
265            #[allow(unused_braces)]
266            fn $assign_fn(&mut self, other: &'a $other_type) {
267                let result = core::ops::$trait::$fn(&*self, other);
268                *self = result
269            }
270        }
271    }
272}
ark_r1cs_std/macros.rs

ark_r1cs_std/
macros.rs
