const-destructure 0.1.1

Destructuring in const contexts on stable Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

This crate provides a macro that allows you to destructure types in a `const` context:

```rust
// A wrapper that does not implement `Copy` to enforce values are moved.
struct NoCopy<T>(T);

// Some struct we'd like to break up in a const fn.
struct Wrap<A, B> {
    a: A,
    b: B,
}

const fn test() {
    const_destructure!(let Wrap { a: a, b: b } = Wrap { a: NoCopy(1), b: NoCopy(2) });

    assert!(matches!(a, NoCopy(1)));
    assert!(matches!(b, NoCopy(2)));
}
```

Unlike normal destructuring, the macro enforces that you assign all fields.
If it didn't, it would be possible to accidentally leak unassigned fields because of how the macro is implemented. 
This is still a big win over writing the implementation by hand, which requires `unsafe`.

## Motivation

The following doesn't compile on rustc 1.90.0 (2025) due to https://github.com/rust-lang/rust/issues/86897:

```rust
pub struct Wrap<T> {
    value: T,
}

impl<T> Wrap<T> {
    pub const fn into_inner(self) -> T {
        let Self { value } = self;
        value
    }
}
```

```txt
error[E0493]: destructor of `Wrap<T>` cannot be evaluated at compile-time
 --> test.rs:6:29
  |
6 |     pub const fn into_inner(self) -> T {
  |                             ^^^^ the destructor for this type cannot be evaluated in constant functions
7 |         self.value
8 |     }
  |     - value is dropped here

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0493`.
```

You get the same error without destructuring:

```rust
impl<T> Wrap<T> {
    pub const fn into_inner(self) -> T {
        self.value
    }
}
```