#traits #macro-derive #proc-macro-attributes #attributes #impl

macro blanket

A simple macro to derive blanket implementations for your traits

8 unstable releases (3 breaking)

0.4.0 Mar 4, 2024
0.3.0 Jun 19, 2023
0.2.0 Jun 5, 2021
0.1.5 May 30, 2021
0.1.2 Jul 23, 2020

#309 in Rust patterns

Download history 2089/week @ 2023-12-06 1524/week @ 2023-12-13 867/week @ 2023-12-20 700/week @ 2023-12-27 1047/week @ 2024-01-03 1956/week @ 2024-01-10 1773/week @ 2024-01-17 1988/week @ 2024-01-24 1791/week @ 2024-01-31 1463/week @ 2024-02-07 1673/week @ 2024-02-14 1435/week @ 2024-02-21 3637/week @ 2024-02-28 2716/week @ 2024-03-06 2109/week @ 2024-03-13 2946/week @ 2024-03-20

11,678 downloads per month
Used in 71 crates (5 directly)

MIT license

86KB
2K SLoC

๐Ÿงฃ blanket Star me

A simple macro to derive blanket implementations for your traits.

Actions Codecov License Source Crate Documentation Changelog GitHub issues

๐Ÿ” Overview

The Rust standard library has plenty of traits, but they shine in how well they integrate with new types. Declare an implementation of std::io::Write for a type W, and you also get it for &mut W and Box<W>! This however translates into a lot of boilerplate code that can be hard to maintain, which is why many crates don't bother providing the same convenience implementations.

This is where blanket comes in! This crate helps you build the same kind of blanket implementations for your own traits with as least additional code as possible: in fact, this is as close as what a derive macro would look like for a trait item.

๐Ÿ”Œ Usage

blanket exports a single eponymous attribute macro, which can be imported simply after the crate has been added to the Cargo.toml dependencies:

extern crate blanket;
use blanket::blanket;

#[blanket(derive(...))]

Use this macro attribute to derive a blanket implementation for a trait, provided the trait methods fit the constraints for that derive, such as only declaring methods with &self of &mut self as their receiver. The following derives are available:

Derive Impl block fn (&self) fn (&mut self) fn (self)
Ref impl<T: Trait + ?Sized> Trait for &T โœ”๏ธ
Rc impl<T: Trait + ?Sized> Trait for Rc<T> โœ”๏ธ
Arc impl<T: Trait + ?Sized> Trait for Arc<T> โœ”๏ธ
Mut impl<T: Trait + ?Sized> Trait for &mut T โœ”๏ธ โœ”๏ธ
Boxยน impl<T: Trait + ?Sized> Trait for Box<T> โœ”๏ธ โœ”๏ธ
Boxยฒ impl<T: Trait> Trait for Box<T> โœ”๏ธ โœ”๏ธ โœ”๏ธ
Cow impl<T: Trait + ToOwned + ?Sized> Trait for Cow<_, T> โœ”๏ธ

For instance, with our own version of std::fmt::Write, we can provide an implementation for Box<impl Write> and &mut impl Write:

extern crate blanket;
use blanket::blanket;

#[blanket(derive(Mut, Box))]
pub trait Write {
    fn write_str(&mut self, s: &str) -> std::fmt::Result;
    fn write_char(&mut self, c: char) -> std::fmt::Result {
         self.write_str(c.encode_utf8(&mut [0; 4]))
    }
}

Note that we can't derive Ref because the Write trait we declared expects mutable references, which we can't provide from an immutable reference. If we were to try, the compiler would warn us:

---- src/lib.rs - (line 55) stdout ----
error: cannot derive `Ref` for a trait declaring `&mut self` methods
 --> src/lib.rs:61:18
  |
8 |     fn write_str(&mut self, s: &str) -> std::fmt::Result;
  |                  ^^^^^^^^^

#[blanket(default = "...")]

blanket can delegate default implementations of trait methods to functions of another module. This can be useful for some traits such as visitors to provide a default behaviour as an external function, such as what syn::visit is doing.

The following example implements a very simple visitor trait for types able to process a &str char-by-char.

extern crate blanket;
use blanket::blanket;

#[blanket(default = "visitor")]
trait Visitor {
    fn visit_string(&self, s: &str);
    fn visit_char(&self, c: char);
}

mod visitor {
    use super::Visitor;

    pub fn visit_string<V: Visitor + ?Sized>(v: &V, s: &str) {
        for c in s.chars() {
            v.visit_char(c);
        }
    }

    pub fn visit_char<V: Visitor + ?Sized>(v: &V, c: char) {}
}

blanket will check that all methods are declared without a default block, and then create a default implementation for all of the declared methods, generating the following code:

trait Visitor {
    fn visit_string(&self, s: &str) {
      visitor::visit_string(self, s)
    }
    fn visit_char(&self, c: char) {
      visitor::visit_char(self, c)
    }
}

๐Ÿ“ To-Do

  • โœ“ Delegation of default method to external functions.
  • โœ“ Support for traits with generic arguments.
  • โœ“ #[derive(Ref)]
  • โœ“ #[derive(Mut)]
  • โœ“ #[derive(Box)] for both sized and unsized types.
  • โœ“ #[derive(Rc)]
  • โœ“ #[derive(Arc)]
  • โœ“ #[derive(Cow)]

๐Ÿค Credits

blanket is developed and maintained by:

The following people contributed to the project:

๐Ÿ“‹ Changelog

This project adheres to Semantic Versioning and provides a changelog in the Keep a Changelog format.

๐Ÿ“œ License

This library is provided under the open-source MIT license.

Dependencies

~280โ€“720KB
~17K SLoC