How to Repeat Commonly Derived Traits in Rust

Problem

In Rust, when exposing types in your api, it’s recommended to eagerly implement commonly derived traits. This is because of the orphan rule. The api user won’t be able to implement the necessary traits for your types as needed.

The commonly implemented traits are:

• Copy
• Clone
• Eq
• PartialEq
• Ord
• PartialOrd
• Hash
• Debug
• Display
• Default
• From
• TryFrom
• AsRef
• AsMut
• Serialize
• Deserialize
• Send
• Sync

It’s also recommended in the Rust Api Guidelines:

• Types eagerly implement common traits (C-COMMON-TRAITS)
• Conversions use the standard traits From, AsRef, AsMut (C-CONV-TRAITS)
• Types are Send and Sync where possible (C-SEND-SYNC)
• Data structures implement Serde’s Serialize, Deserialize (C-SERDE)

However, it’s not only cumbersome but also error-prone if you implement these manually.

#[derive(Debug, Default, Serialize, Deserialize, PartialOrd, PartialEq, /* etc. */)]
pub struct ListRequestParams {
    // Ommitted
}

As so, an automated solution is necessary.

Solution

There are two solutions which I’ve come up with.

1. Creating a Derive Procedural Macro to auto implement the traits
2. Checking if a type implements required traits

1. Creating a Derive Procedural Macro to auto implement the traits

You can create a custom procedural macro to auto implement the traits.

However, I found this to be not scalable since there are lots of situations when you have to implement a trait manually. (Even if you use crates like derive macro) I ended up being able to define only a few traits in the proc macro.

2. Checking if a type implements required traits

This is the solution I’ve settled on. I don’t care how the traits are implemented, but just checked if the necessary traits are implemented afterward. I used the crate static assertions’s assert_impl_alland wrapped it in a declarative macro to check if the traits are implemented.

Here’s an example.

#[macro_export]
macro_rules! assert_impl_all_commons {
    ($type:ty) => {
        ::static_assertions::assert_impl_all!(
            $type:
            Send,
            Sync,
            Clone,
            std::fmt::Debug,
            std::fmt::Display,
            serde::Serialize,
            serde::de::DeserializeOwned,
            PartialEq,
            PartialOrd,
        );
    };
}

You can use it as below.

// This will throw errors during compile time if the necessary traits are not implemented.
assert_impl_all_commons!(CorpCls);

#[derive(Clone, Debug, Serialize, Deserialize, PartialOrd, PartialEq, AsRef, Display)]
pub struct CorpCls(Inner);

Limitations

It could be skill issues, but I found it hard to require generic traits like From and TryFrom, and also traits which require specific lifetimes (You can see I’ve required DeserializeOwned instead of Deserialize in my example above).

I’m a novice in Rust and didn’t want to spend too much time on this.

If you have an idea or a better solution, do please let me know! (junepark202012@gmail.com)

Thank you, and happy coding! 🦀