sodium_rust/impl_/
lambda.rs

1#![allow(clippy::many_single_char_names)]
2
3use crate::impl_::dep::Dep;
4
5pub struct Lambda<FN> {
6    f: FN,
7    deps: Vec<Dep>,
8}
9
10pub fn lambda1_deps<A, B, FN: IsLambda1<A, B>>(f: &FN) -> Vec<Dep> {
11    f.deps_op().cloned().unwrap_or_default()
12}
13
14pub fn lambda2_deps<A, B, C, FN: IsLambda2<A, B, C>>(f: &FN) -> Vec<Dep> {
15    f.deps_op().cloned().unwrap_or_default()
16}
17
18pub fn lambda3_deps<A, B, C, D, FN: IsLambda3<A, B, C, D>>(f: &FN) -> Vec<Dep> {
19    f.deps_op().cloned().unwrap_or_default()
20}
21
22pub fn lambda4_deps<A, B, C, D, E, FN: IsLambda4<A, B, C, D, E>>(f: &FN) -> Vec<Dep> {
23    f.deps_op().cloned().unwrap_or_default()
24}
25
26pub fn lambda5_deps<A, B, C, D, E, F, FN: IsLambda5<A, B, C, D, E, F>>(f: &FN) -> Vec<Dep> {
27    f.deps_op().cloned().unwrap_or_default()
28}
29
30pub fn lambda6_deps<A, B, C, D, E, F, G, FN: IsLambda6<A, B, C, D, E, F, G>>(f: &FN) -> Vec<Dep> {
31    f.deps_op().cloned().unwrap_or_default()
32}
33
34/// Interface for a lambda function of one argument.
35pub trait IsLambda1<A, B> {
36    fn call(&mut self, a: &A) -> B;
37    fn deps_op(&self) -> Option<&Vec<Dep>>;
38}
39
40/// Interface for a lambda function of two arguments.
41pub trait IsLambda2<A, B, C> {
42    fn call(&mut self, a: &A, b: &B) -> C;
43    fn deps_op(&self) -> Option<&Vec<Dep>>;
44}
45
46/// Interface for a lambda function of three arguments.
47pub trait IsLambda3<A, B, C, D> {
48    fn call(&mut self, a: &A, b: &B, c: &C) -> D;
49    fn deps_op(&self) -> Option<&Vec<Dep>>;
50}
51
52/// Interface for a lambda function of four arguments.
53pub trait IsLambda4<A, B, C, D, E> {
54    fn call(&mut self, a: &A, b: &B, c: &C, d: &D) -> E;
55    fn deps_op(&self) -> Option<&Vec<Dep>>;
56}
57
58/// Interface for a lambda function of five arguments.
59pub trait IsLambda5<A, B, C, D, E, F> {
60    fn call(&mut self, a: &A, b: &B, c: &C, d: &D, e: &E) -> F;
61    fn deps_op(&self) -> Option<&Vec<Dep>>;
62}
63
64/// Interface for a lambda function of six arguments.
65pub trait IsLambda6<A, B, C, D, E, F, G> {
66    fn call(&mut self, a: &A, b: &B, c: &C, d: &D, e: &E, f: &F) -> G;
67    fn deps_op(&self) -> Option<&Vec<Dep>>;
68}
69
70impl<A, B, FN: FnMut(&A) -> B> IsLambda1<A, B> for Lambda<FN> {
71    fn call(&mut self, a: &A) -> B {
72        (self.f)(a)
73    }
74
75    fn deps_op(&self) -> Option<&Vec<Dep>> {
76        Some(&self.deps)
77    }
78}
79
80impl<A, B, FN: FnMut(&A) -> B> IsLambda1<A, B> for FN {
81    fn call(&mut self, a: &A) -> B {
82        self(a)
83    }
84
85    fn deps_op(&self) -> Option<&Vec<Dep>> {
86        None
87    }
88}
89
90impl<A, B, C, FN: FnMut(&A, &B) -> C> IsLambda2<A, B, C> for Lambda<FN> {
91    fn call(&mut self, a: &A, b: &B) -> C {
92        (self.f)(a, b)
93    }
94
95    fn deps_op(&self) -> Option<&Vec<Dep>> {
96        Some(&self.deps)
97    }
98}
99
100impl<A, B, C, FN: FnMut(&A, &B) -> C> IsLambda2<A, B, C> for FN {
101    fn call(&mut self, a: &A, b: &B) -> C {
102        self(a, b)
103    }
104
105    fn deps_op(&self) -> Option<&Vec<Dep>> {
106        None
107    }
108}
109
110impl<A, B, C, D, FN: FnMut(&A, &B, &C) -> D> IsLambda3<A, B, C, D> for Lambda<FN> {
111    fn call(&mut self, a: &A, b: &B, c: &C) -> D {
112        (self.f)(a, b, c)
113    }
114
115    fn deps_op(&self) -> Option<&Vec<Dep>> {
116        Some(&self.deps)
117    }
118}
119
120impl<A, B, C, D, FN: FnMut(&A, &B, &C) -> D> IsLambda3<A, B, C, D> for FN {
121    fn call(&mut self, a: &A, b: &B, c: &C) -> D {
122        self(a, b, c)
123    }
124
125    fn deps_op(&self) -> Option<&Vec<Dep>> {
126        None
127    }
128}
129
130impl<A, B, C, D, E, FN: FnMut(&A, &B, &C, &D) -> E> IsLambda4<A, B, C, D, E> for Lambda<FN> {
131    fn call(&mut self, a: &A, b: &B, c: &C, d: &D) -> E {
132        (self.f)(a, b, c, d)
133    }
134
135    fn deps_op(&self) -> Option<&Vec<Dep>> {
136        Some(&self.deps)
137    }
138}
139
140impl<A, B, C, D, E, FN: FnMut(&A, &B, &C, &D) -> E> IsLambda4<A, B, C, D, E> for FN {
141    fn call(&mut self, a: &A, b: &B, c: &C, d: &D) -> E {
142        self(a, b, c, d)
143    }
144
145    fn deps_op(&self) -> Option<&Vec<Dep>> {
146        None
147    }
148}
149
150impl<A, B, C, D, E, F, FN: FnMut(&A, &B, &C, &D, &E) -> F> IsLambda5<A, B, C, D, E, F>
151    for Lambda<FN>
152{
153    fn call(&mut self, a: &A, b: &B, c: &C, d: &D, e: &E) -> F {
154        (self.f)(a, b, c, d, e)
155    }
156
157    fn deps_op(&self) -> Option<&Vec<Dep>> {
158        Some(&self.deps)
159    }
160}
161
162impl<A, B, C, D, E, F, FN: FnMut(&A, &B, &C, &D, &E) -> F> IsLambda5<A, B, C, D, E, F> for FN {
163    fn call(&mut self, a: &A, b: &B, c: &C, d: &D, e: &E) -> F {
164        self(a, b, c, d, e)
165    }
166
167    fn deps_op(&self) -> Option<&Vec<Dep>> {
168        None
169    }
170}
171
172impl<A, B, C, D, E, F, G, FN: FnMut(&A, &B, &C, &D, &E, &F) -> G> IsLambda6<A, B, C, D, E, F, G>
173    for Lambda<FN>
174{
175    fn call(&mut self, a: &A, b: &B, c: &C, d: &D, e: &E, f: &F) -> G {
176        (self.f)(a, b, c, d, e, f)
177    }
178
179    fn deps_op(&self) -> Option<&Vec<Dep>> {
180        Some(&self.deps)
181    }
182}
183
184impl<A, B, C, D, E, F, G, FN: FnMut(&A, &B, &C, &D, &E, &F) -> G> IsLambda6<A, B, C, D, E, F, G>
185    for FN
186{
187    fn call(&mut self, a: &A, b: &B, c: &C, d: &D, e: &E, f: &F) -> G {
188        self(a, b, c, d, e, f)
189    }
190
191    fn deps_op(&self) -> Option<&Vec<Dep>> {
192        None
193    }
194}
195
196pub fn lambda1<A, B, FN: FnMut(&A) -> B>(f: FN, deps: Vec<Dep>) -> Lambda<FN> {
197    Lambda { f, deps }
198}
199
200pub fn lambda2<A, B, C, FN: FnMut(&A, &B) -> C>(f: FN, deps: Vec<Dep>) -> Lambda<FN> {
201    Lambda { f, deps }
202}
203
204pub fn lambda3<A, B, C, D, FN: FnMut(&A, &B, &C) -> D>(f: FN, deps: Vec<Dep>) -> Lambda<FN> {
205    Lambda { f, deps }
206}
207
208pub fn lambda4<A, B, C, D, E, FN: FnMut(&A, &B, &C, &D) -> E>(f: FN, deps: Vec<Dep>) -> Lambda<FN> {
209    Lambda { f, deps }
210}
211
212pub fn lambda5<A, B, C, D, E, F, FN: FnMut(&A, &B, &C, &D, &E) -> F>(
213    f: FN,
214    deps: Vec<Dep>,
215) -> Lambda<FN> {
216    Lambda { f, deps }
217}
218
219pub fn lambda6<A, B, C, D, E, F, G, FN: FnMut(&A, &B, &C, &D, &E, &F) -> G>(
220    f: FN,
221    deps: Vec<Dep>,
222) -> Lambda<FN> {
223    Lambda { f, deps }
224}
sodium_rust/impl_/lambda.rs

sodium_rust/impl_/
lambda.rs
