Crate derive_more [−] [src]
derive_more
Rust has lots of builtin traits that are implemented for its basic types, such as Add
,
Not
or From
.
However, when wrapping these types inside your own structs or enums you lose the
implementations of these traits and are required to recreate them.
This is especially annoying when your own structures are very simple, such as when using the
commonly advised newtype pattern (e.g. MyInt(i32)
).
This library tries to remove these annoyances and the corresponding boilerplate code. It does this by allowing you to derive lots of commonly used traits for both structs and enums.
Example code
By using this library the following code just works:
#[derive(Debug, Eq, PartialEq, From, Add)] struct MyInt(i32); #[derive(Debug, Eq, PartialEq, From, Into, Constructor, Mul)] struct Point2D { x: i32, y: i32, } #[derive(Debug, Eq, PartialEq, From, Add)] enum MyEnum { Int(i32), UnsignedInt(u32), Nothing, } fn main() { let my_11 = MyInt(5) + 6.into(); assert_eq!(MyInt(11), MyInt(5) + 6.into()); assert_eq!(Point2D { x: 5, y: 6 } * 10, (50, 60).into()); assert_eq!((5, 6), Point2D { x: 5, y: 6 }.into()); assert_eq!(Point2D { x: 5, y: 6 }, Point2D::new(5, 6)); assert_eq!(MyEnum::Int(15), (MyEnum::Int(8) + 7.into()).unwrap()) }
The newly derivable traits
Obviously not all traits should be derived to the same code, because they are different traits after all. However, some of the semantics of the traits overlap a lot, so they have been grouped in the following way:
From
, only containsFrom
.Into
, only containsInto
.Constructor
, this doesn't derive a trait, but it derives anew
method that can be used as a constructor.Not
-like, containsNot
andNeg
.Add
-like, containsAdd
,Sub
,BitAnd
,BitOr
andBitXor
.AddAssign
-like, containsAddAssign
,SubAssign
,BitAndAssign
,BitOrAssign
andBitXorAssign
.Mul
-like, containsMul
,Div
,Rem
,Shr
andShl
.MulAssign
-like, containsMulAssign
,DivAssign
,RemAssign
,ShrAssign
andShlAssign
.
Generated code
It is important to understand what code gets generated when using one of the derives from this crate. That is why the links below explain what code gets generated for a trait for each group from before.
#[derive(From)]
#[derive(Into)]
#[derive(Constructor)]
#[derive(Not)]
#[derive(Add)]
#[derive(AddAssign)]
#[derive(Mul)]
#[derive(MulAssign)]
If you want to be sure what code is generated for your specific type I recommend using the
cargo-expand
utility.
This will show you your code with all macros and derives expanded.
Installation
This library requires Rust 1.15 or higher, so this needs to be installed.
Then add the following to Cargo.toml
:
[dependencies]
derive_more = "0.6.0"
And this to the top of your Rust file:
#[macro_use] extern crate derive_more;