4 releases (2 breaking)
0.3.0 | Aug 10, 2022 |
---|---|
0.2.0 | Apr 9, 2022 |
0.1.1 | Mar 23, 2022 |
0.1.0 | Mar 21, 2022 |
#726 in Rust patterns
25KB
411 lines
munge
makes it easy and safe to destructure MaybeUninit
s, Cell
s, ManuallyDrop
s, and more.
Just use the munge!
macro to destructure opaque types the same way you'd destructure a value.
munge
has no features and is always #![no_std]
.
Examples
munge
makes it easy to initialize MaybeUninit
s:
use {
::core::mem::MaybeUninit,
::munge::munge,
};
pub struct Example {
a: u32,
b: (char, f32),
}
let mut mu = MaybeUninit::<Example>::uninit();
munge!(let Example { a, b: (c, mut f) } = &mut mu);
assert_eq!(a.write(10), &10);
assert_eq!(c.write('x'), &'x');
assert_eq!(f.write(3.14), &3.14);
// Note that `mut` bindings can be reassigned like you'd expect:
f = &mut MaybeUninit::uninit();
// SAFETY: `mu` is completely initialized.
let init = unsafe { mu.assume_init() };
assert_eq!(init.a, 10);
assert_eq!(init.b.0, 'x');
assert_eq!(init.b.1, 3.14);
It can also be used to destructure Cell
s:
use {
::core::cell::Cell,
::munge::munge,
};
pub struct Example {
a: u32,
b: (char, f32),
}
let value = Example {
a: 10,
b: ('x', 3.14),
};
let cell = Cell::<Example>::new(value);
munge!(let Example { a, b: (c, f) } = &cell);
assert_eq!(a.get(), 10);
a.set(42);
assert_eq!(c.get(), 'x');
c.set('!');
assert_eq!(f.get(), 3.14);
f.set(1.41);
let value = cell.into_inner();
assert_eq!(value.a, 42);
assert_eq!(value.b.0, '!');
assert_eq!(value.b.1, 1.41);
You can even extend munge
to work with your own types by implementing its Destructure
and
Restructure
traits.
Dependencies
~0.7–1MB
~26K SLoC