1 | use core::fmt::{self, Debug}; |
---|---|

2 | use core::marker::PhantomData; |

3 | |

4 | pub trait FnOnce1<A> { |

5 | type Output; |

6 | fn call_once(self, arg: A) -> Self::Output; |

7 | } |

8 | |

9 | impl<T, A, R> FnOnce1<A> for T |

10 | where |

11 | T: FnOnce(A) -> R, |

12 | { |

13 | type Output = R; |

14 | fn call_once(self, arg: A) -> R { |

15 | self(arg) |

16 | } |

17 | } |

18 | |

19 | pub trait FnMut1<A>: FnOnce1<A> { |

20 | fn call_mut(&mut self, arg: A) -> Self::Output; |

21 | } |

22 | |

23 | impl<T, A, R> FnMut1<A> for T |

24 | where |

25 | T: FnMut(A) -> R, |

26 | { |

27 | fn call_mut(&mut self, arg: A) -> R { |

28 | self(arg) |

29 | } |

30 | } |

31 | |

32 | // Not used, but present for completeness |

33 | #[allow(unreachable_pub)] |

34 | pub trait Fn1<A>: FnMut1<A> { |

35 | fn call(&self, arg: A) -> Self::Output; |

36 | } |

37 | |

38 | impl<T, A, R> Fn1<A> for T |

39 | where |

40 | T: Fn(A) -> R, |

41 | { |

42 | fn call(&self, arg: A) -> R { |

43 | self(arg) |

44 | } |

45 | } |

46 | |

47 | macro_rules! trivial_fn_impls { |

48 | ($name:ident <$($arg:ident),*> $t:ty = $debug:literal) => { |

49 | impl<$($arg),*> Copy for $t {} |

50 | impl<$($arg),*> Clone for $t { |

51 | fn clone(&self) -> Self { *self } |

52 | } |

53 | impl<$($arg),*> Debug for $t { |

54 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |

55 | f.write_str($debug) |

56 | } |

57 | } |

58 | impl<$($arg,)* A> FnMut1<A> for $t where Self: FnOnce1<A> { |

59 | fn call_mut(&mut self, arg: A) -> Self::Output { |

60 | self.call_once(arg) |

61 | } |

62 | } |

63 | impl<$($arg,)* A> Fn1<A> for $t where Self: FnOnce1<A> { |

64 | fn call(&self, arg: A) -> Self::Output { |

65 | self.call_once(arg) |

66 | } |

67 | } |

68 | pub(crate) fn $name<$($arg),*>() -> $t { |

69 | Default::default() |

70 | } |

71 | } |

72 | } |

73 | |

74 | pub struct OkFn<E>(PhantomData<fn(E)>); |

75 | |

76 | impl<E> Default for OkFn<E> { |

77 | fn default() -> Self { |

78 | Self(PhantomData) |

79 | } |

80 | } |

81 | |

82 | impl<A, E> FnOnce1<A> for OkFn<E> { |

83 | type Output = Result<A, E>; |

84 | fn call_once(self, arg: A) -> Self::Output { |

85 | Ok(arg) |

86 | } |

87 | } |

88 | |

89 | trivial_fn_impls!(ok_fn <T> OkFn<T> = "Ok"); |

90 | |

91 | #[derive(Debug, Copy, Clone, Default)] |

92 | pub struct ChainFn<F, G>(F, G); |

93 | |

94 | impl<F, G, A> FnOnce1<A> for ChainFn<F, G> |

95 | where |

96 | F: FnOnce1<A>, |

97 | G: FnOnce1<F::Output>, |

98 | { |

99 | type Output = G::Output; |

100 | fn call_once(self, arg: A) -> Self::Output { |

101 | self.1.call_once(self.0.call_once(arg)) |

102 | } |

103 | } |

104 | impl<F, G, A> FnMut1<A> for ChainFn<F, G> |

105 | where |

106 | F: FnMut1<A>, |

107 | G: FnMut1<F::Output>, |

108 | { |

109 | fn call_mut(&mut self, arg: A) -> Self::Output { |

110 | self.1.call_mut(self.0.call_mut(arg)) |

111 | } |

112 | } |

113 | impl<F, G, A> Fn1<A> for ChainFn<F, G> |

114 | where |

115 | F: Fn1<A>, |

116 | G: Fn1<F::Output>, |

117 | { |

118 | fn call(&self, arg: A) -> Self::Output { |

119 | self.1.call(self.0.call(arg)) |

120 | } |

121 | } |

122 | pub(crate) fn chain_fn<F, G>(f: F, g: G) -> ChainFn<F, G> { |

123 | ChainFn(f, g) |

124 | } |

125 | |

126 | #[derive(Default)] |

127 | pub struct MergeResultFn; |

128 | |

129 | impl<T> FnOnce1<Result<T, T>> for MergeResultFn { |

130 | type Output = T; |

131 | fn call_once(self, arg: Result<T, T>) -> Self::Output { |

132 | match arg { |

133 | Ok(x) => x, |

134 | Err(x) => x, |

135 | } |

136 | } |

137 | } |

