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

#![no_std]

//! An escape hatch for implementing `ops` traits for references to newtypes.
//!
//! As of Rust 1.65.0, the following code does not compile:
//! ```compile_fail
//! use core::ops::Neg;
//!
//! struct A<T>(T);
//!
//! impl<'a, T, O> Neg for &'a A<T>
//! where
//!     &'a T: Neg<Output = O>,
//! {
//!     type Output = A<O>;
//!
//!     fn neg(self) -> Self::Output {
//!         A(-&self.0)
//!     }
//! }
//!
//! fn f<T>(a: T)
//! where
//!     for<'a> &'a T: Neg,
//! {
//!     let minus_a = -&a;
//!
//!     // to do something with `a` and `minus_a`
//! }
//!
//! fn g<T>(a: T)
//! where
//!     for<'a> &'a T: Neg,
//! {
//!     f(a);
//! }
//! ```
//! but the following code does:
//! ```
//! use core::ops::Neg;
//! use ref_ops::RefNeg;
//!
//! struct A<T>(T);
//!
//! impl<T> Neg for &A<T>
//! where
//!     T: RefNeg,
//! {
//!     type Output = A<T::Output>;
//!
//!     fn neg(self) -> Self::Output {
//!         A(self.0.ref_neg())
//!     }
//! }
//!
//! fn f<T>(a: T)
//! where
//!     for<'a> &'a T: Neg,
//! {
//!     let minus_a = -&a;
//!
//!     // to do something with `a` and `minus_a`
//! }
//!
//! fn g<T>(a: T)
//! where
//!     for<'a> &'a T: Neg,
//! {
//!     f(a);
//! }
//! ```

mod ref_unary;
pub use ref_unary::*;

mod ref_mut_unary;
pub use ref_mut_unary::*;

mod ref_binary;
pub use ref_binary::*;

mod ref_mut_binary;
pub use ref_mut_binary::*;