dupe/
lib.rs

1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
3 *
4 * This source code is licensed under both the MIT license found in the
5 * LICENSE-MIT file in the root directory of this source tree and the Apache
6 * License, Version 2.0 found in the LICENSE-APACHE file in the root directory
7 * of this source tree.
8 */
9
10//! A cheap version of [`Clone`].
11
12pub mod __macro_refs;
13pub(crate) mod iter;
14pub(crate) mod option;
15
16use std::cell::Cell;
17use std::mem::ManuallyDrop;
18use std::num::*;
19use std::rc::Rc;
20use std::sync::Arc;
21
22pub use dupe_derive::Clone_;
23pub use dupe_derive::Copy_;
24pub use dupe_derive::Dupe;
25pub use dupe_derive::Dupe_;
26
27pub use crate::iter::IterDupedExt;
28pub use crate::option::OptionDupedExt;
29
30/// Like [`Clone`], but should only be available if [`Clone`] is
31/// constant time and zero allocation (e.g. a few [`Arc`] bumps).
32/// The implementation of `dupe` should _always_ call `clone`.
33pub trait Dupe: Clone {
34    #[inline]
35    fn dupe(&self) -> Self {
36        self.clone()
37    }
38}
39
40// Smart pointer/wrapper types
41impl<A: ?Sized> Dupe for &A {}
42impl<A: ?Sized> Dupe for *const A {}
43impl<A: ?Sized> Dupe for *mut A {}
44impl<A: ?Sized> Dupe for Arc<A> {}
45impl<A: ?Sized> Dupe for std::sync::Weak<A> {}
46impl<A: ?Sized> Dupe for Rc<A> {}
47impl<A: ?Sized> Dupe for std::rc::Weak<A> {}
48impl<A: Copy> Dupe for Cell<A> {}
49impl<A: Dupe> Dupe for ManuallyDrop<A> {}
50
51// Small containers
52impl<A: Dupe> Dupe for Option<A> {}
53impl<T: Dupe, E: Dupe> Dupe for Result<T, E> {}
54impl<A: Dupe> Dupe for std::ops::Bound<A> {}
55impl<A: Dupe> Dupe for std::pin::Pin<A> {}
56impl<A: Dupe> Dupe for std::ptr::NonNull<A> {}
57impl<A: Dupe> Dupe for std::task::Poll<A> {}
58impl Dupe for () {}
59impl<A: Dupe> Dupe for (A,) {}
60impl<A: Dupe, B: Dupe> Dupe for (A, B) {}
61impl<A: Dupe, B: Dupe, C: Dupe> Dupe for (A, B, C) {}
62impl<A: Dupe, B: Dupe, C: Dupe, D: Dupe> Dupe for (A, B, C, D) {}
63impl<A: Dupe, B: Dupe, C: Dupe, D: Dupe, E: Dupe> Dupe for (A, B, C, D, E) {}
64impl<A: Dupe, B: Dupe, C: Dupe, D: Dupe, E: Dupe, F: Dupe> Dupe for (A, B, C, D, E, F) {}
65impl<A: Dupe, B: Dupe, C: Dupe, D: Dupe, E: Dupe, F: Dupe, G: Dupe> Dupe for (A, B, C, D, E, F, G) {}
66impl<A: Dupe, B: Dupe, C: Dupe, D: Dupe, E: Dupe, F: Dupe, G: Dupe, H: Dupe> Dupe
67    for (A, B, C, D, E, F, G, H)
68{
69}
70impl<A: Dupe, B: Dupe, C: Dupe, D: Dupe, E: Dupe, F: Dupe, G: Dupe, H: Dupe, I: Dupe> Dupe
71    for (A, B, C, D, E, F, G, H, I)
72{
73}
74impl<A: Dupe, B: Dupe, C: Dupe, D: Dupe, E: Dupe, F: Dupe, G: Dupe, H: Dupe, I: Dupe, J: Dupe> Dupe
75    for (A, B, C, D, E, F, G, H, I, J)
76{
77}
78
79impl<A: Dupe, const N: usize> Dupe for [A; N] {}
80
81// Atomic types
82impl Dupe for bool {}
83impl Dupe for char {}
84impl Dupe for u8 {}
85impl Dupe for u16 {}
86impl Dupe for u32 {}
87impl Dupe for u64 {}
88impl Dupe for u128 {}
89impl Dupe for usize {}
90impl Dupe for i8 {}
91impl Dupe for i16 {}
92impl Dupe for i32 {}
93impl Dupe for i64 {}
94impl Dupe for i128 {}
95impl Dupe for isize {}
96impl Dupe for f32 {}
97impl Dupe for f64 {}
98impl Dupe for NonZeroU8 {}
99impl Dupe for NonZeroU16 {}
100impl Dupe for NonZeroU32 {}
101impl Dupe for NonZeroU64 {}
102impl Dupe for NonZeroU128 {}
103impl Dupe for NonZeroUsize {}
104impl Dupe for NonZeroI8 {}
105impl Dupe for NonZeroI16 {}
106impl Dupe for NonZeroI32 {}
107impl Dupe for NonZeroI64 {}
108impl Dupe for NonZeroI128 {}
109impl Dupe for NonZeroIsize {}
110
111// Other std types that are Copyable
112impl Dupe for std::any::TypeId {}
113impl Dupe for std::marker::PhantomPinned {}
114impl Dupe for std::net::Ipv4Addr {}
115impl Dupe for std::net::Ipv6Addr {}
116impl Dupe for std::net::SocketAddrV4 {}
117impl Dupe for std::net::SocketAddrV6 {}
118impl Dupe for std::thread::ThreadId {}
119impl Dupe for std::time::Instant {}
120impl Dupe for std::time::SystemTime {}
121impl Dupe for std::time::Duration {}
122impl<T: ?Sized> Dupe for std::marker::PhantomData<T> {}
123
124impl<R> Dupe for fn() -> R {}
125impl<A1, R> Dupe for fn(A1) -> R {}
126impl<A1, A2, R> Dupe for fn(A1, A2) -> R {}
127impl<A1, A2, A3, R> Dupe for fn(A1, A2, A3) -> R {}
128impl<A1, A2, A3, A4, R> Dupe for fn(A1, A2, A3, A4) -> R {}
129impl<A1, A2, A3, A4, A5, R> Dupe for fn(A1, A2, A3, A4, A5) -> R {}
130impl<A1, A2, A3, A4, A5, A6, R> Dupe for fn(A1, A2, A3, A4, A5, A6) -> R {}
131impl<A1, A2, A3, A4, A5, A6, A7, R> Dupe for fn(A1, A2, A3, A4, A5, A6, A7) -> R {}
132impl<A1, A2, A3, A4, A5, A6, A7, A8, R> Dupe for fn(A1, A2, A3, A4, A5, A6, A7, A8) -> R {}
133impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, R> Dupe for fn(A1, A2, A3, A4, A5, A6, A7, A8, A9) -> R {}
134impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R> Dupe
135    for fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R
136{
137}
138impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R> Dupe
139    for fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> R
140{
141}
142impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R> Dupe
143    for fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> R
144{
145}
146// Rust goes up to 12 arguments for traits, so we follow
147
148#[cfg(test)]
149mod tests {
150    use super::*;
151    #[allow(unused_imports)] // Not actually unused, this makes testing the derive macro work
152    use crate as dupe;
153
154    #[test]
155    fn test_dupe_generic() {
156        #[derive(Clone, Dupe, Debug, PartialEq, Eq)]
157        struct Foo {}
158        #[derive(Clone, Dupe, Debug, PartialEq, Eq)]
159        struct FooT<T> {
160            foo: T,
161        }
162        #[derive(Clone, Dupe, Debug, PartialEq, Eq)]
163        struct Faz;
164
165        let x = Foo {};
166        assert_eq!(x, Dupe::dupe(&x));
167
168        let x = FooT { foo: 1 };
169        assert_eq!(x, Dupe::dupe(&x));
170
171        let x = Faz;
172        assert_eq!(x, Dupe::dupe(&x));
173    }
174
175    #[test]
176    fn test_dupe_() {
177        #[derive(Debug, PartialEq, Eq)]
178        struct NoClone();
179        #[derive(Dupe_, Debug, PartialEq, Eq)]
180        struct FooT<T> {
181            foo: Arc<T>,
182        }
183
184        impl<T> Clone for FooT<T> {
185            fn clone(&self) -> Self {
186                FooT {
187                    foo: self.foo.clone(),
188                }
189            }
190        }
191
192        let x = FooT {
193            foo: Arc::new(NoClone()),
194        };
195        assert_eq!(x, Dupe::dupe(&x));
196    }
197
198    #[test]
199    fn test_dupe_enum() {
200        #[derive(Clone, Dupe, Debug, PartialEq, Eq)]
201        struct Foo();
202        #[derive(Clone, Dupe, Debug, PartialEq, Eq)]
203        struct Foo2;
204        #[derive(Clone, Dupe, Debug, PartialEq, Eq)]
205        struct Bar(i64, bool, Foo2);
206        #[derive(Clone, Dupe, Debug, PartialEq, Eq)]
207        struct Baz {
208            foo: usize,
209        }
210        #[derive(Clone, Dupe, Debug, PartialEq, Eq)]
211        enum Qux {
212            Foo(),
213            Foo2,
214            Bar(Foo, Bar),
215            Baz { foo: Foo, bar: Bar, baz: Baz },
216        }
217
218        let x = Qux::Bar(Foo(), Bar(8, true, Foo2));
219        assert_eq!(x, Dupe::dupe(&x));
220        let x = Qux::Baz {
221            foo: Foo(),
222            bar: Bar(7, false, Foo2),
223            baz: Baz { foo: 9 },
224        };
225        assert_eq!(x, Dupe::dupe(&x));
226        let x = Qux::Foo();
227        assert_eq!(x, Dupe::dupe(&x));
228        let x = Qux::Foo2;
229        assert_eq!(x, Dupe::dupe(&x));
230    }
231
232    #[test]
233    fn test_dupe_fn()
234    where
235        fn(usize): Dupe,
236        fn(String, Vec<usize>) -> bool: Dupe,
237    {
238        // Tests are in the where
239    }
240}
dupe/lib.rs

dupe/
lib.rs