138 | trivial_fn_impls!(merge_result_fn <> MergeResultFn = "merge_result"); |

139 | |

140 | #[derive(Debug, Copy, Clone, Default)] |

141 | pub struct InspectFn<F>(F); |

142 | |

143 | #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058 |

144 | impl<F, A> FnOnce1<A> for InspectFn<F> |

145 | where |

146 | F: for<'a> FnOnce1<&'a A, Output = ()>, |

147 | { |

148 | type Output = A; |

149 | fn call_once(self, arg: A) -> Self::Output { |

150 | self.0.call_once(&arg); |

151 | arg |

152 | } |

153 | } |

154 | #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058 |

155 | impl<F, A> FnMut1<A> for InspectFn<F> |

156 | where |

157 | F: for<'a> FnMut1<&'a A, Output = ()>, |

158 | { |

159 | fn call_mut(&mut self, arg: A) -> Self::Output { |

160 | self.0.call_mut(&arg); |

161 | arg |

162 | } |

163 | } |

164 | #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058 |

165 | impl<F, A> Fn1<A> for InspectFn<F> |

166 | where |

167 | F: for<'a> Fn1<&'a A, Output = ()>, |

168 | { |

169 | fn call(&self, arg: A) -> Self::Output { |

170 | self.0.call(&arg); |

171 | arg |

172 | } |

173 | } |

174 | pub(crate) fn inspect_fn<F>(f: F) -> InspectFn<F> { |

175 | InspectFn(f) |

176 | } |

177 | |

178 | #[derive(Debug, Copy, Clone, Default)] |

179 | pub struct MapOkFn<F>(F); |

180 | |

181 | impl<F, T, E> FnOnce1<Result<T, E>> for MapOkFn<F> |

182 | where |

183 | F: FnOnce1<T>, |

184 | { |

185 | type Output = Result<F::Output, E>; |

186 | fn call_once(self, arg: Result<T, E>) -> Self::Output { |

187 | arg.map(|x| self.0.call_once(x)) |

188 | } |

189 | } |

190 | impl<F, T, E> FnMut1<Result<T, E>> for MapOkFn<F> |

191 | where |

192 | F: FnMut1<T>, |

193 | { |

194 | fn call_mut(&mut self, arg: Result<T, E>) -> Self::Output { |

195 | arg.map(|x| self.0.call_mut(x)) |

196 | } |

197 | } |

198 | impl<F, T, E> Fn1<Result<T, E>> for MapOkFn<F> |

199 | where |

200 | F: Fn1<T>, |

201 | { |

202 | fn call(&self, arg: Result<T, E>) -> Self::Output { |

203 | arg.map(|x| self.0.call(x)) |

204 | } |

205 | } |

206 | pub(crate) fn map_ok_fn<F>(f: F) -> MapOkFn<F> { |

207 | MapOkFn(f) |

208 | } |

209 | |

210 | #[derive(Debug, Copy, Clone, Default)] |

211 | pub struct MapErrFn<F>(F); |

212 | |

213 | impl<F, T, E> FnOnce1<Result<T, E>> for MapErrFn<F> |

214 | where |

215 | F: FnOnce1<E>, |

216 | { |

217 | type Output = Result<T, F::Output>; |

218 | fn call_once(self, arg: Result<T, E>) -> Self::Output { |

219 | arg.map_err(|x| self.0.call_once(x)) |

220 | } |

221 | } |

222 | impl<F, T, E> FnMut1<Result<T, E>> for MapErrFn<F> |

223 | where |

224 | F: FnMut1<E>, |

225 | { |

226 | fn call_mut(&mut self, arg: Result<T, E>) -> Self::Output { |

227 | arg.map_err(|x| self.0.call_mut(x)) |

228 | } |

229 | } |

230 | impl<F, T, E> Fn1<Result<T, E>> for MapErrFn<F> |

231 | where |

232 | F: Fn1<E>, |

233 | { |

234 | fn call(&self, arg: Result<T, E>) -> Self::Output { |

235 | arg.map_err(|x| self.0.call(x)) |

236 | } |

237 | } |

238 | pub(crate) fn map_err_fn<F>(f: F) -> MapErrFn<F> { |

239 | MapErrFn(f) |

240 | } |

241 | |

242 | #[derive(Debug, Copy, Clone)] |

243 | pub struct InspectOkFn<F>(F); |

244 | |

245 | impl<'a, F, T, E> FnOnce1<&'a Result<T, E>> for InspectOkFn<F> |

246 | where |

247 | F: FnOnce1<&'a T, Output = ()>, |

248 | { |

249 | type Output = (); |

250 | fn call_once(self, arg: &'a Result<T, E>) -> Self::Output { |

251 | if let Ok(x) = arg { |

252 | self.0.call_once(x) |

253 | } |

254 | } |

255 | } |

256 | impl<'a, F, T, E> FnMut1<&'a Result<T, E>> for InspectOkFn<F> |

