quick-impl

quick-impl is a Rust procedural macro that generates usual methods and trait implementations for enums and structs, reducing boilerplate and improving ergonomics.

Quick start

use quick_impl::quick_impl;

#[quick_impl]
enum Shape {
    #[quick_impl(pub const is)]
    Circle(f64),

    #[quick_impl(pub as_ref, as_ref_mut, impl From)]
    Rectangle(f64, f64),

    #[quick_impl(pub as_ref, pub into)]
    Square(f64),
}

let circle = Shape::Circle(5.0);
assert!(circle.is_circle());

let rect = Shape::from((3.0, 4.0));
assert_eq!(rect.as_rectangle().unwrap(), (&3.0, &4.0));

let square = Shape::Square(10.0);
assert_eq!(square.into_square().unwrap(), 10.0);

More examples can be found in the examples folder.

Features

Enum variant methods

Attribute	Description
as_ref	Returns a reference to the associated data if the enum is the specified variant.
as_ref_mut	Returns a mutable reference to the associated data if the enum is the specified variant.
from	Creates the specified variant from the provided data.
inspect	Calls a closure with a reference to the associated data if the enum is the specified variant, and returns self.
into	Extracts the associated data if the enum is the specified variant, returning an Option.
is	Returns true if the enum is the specified variant.
is_and	Returns true if the enum is the specified variant and the associated data satisfies a predicate.
set	Sets self to the specified variant with the given data, returning the previous value.
try_into	Extracts the associated data if the enum is the specified variant, returning a Result.

Enum variant traits

Attribute	Description
Default	Implements Default, constructing the specified variant.
From	Implements From to construct the specified variant.
TryFrom	Implements TryFrom to extract the associated data.
TryInto	Implements TryInto to extract the associated data.

Struct field methods

Attribute	Description
get	Returns a reference to the field.
get_clone	Returns a clone of the field.
get_mut	Returns a mutable reference to the field.
into	Consumes self and returns the field.
from	Creates an instance from the field, setting the remaining fields to their default values.
replace	Replaces the field with the given value, returning the previous value.
set	Sets the field and returns &mut self for chaining.
take	Takes the field, replacing it with its default value.
with	Returns self with the field set to the given value.

Struct field traits

Attribute	Description
AsRef	Implements AsRef to return a reference to the field.
AsMut	Implements AsMut to return a mutable reference to the field.
Borrow	Implements Borrow for the field type.
BorrowMut	Implements BorrowMut for the field type.
Deref	Implements Deref with the field as the target.
DerefMut	Implements DerefMut with the field as the target.
From	Implements From to create the struct from the field, defaulting the remaining fields.
Into	Implements Into to convert the struct into the field value.

Struct global methods

Attribute	Description
new	Constructs a new instance from the given field values.
from_tuple	Constructs a new instance from a tuple of field values.
into_parts	Decomposes the instance into a tuple of its field values.

Struct global traits

Attribute	Description
From	Implements From to create the struct from a tuple of its field values.
Into	Implements Into to convert the struct into a tuple of its field values.

Reducing duplication with quick_impl_all

quick_impl_all applies the specified attributes to all variants (for enums) or all fields (for structs). You can combine it with per-variant/per-field quick_impl attributes:

use quick_impl::quick_impl_all;

#[quick_impl_all(pub const is)]
enum MyEnum {
    VariantA,

    #[quick_impl(pub from)]
    VariantB(i32),
}

fn main() {
    let variant = MyEnum::from_variant_b(10);
    assert!(variant.is_variant_b());
    assert!(!variant.is_variant_a());
}

Configuration

Method configuration

• name — Override the generated method name. Use {} as a placeholder for the variant/field name.

#[quick_impl::quick_impl]
struct Foo {
    #[quick_impl(pub get_clone = { name = "get_{}_unchecked" })]
    bar: usize,
    #[quick_impl(pub get_clone = "get_{}_unchecked")] // shorthand
    baz: usize,
}

fn main() {
    let foo = Foo { bar: 1, baz: 2 };
    assert_eq!(foo.get_bar_unchecked(), 1);
    assert_eq!(foo.get_baz_unchecked(), 2);
}

• doc — Override the generated documentation string.

#[quick_impl::quick_impl(pub const new = { doc = "Generates an awesome instance of [`Foo`]." })]
struct Foo {
    bar: usize,
    baz: usize,
}

Trait configuration

• doc — Override the generated documentation for the trait method.

#[quick_impl::quick_impl]
enum Foo {
    #[quick_impl(impl TryFrom = { doc = "Attempts to extract the data from a [`Foo::Bar`] variant." })]
    Bar(usize),
    Baz(isize),
}

Comparison with derive_more

This crate is not intended to replace derive_more. While derive_more focuses on deriving standard traits, quick-impl focuses on generating common methods like is_*, as_*, and set_*. Trait implementations are included where they complement the method generation, but matching the breadth of derive_more is a non-goal.

Installation

Add quick-impl to your Cargo.toml:

[dependencies]
quick-impl = "0.2"

Or run:

cargo add quick-impl

License

Licensed under either of Apache License, Version 2.0 or MIT License, at your option.