From 3fca916d04a87c3ab985798fd70383cc6e973612 Mon Sep 17 00:00:00 2001
From: Cecile Tonglet <cecile.tonglet@cecton.com>
Date: Thu, 9 Nov 2023 11:05:26 +0100
Subject: [PATCH 1/2] Add method implicit_clone() to help ensure the type is
 ImplicitClone

---
 src/lib.rs | 31 ++++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
index 6f397de..c05c929 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -55,7 +55,36 @@ pub mod unsync;
 ///
 /// Enables host libraries to have the same syntax as [`Copy`] while calling the [`Clone`]
 /// implementation instead.
-pub trait ImplicitClone: Clone {}
+pub trait ImplicitClone: Clone {
+    /// This function is not magic; it is literally defined as
+    ///
+    /// ```ignore
+    /// fn implicit_clone(&self) -> Self {
+    ///     self.clone()
+    /// }
+    /// ```
+    ///
+    /// It is useful when you want to clone but also ensure that the type implements
+    /// [`ImplicitClone`].
+    ///
+    /// Examples:
+    ///
+    /// ```
+    /// use implicit_clone::ImplicitClone;
+    /// let x: u32 = Default::default();
+    /// let clone = ImplicitClone::implicit_clone(&x);
+    /// ```
+    ///
+    /// ```compile_fail
+    /// use implicit_clone::ImplicitClone;
+    /// let x: Vec<u32> = Default::default();
+    /// // does not compile because Vec<_> does not implement ImplicitClone
+    /// let clone = ImplicitClone::implicit_clone(&x);
+    /// ```
+    fn implicit_clone(&self) -> Self {
+        self.clone()
+    }
+}
 
 impl<T: ?Sized> ImplicitClone for &T {}
 

From 8edf3a780566fce726d763725f853f9e02eacb2e Mon Sep 17 00:00:00 2001
From: Cecile Tonglet <cecile.tonglet@cecton.com>
Date: Thu, 9 Nov 2023 11:08:14 +0100
Subject: [PATCH 2/2] Adding #[inline] just like std::mem:copy(), probably help
 the compiler

---
 src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/lib.rs b/src/lib.rs
index c05c929..3bba0ff 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -81,6 +81,7 @@ pub trait ImplicitClone: Clone {
     /// // does not compile because Vec<_> does not implement ImplicitClone
     /// let clone = ImplicitClone::implicit_clone(&x);
     /// ```
+    #[inline]
     fn implicit_clone(&self) -> Self {
         self.clone()
     }