Swap macro re-export modules (#405)

CHANGELOG.md

@@ -5,7 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
-## 1.0.1 - Unreleased
+
+## 2.0.0 - Unreleased
+
+### Breaking changes
+
+- `use derive_more::SomeTrait` now imports macro only. Importing macro with
+  its trait along is possible now via `use derive_more::with_trait::SomeTrait`.
+  ([#406](https://github.com/JelteF/derive_more/pull/406))
 
 ### Fixed
 

README.md

@@ -139,17 +139,17 @@ These don't derive traits, but derive static methods instead.
 
 ### Re-exports
 
-This crate also re-exports all the standard library traits that it adds derives
-for. So, both the `Display` derive and the `Display` trait will be in scope when
-you add the following code:
+This crate also re-exports all the standard library traits, that it adds derives
+for, in the `with_trait` module. So, both the `Display` derive and the `Display`
+trait will be in scope when you add the following code:
 ```rust
-use derive_more::Display; // also imports `core::fmt::Display`
+use derive_more::with_trait::Display; // also imports `core::fmt::Display`
 ```
 
-For derive macros only, without the corresponding traits, do import them from
-the `derive` module:
+By default, derive macros only, without the corresponding traits, are import from
+the crate's root:
 ```rust
-use derive_more::derive::Display; // imports macro only
+use derive_more::Display; // imports macro only
 ```
 
 #### Hygiene

impl/doc/add.md

@@ -26,7 +26,7 @@ Code like this will be generated:
 
 ```rust
 # struct MyInts(i32, i32);
-impl derive_more::Add for MyInts {
+impl derive_more::core::ops::Add for MyInts {
     type Output = MyInts;
     fn add(self, rhs: MyInts) -> MyInts {
         MyInts(self.0.add(rhs.0), self.1.add(rhs.1))
@@ -60,7 +60,7 @@ Code like this will be generated:
 #     x: i32,
 #     y: i32,
 # }
-impl derive_more::Add for Point2D {
+impl derive_more::core::ops::Add for Point2D {
     type Output = Point2D;
     fn add(self, rhs: Point2D) -> Point2D {
         Point2D {
@@ -112,7 +112,7 @@ Code like this will be generated:
 #     UnsignedTwo(u32),
 #     Unit,
 # }
-impl derive_more::Add for MixedInts {
+impl derive_more::core::ops::Add for MixedInts {
     type Output = Result<MixedInts, derive_more::BinaryError>;
     fn add(self, rhs: MixedInts) -> Result<MixedInts, derive_more::BinaryError> {
         match (self, rhs) {

impl/doc/add_assign.md

@@ -22,7 +22,7 @@ Code like this will be generated:
 
 ```rust
 # struct MyInts(i32, i32);
-impl derive_more::AddAssign for MyInts {
+impl derive_more::core::ops::AddAssign for MyInts {
     fn add_assign(&mut self, rhs: MyInts) {
         self.0.add_assign(rhs.0);
         self.1.add_assign(rhs.1);
@@ -56,7 +56,7 @@ Code like this will be generated:
 #     x: i32,
 #     y: i32,
 # }
-impl derive_more::AddAssign for Point2D {
+impl derive_more::core::ops::AddAssign for Point2D {
     fn add_assign(&mut self, rhs: Point2D) {
         self.x.add_assign(rhs.x);
         self.y.add_assign(rhs.y);

impl/doc/as_mut.md

@@ -24,7 +24,7 @@ Generates:
 
 ```rust
 # struct MyWrapper(String);
-impl derive_more::AsMut<String> for MyWrapper {
+impl AsMut<String> for MyWrapper {
     fn as_mut(&mut self) -> &mut String {
         &mut self.0
     }
@@ -50,9 +50,9 @@ This generates code equivalent to:
 
 ```rust
 # struct SingleFieldForward(Vec<i32>);
-impl<T: ?Sized> derive_more::AsMut<T> for SingleFieldForward
+impl<T: ?Sized> AsMut<T> for SingleFieldForward
 where
-    Vec<i32>: derive_more::AsMut<T>,
+    Vec<i32>: AsMut<T>,
 {
     #[inline]
     fn as_mut(&mut self) -> &mut T {

impl/doc/as_ref.md

@@ -24,7 +24,7 @@ Generates:
 
 ```rust
 # struct MyWrapper(String);
-impl derive_more::AsRef<String> for MyWrapper {
+impl AsRef<String> for MyWrapper {
     fn as_ref(&self) -> &String {
         &self.0
     }
@@ -50,9 +50,9 @@ This generates code equivalent to:
 
 ```rust
 # struct SingleFieldForward(Vec<i32>);
-impl<T: ?Sized> derive_more::AsRef<T> for SingleFieldForward
+impl<T: ?Sized> AsRef<T> for SingleFieldForward
 where
-    Vec<i32>: derive_more::AsRef<T>,
+    Vec<i32>: AsRef<T>,
 {
     #[inline]
     fn as_ref(&self) -> &T {

impl/doc/deref.md

@@ -67,7 +67,7 @@ Code like this will be generated:
 #     cool: bool,
 #     vec: Vec<i32>,
 # }
-impl derive_more::Deref for CoolVec {
+impl derive_more::core::ops::Deref for CoolVec {
     type Target = Vec<i32>;
     #[inline]
     fn deref(&self) -> &Self::Target {
@@ -90,11 +90,11 @@ Code like this will be generated:
 
 ```rust
 # struct MyBoxedInt(Box<i32>);
-impl derive_more::Deref for MyBoxedInt {
-    type Target = <Box<i32> as derive_more::Deref>::Target;
+impl derive_more::core::ops::Deref for MyBoxedInt {
+    type Target = <Box<i32> as derive_more::core::ops::Deref>::Target;
     #[inline]
     fn deref(&self) -> &Self::Target {
-        <Box<i32> as derive_more::Deref>::deref(&self.0)
+        <Box<i32> as derive_more::core::ops::Deref>::deref(&self.0)
     }
 }
 ```

impl/doc/deref_mut.md

@@ -85,7 +85,7 @@ Code like this will be generated:
 #         &self.vec
 #     }
 # }
-impl derive_more::DerefMut for CoolVec {
+impl derive_more::core::ops::DerefMut for CoolVec {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.vec
@@ -116,10 +116,10 @@ When deriving a forwarded `DerefMut` for a struct:
 #         <Box<i32> as Deref>::deref(&self.0)
 #     }
 # }
-impl derive_more::DerefMut for MyBoxedInt {
+impl derive_more::core::ops::DerefMut for MyBoxedInt {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
-        <Box<i32> as derive_more::DerefMut>::deref_mut(&mut self.0)
+        <Box<i32> as derive_more::core::ops::DerefMut>::deref_mut(&mut self.0)
     }
 }
 ```

impl/doc/display.md

@@ -33,7 +33,7 @@ once to get the address of the field itself, instead of the address of the
 reference to the field:
 
 ```rust
-# use derive_more::Display;
+# use derive_more::with_trait::Display;
 #
 #[derive(Display)]
 #[display("{field:p} {:p}", *field)]
@@ -107,7 +107,7 @@ Explicitly specified bounds are added to the inferred ones. Note how no `V: Disp
 because it's inferred already.
 
 ```rust
-# use derive_more::Display;
+# use derive_more::with_trait::Display;
 #
 # trait MyTrait { fn my_function(&self) -> i32; }
 #

impl/doc/from_str.md

@@ -44,8 +44,8 @@ Code like this will be generated:
 
 ```rust
 # struct MyInt(i32);
-impl derive_more::FromStr for MyInt {
-    type Err = <i32 as derive_more::FromStr>::Err;
+impl derive_more::core::str::FromStr for MyInt {
+    type Err = <i32 as derive_more::core::str::FromStr>::Err;
     fn from_str(src: &str) -> Result<Self, Self::Err> {
         return Ok(MyInt(i32::from_str(src)?));
     }
@@ -74,8 +74,8 @@ Code like this will be generated:
 # struct Point1D {
 #     x: i32,
 # }
-impl derive_more::FromStr for Point1D {
-    type Err = <i32 as derive_more::FromStr>::Err;
+impl derive_more::core::str::FromStr for Point1D {
+    type Err = <i32 as derive_more::core::str::FromStr>::Err;
     fn from_str(src: &str) -> Result<Self, Self::Err> {
         return Ok(Point1D {
             x: i32::from_str(src)?,
@@ -121,7 +121,7 @@ Code like this will be generated:
 #     Baz,
 # }
 #
-impl derive_more::FromStr for EnumNoFields {
+impl derive_more::core::str::FromStr for EnumNoFields {
     type Err = derive_more::FromStrError;
     fn from_str(src: &str) -> Result<Self, Self::Err> {
         Ok(match src.to_lowercase().as_str() {

impl/doc/index.md

@@ -54,14 +54,14 @@ Code like this will be generated:
 #     numbers: Vec<i32>,
 #     useless: bool,
 # }
-impl<__IdxT> derive_more::Index<__IdxT> for Numbers
+impl<__IdxT> derive_more::core::ops::Index<__IdxT> for Numbers
 where
-    Vec<i32>: derive_more::Index<__IdxT>,
+    Vec<i32>: derive_more::core::ops::Index<__IdxT>,
 {
-    type Output = <Vec<i32> as derive_more::Index<__IdxT>>::Output;
+    type Output = <Vec<i32> as derive_more::core::ops::Index<__IdxT>>::Output;
     #[inline]
     fn index(&self, idx: __IdxT) -> &Self::Output {
-        <Vec<i32> as derive_more::Index<__IdxT>>::index(&self.numbers, idx)
+        <Vec<i32> as derive_more::core::ops::Index<__IdxT>>::index(&self.numbers, idx)
     }
 }
 ```

impl/doc/index_mut.md

@@ -73,13 +73,13 @@ Code like this will be generated to implement `IndexMut`:
 #         <Vec<i32> as Index<__IdxT>>::index(&self.numbers, idx)
 #     }
 # }
-impl<__IdxT> derive_more::IndexMut<__IdxT> for Numbers
+impl<__IdxT> derive_more::core::ops::IndexMut<__IdxT> for Numbers
 where
-    Vec<i32>: derive_more::IndexMut<__IdxT>,
+    Vec<i32>: derive_more::core::ops::IndexMut<__IdxT>,
 {
     #[inline]
     fn index_mut(&mut self, idx: __IdxT) -> &mut Self::Output {
-        <Vec<i32> as derive_more::IndexMut<__IdxT>>::index_mut(&mut self.numbers, idx)
+        <Vec<i32> as derive_more::core::ops::IndexMut<__IdxT>>::index_mut(&mut self.numbers, idx)
     }
 }
 ```

impl/doc/into_iterator.md

@@ -32,7 +32,7 @@ struct Numbers {
 
 assert_eq!(Some(5), MyVec(vec![5, 8]).into_iter().next());
 
-let mut nums = Numbers{numbers: vec![100, 200], useless: false};
+let mut nums = Numbers { numbers: vec![100, 200], useless: false };
 assert_eq!(Some(&100), (&nums).into_iter().next());
 assert_eq!(Some(&mut 100), (&mut nums).into_iter().next());
 assert_eq!(Some(100), nums.into_iter().next());
@@ -63,30 +63,30 @@ Code like this will be generated:
 #     numbers: Vec<i32>,
 #     useless: bool,
 # }
-impl derive_more::IntoIterator for Numbers {
-    type Item = <Vec<i32> as derive_more::IntoIterator>::Item;
-    type IntoIter = <Vec<i32> as derive_more::IntoIterator>::IntoIter;
+impl IntoIterator for Numbers {
+    type Item = <Vec<i32> as IntoIterator>::Item;
+    type IntoIter = <Vec<i32> as IntoIterator>::IntoIter;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
-        <Vec<i32> as derive_more::IntoIterator>::into_iter(self.numbers)
+        <Vec<i32> as IntoIterator>::into_iter(self.numbers)
     }
 }
 
-impl<'__deriveMoreLifetime> derive_more::IntoIterator for &'__deriveMoreLifetime Numbers {
-    type Item = <&'__deriveMoreLifetime Vec<i32> as derive_more::IntoIterator>::Item;
-    type IntoIter = <&'__deriveMoreLifetime Vec<i32> as derive_more::IntoIterator>::IntoIter;
+impl<'__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime Numbers {
+    type Item = <&'__deriveMoreLifetime Vec<i32> as IntoIterator>::Item;
+    type IntoIter = <&'__deriveMoreLifetime Vec<i32> as IntoIterator>::IntoIter;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
-        <&'__deriveMoreLifetime Vec<i32> as derive_more::IntoIterator>::into_iter(&self.numbers)
+        <&'__deriveMoreLifetime Vec<i32> as IntoIterator>::into_iter(&self.numbers)
     }
 }
 
-impl<'__deriveMoreLifetime> derive_more::IntoIterator for &'__deriveMoreLifetime mut Numbers {
-    type Item = <&'__deriveMoreLifetime mut Vec<i32> as derive_more::IntoIterator>::Item;
-    type IntoIter = <&'__deriveMoreLifetime mut Vec<i32> as derive_more::IntoIterator>::IntoIter;
+impl<'__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime mut Numbers {
+    type Item = <&'__deriveMoreLifetime mut Vec<i32> as IntoIterator>::Item;
+    type IntoIter = <&'__deriveMoreLifetime mut Vec<i32> as IntoIterator>::IntoIter;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
-        <&'__deriveMoreLifetime mut Vec<i32> as derive_more::IntoIterator>::into_iter(
+        <&'__deriveMoreLifetime mut Vec<i32> as IntoIterator>::into_iter(
             &mut self.numbers,
         )
     }

impl/doc/mul.md

@@ -35,8 +35,8 @@ Code like this will be generated:
 
 ```rust
 # struct MyInt(i32);
-impl<__RhsT> derive_more::Mul<__RhsT> for MyInt
-    where i32: derive_more::Mul<__RhsT, Output = i32>
+impl<__RhsT> derive_more::core::ops::Mul<__RhsT> for MyInt
+    where i32: derive_more::core::ops::Mul<__RhsT, Output = i32>
 {
     type Output = MyInt;
     fn mul(self, rhs: __RhsT) -> MyInt {
@@ -60,8 +60,8 @@ Code like this will be generated:
 
 ```rust
 # struct MyInts(i32, i32);
-impl<__RhsT: Copy> derive_more::Mul<__RhsT> for MyInts
-    where i32: derive_more::Mul<__RhsT, Output = i32>
+impl<__RhsT: Copy> derive_more::core::ops::Mul<__RhsT> for MyInts
+    where i32: derive_more::core::ops::Mul<__RhsT, Output = i32>
 {
     type Output = MyInts;
     fn mul(self, rhs: __RhsT) -> MyInts {
@@ -94,8 +94,8 @@ Code like this will be generated:
 # struct Point1D {
 #     x: i32,
 # }
-impl<__RhsT> derive_more::Mul<__RhsT> for Point1D
-    where i32: derive_more::Mul<__RhsT, Output = i32>
+impl<__RhsT> derive_more::core::ops::Mul<__RhsT> for Point1D
+    where i32: derive_more::core::ops::Mul<__RhsT, Output = i32>
 {
     type Output = Point1D;
     fn mul(self, rhs: __RhsT) -> Point1D {
@@ -125,8 +125,8 @@ Code like this will be generated:
 #     x: i32,
 #     y: i32,
 # }
-impl<__RhsT: Copy> derive_more::Mul<__RhsT> for Point2D
-    where i32: derive_more::Mul<__RhsT, Output = i32>
+impl<__RhsT: Copy> derive_more::core::ops::Mul<__RhsT> for Point2D
+    where i32: derive_more::core::ops::Mul<__RhsT, Output = i32>
 {
     type Output = Point2D;
     fn mul(self, rhs: __RhsT) -> Point2D {

impl/doc/mul_assign.md

@@ -27,8 +27,8 @@ Code like this will be generated:
 
 ```rust
 # struct MyInts(i32, i32);
-impl<__RhsT: Copy> derive_more::MulAssign<__RhsT> for MyInts
-    where i32: derive_more::MulAssign<__RhsT>
+impl<__RhsT: Copy> derive_more::core::ops::MulAssign<__RhsT> for MyInts
+    where i32: derive_more::core::ops::MulAssign<__RhsT>
 {
     fn mul_assign(&mut self, rhs: __RhsT) {
         self.0.mul_assign(rhs);
@@ -64,8 +64,8 @@ Code like this will be generated:
 #     x: i32,
 #     y: i32,
 # }
-impl<__RhsT: Copy> derive_more::MulAssign<__RhsT> for Point2D
-    where i32: derive_more::MulAssign<__RhsT>
+impl<__RhsT: Copy> derive_more::core::ops::MulAssign<__RhsT> for Point2D
+    where i32: derive_more::core::ops::MulAssign<__RhsT>
 {
     fn mul_assign(&mut self, rhs: __RhsT) {
         self.x.mul_assign(rhs);