Crate impl_more

Expand description

Concise, declarative trait implementation macros.

§`#[no_std]`

Where possible, these macros emit #[no_std]-compatible code.

§Usage

struct MyNewTypeStruct(String);

impl_more::impl_as_ref!(MyNewTypeStruct => String);
impl_more::impl_as_mut!(MyNewTypeStruct => String);
impl_more::forward_as_ref!(MyNewTypeStruct => str);
impl_more::forward_as_mut!(MyNewTypeStruct => str);

impl_more::impl_deref!(MyNewTypeStruct => String);
impl_more::impl_deref_mut!(MyNewTypeStruct);
// or, to deref through String too:
// impl_more::forward_deref_and_mut!(MyNewTypeStruct => ref str);

impl_more::impl_from!(String => MyNewTypeStruct);
impl_more::impl_into!(MyNewTypeStruct => String);

impl_more::forward_display!(MyNewTypeStruct);
impl_more::forward_from_str!(MyNewTypeStruct => String);

struct Items<T>(Vec<T>);

impl_more::forward_into_iterator!(<T> in Items<T> => Vec<T>; owned, ref, ref_mut);
impl_more::forward_from_iterator!(<T> in Items<T> => Vec<T>);
impl_more::forward_extend!(<T> in Items<T> => Vec<T>);

struct Mask(u32);

impl_more::forward_debug!(Mask);
impl_more::forward_lower_hex!(Mask);
impl_more::forward_binary!(Mask);

enum MyEnum {
    Bar,
    Qux,
}

impl_more::impl_display_enum!(MyEnum: Bar => "bar", Qux => "qux");

enum Coords {
    Xy(i64, i64),
    Xyz(i64, i64, i64),
    Uv(i64, i64),
}

impl_more::impl_display_enum!(
    Coords:
    Xy(x, y) => "{x}, {y}",
    Xyz(x, y, z) => "{x}, {y}, {z}",
    Uv(u, _) => "{u}",
);

#[derive(Debug)]
struct MyError(eyre::Report);

impl_more::forward_display!(MyError);
impl_more::forward_error!(MyError);

let err = MyError(eyre::eyre!("something went wrong"));
assert_eq!(err.source().unwrap().to_string(), "something went wrong");

#[derive(Debug)]
struct MyFieldError {
    cause: eyre::Report,
}

impl_more::forward_display!(MyFieldError => cause);
impl_more::forward_error!(MyFieldError => cause);

let err = MyFieldError {
    cause: eyre::eyre!("something else went wrong"),
};
assert_eq!(
    err.source().unwrap().to_string(),
    "something else went wrong"
);

#[derive(Debug)]
enum Err {
    Io(std::io::Error),
    Generic(String),
}

impl_more::impl_display_enum! {
    Err:
    Io(err) => "{err}",
    Generic(msg) => "{msg}",
}
impl_more::impl_error_enum!(Err: Io(err) => err);

Declare type and const parameters before in:

struct Array<T, const N: usize>([T; N]);

impl_more::impl_as_ref!(<T, const N: usize> in Array<T, N> => [T; N]);
impl_more::impl_from!(<T, const N: usize> in [T; N] => Array<T, N>);
impl_more::forward_into_iterator!(<T, const N: usize> in Array<T, N> => [T; N]; owned);

let value = Array::from([1, 2, 3]);
assert_eq!(value.as_ref(), &[1, 2, 3]);
assert_eq!(value.into_iter().sum::<u32>(), 6);

Macros§

forward_as_mut: Implement AsMut by forwarding to a field’s implementation.
forward_as_ref: Implement AsRef by forwarding to a field’s implementation.
forward_as_ref_and_mut: Implement AsRef and AsMut by forwarding to a field’s implementations.
forward_binary: Implement Binary by forwarding to a field.
forward_debug: Implement Debug by forwarding to a field.
forward_deref_and_mut: Implements Deref and DerefMut by forwarding through an inner field’s implementation.
forward_display: Implements Display for structs by forwarding to one of its field.
forward_error: Implements Error for structs and forwards the source implementation to one of its fields.
forward_extend: Implement Extend by forwarding to a field.
forward_from_iterator: Implement FromIterator for a single-field wrapper.
forward_from_str: Implement FromStr by forwarding to a field’s implementation.
forward_into_iterator: Implement IntoIterator by forwarding to a field.
forward_lower_exp: Implement LowerExp by forwarding to a field.
forward_lower_hex: Implement LowerHex by forwarding to a field.
forward_octal: Implement Octal by forwarding to a field.
forward_pointer: Implement Pointer by forwarding to a field.
forward_upper_exp: Implement UpperExp by forwarding to a field.
forward_upper_hex: Implement UpperHex by forwarding to a field.
impl_as_mut: Implement AsMut for a struct.
impl_as_ref: Implement AsRef for a struct.
impl_deref: Implement Deref for a struct.
impl_deref_and_mut: Implements Deref and DerefMut by forwarding through an inner field’s implementation.
impl_deref_mut: Implement DerefMut for a struct.
impl_display: Implements Display for structs using a format!-like string constructor.
impl_display_enum: Implements Display for enums using a static string or format args for each variant.
impl_enum_from: Implement From for an enum variant with one named or unnamed field.
impl_error_enum: Implements Error for enums.
impl_from: Implement From for a struct.
impl_from_for_primitive: Implement From for a primitive.
impl_into: Implement Into for a struct.
impl_leaf_error: Implements leaf Errors.
impl_newtype_from_into: Implement From and Into for a newtype struct.

Crate impl_more

Crate impl_more Copy item path

§#[no_std]

§Usage

Macros§

Crate impl_more

§`#[no_std]`