257 | where |

258 | F: FnMut1<&'a T, Output = ()>, |

259 | { |

260 | fn call_mut(&mut self, arg: &'a Result<T, E>) -> Self::Output { |

261 | if let Ok(x) = arg { |

262 | self.0.call_mut(x) |

263 | } |

264 | } |

265 | } |

266 | impl<'a, F, T, E> Fn1<&'a Result<T, E>> for InspectOkFn<F> |

267 | where |

268 | F: Fn1<&'a T, Output = ()>, |

269 | { |

270 | fn call(&self, arg: &'a Result<T, E>) -> Self::Output { |

271 | if let Ok(x) = arg { |

272 | self.0.call(x) |

273 | } |

274 | } |

275 | } |

276 | pub(crate) fn inspect_ok_fn<F>(f: F) -> InspectOkFn<F> { |

277 | InspectOkFn(f) |

278 | } |

279 | |

280 | #[derive(Debug, Copy, Clone)] |

281 | pub struct InspectErrFn<F>(F); |

282 | |

283 | impl<'a, F, T, E> FnOnce1<&'a Result<T, E>> for InspectErrFn<F> |

284 | where |

285 | F: FnOnce1<&'a E, Output = ()>, |

286 | { |

287 | type Output = (); |

288 | fn call_once(self, arg: &'a Result<T, E>) -> Self::Output { |

289 | if let Err(x) = arg { |

290 | self.0.call_once(x) |

291 | } |

292 | } |

293 | } |

294 | impl<'a, F, T, E> FnMut1<&'a Result<T, E>> for InspectErrFn<F> |

295 | where |

296 | F: FnMut1<&'a E, Output = ()>, |

297 | { |

298 | fn call_mut(&mut self, arg: &'a Result<T, E>) -> Self::Output { |

299 | if let Err(x) = arg { |

300 | self.0.call_mut(x) |

301 | } |

302 | } |

303 | } |

304 | impl<'a, F, T, E> Fn1<&'a Result<T, E>> for InspectErrFn<F> |

305 | where |

306 | F: Fn1<&'a E, Output = ()>, |

307 | { |

308 | fn call(&self, arg: &'a Result<T, E>) -> Self::Output { |

309 | if let Err(x) = arg { |

310 | self.0.call(x) |

311 | } |

312 | } |

313 | } |

314 | pub(crate) fn inspect_err_fn<F>(f: F) -> InspectErrFn<F> { |

315 | InspectErrFn(f) |

316 | } |

317 | |

318 | pub(crate) type MapOkOrElseFn<F, G> = ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>; |

319 | pub(crate) fn map_ok_or_else_fn<F, G>(f: F, g: G) -> MapOkOrElseFn<F, G> { |

320 | chain_fn(map_ok_fn(f), chain_fn(map_err_fn(g), merge_result_fn())) |

321 | } |

322 | |

323 | #[derive(Debug, Copy, Clone, Default)] |

324 | pub struct UnwrapOrElseFn<F>(F); |

325 | |

326 | impl<F, T, E> FnOnce1<Result<T, E>> for UnwrapOrElseFn<F> |

327 | where |

328 | F: FnOnce1<E, Output = T>, |

329 | { |

330 | type Output = T; |

331 | fn call_once(self, arg: Result<T, E>) -> Self::Output { |

332 | arg.unwrap_or_else(|x| self.0.call_once(x)) |

333 | } |

334 | } |

335 | impl<F, T, E> FnMut1<Result<T, E>> for UnwrapOrElseFn<F> |

336 | where |

337 | F: FnMut1<E, Output = T>, |

338 | { |

339 | fn call_mut(&mut self, arg: Result<T, E>) -> Self::Output { |

340 | arg.unwrap_or_else(|x| self.0.call_mut(x)) |

341 | } |

342 | } |

343 | impl<F, T, E> Fn1<Result<T, E>> for UnwrapOrElseFn<F> |

344 | where |

345 | F: Fn1<E, Output = T>, |

346 | { |

347 | fn call(&self, arg: Result<T, E>) -> Self::Output { |

348 | arg.unwrap_or_else(|x| self.0.call(x)) |

349 | } |

350 | } |

351 | pub(crate) fn unwrap_or_else_fn<F>(f: F) -> UnwrapOrElseFn<F> { |

352 | UnwrapOrElseFn(f) |

353 | } |

354 | |

355 | pub struct IntoFn<T>(PhantomData<fn() -> T>); |

356 | |

357 | impl<T> Default for IntoFn<T> { |

358 | fn default() -> Self { |

359 | Self(PhantomData) |

360 | } |

361 | } |

362 | impl<A, T> FnOnce1<A> for IntoFn<T> |

363 | where |

364 | A: Into<T>, |

365 | { |

366 | type Output = T; |

367 | fn call_once(self, arg: A) -> Self::Output { |

368 | arg.into() |

369 | } |

370 | } |

371 | |

372 | trivial_fn_impls!(into_fn <T> IntoFn<T> = "Into::into"); |

373 |