13 releases
Uses new Rust 2024
new 0.2.0 | Apr 27, 2025 |
---|---|
0.1.11 | Apr 7, 2025 |
0.1.10 | Mar 16, 2025 |
0.1.7 | Dec 11, 2024 |
0.1.0 | Jun 23, 2024 |
#1173 in Procedural macros
159 downloads per month
Used in meplang
120KB
3K
SLoC
quick-impl
quick-impl
is a Rust procedural macro that simplifies working with enums and structs by generating common methods and traits for each variant or field. This helps reduce boilerplate code and enhances the ergonomics of using enums and structs in your Rust projects.
Usage
use quick_impl::quick_impl;
#[quick_impl]
enum YourEnum {
#[quick_impl(pub const is)]
Variant1,
#[quick_impl(pub as_ref, pub(crate) as_ref_mut, impl From)]
Variant2(i32),
}
let instance1 = YourEnum::Variant1;
assert!(instance1.is_variant1());
let instance2 = YourEnum::from(42);
assert_eq!(*instance2.as_variant2().unwrap(), 42);
More examples can be found in the examples folder.
Features
Enum variant methods
as_ref
- Returns an immutable reference to the associated data of the enum variant.as_ref_mut
- Returns a mutable reference to the associated data of the enum variant.from
- Creates an instance of the enum variant from the associated data.inspect
- Calls a function with a reference to the associated data if the instance is of the enum variant.into
- Converts the enum into the associated data of the variant, returning anOption
.is
- Returnstrue
if the enum matches the specified variant.is_and
- Returnstrue
if the enum matches the specified variant and the associated data matches a predicate.set
- Replaces the current instance with a new instance of the specified variant.try_into
- Converts the enum into the associated data of the variant, returning aResult
.
Enum variant traits
Default
- Implements theDefault
trait on the enum.From
- Implements theFrom
trait on the enum.TryInto
- Implements theTryInto
trait on the enum.TryFrom
- Implements theTryFrom
trait on the associated data.
Structure field methods
get
- A getter for the field. Returns a reference to the field.get_clone
- A getter for the field. Returns a clone of the field.get_mut
- A mutable getter for a field.into
- Converts the struct into the field.from
- Creates an instance from the field. Sets the other fields to their default value.replace
- A setter for the field, returning the previous value.set
- A setter for the field, returning a mutable reference to the instance.take
- Returns the field and replaces it with its default value.with
- Returns the struct with the field modified.
Structure field traits
AsRef
- Implements theAsRef
trait for the struct.AsMut
- Implements theAsMut
trait for the struct.Borrow
- Implements theBorrow
trait for the struct.BorrowMut
- Implements theBorrowMut
trait for the struct.Deref
- Implements theDeref
trait for the struct.DerefMut
- Implements theDerefMut
trait for the struct.From
- Implements theFrom
trait for the struct, allowing it to be created from the field value while setting the other fields to their default values.Into
- Implements theInto
trait for the struct, converting the structure instance into the field value.
Structure global methods
new
- Constructs a new instance from the given field values.from_tuple
- Constructs a new instance from a tuple of the given field values.into_parts
- Destructures the instance into its fields values.
Structure global traits
From
- Implements theFrom
trait for the struct, allowing it to be created from a tuple of its field values.Into
- Implements theInto
trait for the struct, converting the structure instance into a tuple of its field values.
Configuration
Methods configurations
name
- Sets the name of the generated method. If not set, a default name is used.
#[quick_impl::quick_impl]
struct Foo {
#[quick_impl(pub get_clone = { name = "get_{}_unchecked"})]
bar: usize,
#[quick_impl(pub get_clone = "get_{}_unchecked")] // Shorter version
baz: usize,
}
let instance = Foo { bar: 1, baz: 2 };
assert_eq!(instance.get_bar_unchecked(), 1);
assert_eq!(instance.get_baz_unchecked(), 2);
doc
- Sets the documentation for the generated method. If not set, a default documentation is generated.
#[quick_impl::quick_impl(pub const new = { doc = "Generates an awesome instance of [`Foo`]." })]
struct Foo {
bar: usize,
baz: usize,
}
Traits configurations
doc
- Sets the documentation of the generated trait method. If not set, a default documentation is generated.
#[quick_impl::quick_impl]
enum Foo {
#[quick_impl(impl TryFrom = { doc = "Attempts to extract the associated data from a [`Foo::Bar`] variant." })]
Bar(usize),
Baz(isize),
}
Reduce duplicates with quick_impl_all
quick_impl_all
is a helper macro that automatically applies the specified quick_impl
attributes to all variants (for enums) or all fields (for structs).
You can combine it with regular quick_impl
attributes on individual variants or fields.
use quick_impl::quick_impl_all;
#[quick_impl_all(pub const is)]
enum MyEnum {
VariantA,
#[quick_impl(pub from)]
VariantB(i32),
}
let variant = MyEnum::from_variant_b(10);
assert!(variant.is_variant_b());
assert!(!variant.is_variant_a());
About derive_more
This crate is not intended to compete with derive_more
. While derive_more
focuses on deriving standard traits, the primary goal of quick-impl
is to generate common methods like is_*
, as_*
, and set_*
.
Trait implementations were added where it made sense and was easy to support, but quick-impl
will never aim to match the breadth of trait support provided by derive_more
.
Installation
Add quick-impl
to your Cargo.toml
:
[dependencies]
quick-impl = "0.2"
Or run the following command:
cargo add quick-impl
Dependencies
~205–640KB
~15K SLoC