diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /third_party/rust/derive_more-impl/doc/add.md | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/derive_more-impl/doc/add.md')
-rw-r--r-- | third_party/rust/derive_more-impl/doc/add.md | 152 |
1 files changed, 152 insertions, 0 deletions
diff --git a/third_party/rust/derive_more-impl/doc/add.md b/third_party/rust/derive_more-impl/doc/add.md new file mode 100644 index 0000000000..5d58996a28 --- /dev/null +++ b/third_party/rust/derive_more-impl/doc/add.md @@ -0,0 +1,152 @@ +# What `#[derive(Add)]` generates + +The derived `Add` implementation will allow two structs from the same type to be +added together. This done by adding their respective fields together and +creating a new struct with those values. +For enums each variant can be added in a similar way to another instance of that +same variant. There's one big difference however, it returns a +`Result<EnumType>`, because an error is returned when to different variants are +added together. + + + + +## Tuple structs + +When deriving `Add` for a tuple struct with two fields like this: + +```rust +# use derive_more::Add; +# +#[derive(Add)] +struct MyInts(i32, i32); +``` + +Code like this will be generated: + +```rust +# struct MyInts(i32, i32); +impl ::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)) + } +} +``` + +The behaviour is similar with more or less fields. + + + + +## Regular structs + +When deriving `Add` for a regular struct with two fields like this: + +```rust +# use derive_more::Add; +# +#[derive(Add)] +struct Point2D { + x: i32, + y: i32, +} +``` + +Code like this will be generated: + +```rust +# struct Point2D { +# x: i32, +# y: i32, +# } +impl ::core::ops::Add for Point2D { + type Output = Point2D; + fn add(self, rhs: Point2D) -> Point2D { + Point2D { + x: self.x.add(rhs.x), + y: self.y.add(rhs.y), + } + } +} +``` + +The behaviour is similar for more or less fields. + + + + +## Enums + +There's a big difference between the code that is generated for the two struct +types and the one that is generated for enums. The code for enums returns +`Result<EnumType>` instead of an `EnumType` itself. This is because adding an +enum to another enum is only possible if both are the same variant. This makes +the generated code much more complex as well, because this check needs to be +done. For instance when deriving `Add` for an enum like this: + +```rust +# use derive_more::Add; +# +#[derive(Add)] +enum MixedInts { + SmallInt(i32), + BigInt(i64), + TwoSmallInts(i32, i32), + NamedSmallInts { x: i32, y: i32 }, + UnsignedOne(u32), + UnsignedTwo(u32), + Unit, +} +``` + +Code like this will be generated: + +```rust +# enum MixedInts { +# SmallInt(i32), +# BigInt(i64), +# TwoSmallInts(i32, i32), +# NamedSmallInts { x: i32, y: i32 }, +# UnsignedOne(u32), +# UnsignedTwo(u32), +# Unit, +# } +impl ::core::ops::Add for MixedInts { + type Output = Result<MixedInts, ::derive_more::ops::BinaryError>; + fn add(self, rhs: MixedInts) -> Result<MixedInts, ::derive_more::ops::BinaryError> { + match (self, rhs) { + (MixedInts::SmallInt(__l_0), MixedInts::SmallInt(__r_0)) => { + Ok(MixedInts::SmallInt(__l_0.add(__r_0))) + } + (MixedInts::BigInt(__l_0), MixedInts::BigInt(__r_0)) => { + Ok(MixedInts::BigInt(__l_0.add(__r_0))) + } + (MixedInts::TwoSmallInts(__l_0, __l_1), MixedInts::TwoSmallInts(__r_0, __r_1)) => { + Ok(MixedInts::TwoSmallInts(__l_0.add(__r_0), __l_1.add(__r_1))) + } + (MixedInts::NamedSmallInts { x: __l_0, y: __l_1 }, + MixedInts::NamedSmallInts { x: __r_0, y: __r_1 }) => { + Ok(MixedInts::NamedSmallInts { + x: __l_0.add(__r_0), + y: __l_1.add(__r_1), + }) + } + (MixedInts::UnsignedOne(__l_0), MixedInts::UnsignedOne(__r_0)) => { + Ok(MixedInts::UnsignedOne(__l_0.add(__r_0))) + } + (MixedInts::UnsignedTwo(__l_0), MixedInts::UnsignedTwo(__r_0)) => { + Ok(MixedInts::UnsignedTwo(__l_0.add(__r_0))) + } + (MixedInts::Unit, MixedInts::Unit) => Err(::derive_more::ops::BinaryError::Unit( + ::derive_more::ops::UnitError::new("add"), + )), + _ => Err(::derive_more::ops::BinaryError::Mismatch( + ::derive_more::ops::WrongVariantError::new("add"), + )), + } + } +} +``` + +Also note the Unit type that throws an error when adding it to itself. |