5 releases (breaking)

0.5.0 Oct 20, 2022
0.4.0 Sep 12, 2022
0.3.2 Sep 6, 2022
0.3.0 Oct 4, 2021
0.1.0 Apr 25, 2021

#10 in #stylish

Download history 35/week @ 2024-07-28 21/week @ 2024-08-04 41/week @ 2024-08-11 16/week @ 2024-08-18 16/week @ 2024-08-25 13/week @ 2024-09-01 13/week @ 2024-09-08 7/week @ 2024-09-15 29/week @ 2024-09-22 22/week @ 2024-09-29 32/week @ 2024-10-06 18/week @ 2024-10-13 18/week @ 2024-10-20 16/week @ 2024-10-27 18/week @ 2024-11-03

74 downloads per month
Used in valued

MIT/Apache

27KB
585 lines

Giftwrap Crates

Wrap and unwrap your types the stylish way with derive macros for From/TryFrom in both directions

How does it work?

giftwrap exposes two derive macros, Wrap and Unwrap that derive impl From<inner_type> for your_type and impl From<your_type> for inner_type (or TryFrom<your_type> in the case of enums) respectively. It works for any struct or enum variant that holds only a single type, and don't worry variants with multiple types or with types you want to convert yourself can be easily ignored by setting noWrap and noUnwrap in the #[giftwrap()] attribute.

Examples

Consider the following error.rs

pub type Result<T> = std::result::Result<T, Error>;

macro_rules! impl_from {
    ($wrapper:expr, $inner:ty) => {
        impl From<$inner> for Error {
            fn from(e: $inner) -> Error {
                $wrapper(e)
            }
        }
    };
}

#[derive(Debug)]
pub enum Error {
    Io(std::io::Error),
    RppalGpio(rppal::gpio::Error),
    Reqwest(reqwest::Error),
    Qr(Box<qrcodegen::DataTooLong>),
    Other(String),
}

impl_from!(Error::Io, std::io::Error);
impl_from!(Error::RppalGpio, rppal::gpio::Error);
impl_from!(Error::Reqwest, reqwest::Error);

impl From<qrcodegen::DataTooLong> for Error {
    fn from(f: qrcodegen::DataTooLong) -> Self {
        Error::Qr(f.into())
    }
}

impl From<Box<qrcodegen::DataTooLong>> for Error {
    fn from(f: Box<qrcodegen::DataTooLong>) -> Self {
        Error::Qr(f)
    }
}

This might seem simple enough but adding new error types is not as easy as it could be.

However with giftwrap it's as simple as it gets:

pub type Result<T> = std::result::Result<T, Error>;

use giftwrap::Wrap;
#[derive(Debug, Wrap)]
pub enum Error {
    Io(std::io::Error),
    RppalGpio(rppal::gpio::Error),
    Reqwest(reqwest::Error),
    #[giftwrap(wrapDepth = 0)]
    Qr(<qrcodegen::DataTooLong>),
    #[giftwrap(noWrap = true)]
    Other(String),
}

Now you could add a new error variant wrapping a type from any library and giftwrap handles the rest for you

Dependencies

~2MB
~46K SLoC