derive_more

The #[derive(Deref)] macro allows you to automatically implement the std::ops::Deref trait for structs or enums. This is useful for making a type behave like a reference to one of its internal fields.

Constraints:

• For structs: You can only derive Deref for a single field.
• For enums: You can only derive Deref for a single field per variant.

Two modes of operation:

1. Dereferencing to a field: The type acts as if it were a reference type, returning a reference to the specified field.
2. Forwarding dereference: Used when the field itself is a reference type (like Box<T> or &T). The implementation calls the deref method of the field's type.

Use the #[deref] attribute to specify which field to use, and #[deref(forward)] on the container to enable forwarding mode.

use derive_more::Deref;

#[derive(Deref)]
struct Num {
    num: i32,
}

#[derive(Deref)]
#[deref(forward)]
struct MyBoxedInt(Box<i32>);

let num = Num{num: 123};
let boxed = MyBoxedInt(Box::new(123));
assert_eq!(123, *num);
assert_eq!(123, *boxed);

The #[derive(Into)] macro allows you to extract the values contained within a struct. It does not implement the Into trait directly; instead, it derives From for the contained types, providing an indirect implementation of Into as recommended by Rust documentation.

Single-field structs

For structs with one field, calling .into() returns the inner type.

Multi-field structs

For structs with multiple fields, calling .into() returns a tuple containing the values of those fields.

Customizing conversions with #[into(<types>)]

You can use the #[into(<types>)] attribute on a struct to specify concrete types for the conversions. This is useful for mapping fields to specific types like Cow, String, or specific tuple shapes (e.g., (i64, i64) vs (i32, i32)).

Reference conversions

You can derive conversions into references (mutable or immutable) using #[into(ref(...))] or #[into(ref_mut(...))] within the struct attribute.

Skipping fields

To exclude specific fields from the conversion, use the #[into(skip)] or #[into(ignore)] attribute on the field.

#[derive(Debug, Into, PartialEq)]
struct Int(i32);

assert_eq!(2, Int(2).into());

By applying the #[mul(forward)] attribute, you can implement structural multiplication. This behaves like Add: it multiplies corresponding fields of two instances of the same type together.

Structs

For structs, it multiplies each field of the left-hand side by the corresponding field of the right-hand side. Fields can be excluded using #[mul(skip)] or #[mul(ignore)].

Enums

For enums, structural multiplication works variant-to-variant.

• Success: If both instances are the same variant, it multiplies their fields and returns Ok(Self).
• Failure: If the variants do not match, it returns Err(derive_more::BinaryError::Mismatch).
• Unit Variants: Multiplying Unit variants together returns a derive_more::BinaryError::Unit error.
• Return Type: The Output type for enum structural Mul is Result<Self, derive_more::BinaryError>.

use derive_more::Mul;
use core::marker::PhantomData;

#[derive(Mul)]
#[mul(forward)]
struct Point2D {
    x: i32,
    y: i32,
}

#[derive(Mul)]
#[mul(forward)]
enum MixedInts {
    BigInt(i64),
    NamedSmallInts { x: i32, y: i32 },
    Unit,
}

#[derive(Mul)]
#[mul(forward)]
enum MixedIntsWithSkip {
    TwoSmallInts(i32, #[mul(skip)] i32),
    NamedSmallInts {
        #[mul(skip)]
        x: i32,
        y: i32,
    },
}

The DerefMut derive macro implements the core::ops::DerefMut trait for your type. This allows you to mutably dereference a struct or enum variant to access its underlying member directly.

Key Requirements & Constraints:

• Single Field: Deriving Deref or DerefMut only works if the type has a single field, or if each variant of an enum has exactly one field designated for dereferencing.
• Dependency on Deref: Because DerefMut requires the target type to also implement Deref, you should almost always derive both Deref and DerefMut together.
• Two Dereference Modes:
  1. Direct Dereferencing: Accessing the field directly (treating the struct as if it were the field type).
  2. Double Dereferencing: When the field itself is a reference type (like Box or &mut), the macro handles the extra layer of dereferencing.

Use #[deref_mut] or #[deref_mut(ignore)] to specify which field should be used for the implementation.