u-num-it 0.3.4

typenum macro for matching types from a given range
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

# u-num-it

A simple procedural macro for matching `typenum::consts` in a given range or array.

It helps you write concise numeric typenum matches like:

```rust
use typenum::{Bit, ToInt, Unsigned};

let x: isize = 3;

let y: isize = u_num_it::u_num_it!(-5..5, match x {
    N => {
        // negative integer types implement ToInt
        NumType::to_int()
    },
    False => {
        // False (B0) is a Bit, not an Integer. Use to_u8() and cast.
        NumType::to_u8() as isize
    },
    P => {
        // positive integer types implement ToInt
        NumType::to_int()
    }
});

assert_eq!(y, 3);
```

Or with an array of arbitrary numbers:

```rust
use typenum::{Bit, ToInt, Unsigned};

let x: isize = 8;

let y: isize = u_num_it::u_num_it!([1, 2, 8, 22], match x {
    P => {
        NumType::to_int()
    },
    _ => panic!("unexpected")
});

assert_eq!(y, 8);
```

Instead of writing the explicit (and repetitive) match yourself:

```rust
use typenum::{Bit, ToInt, Unsigned};

let x: isize = 3;

let y: isize = match x {
    -5 => typenum::consts::N5::to_int(),
    -4 => typenum::consts::N4::to_int(),
    -3 => typenum::consts::N3::to_int(),
    -2 => typenum::consts::N2::to_int(),
    -1 => typenum::consts::N1::to_int(),
     0 => typenum::consts::False::to_u8() as isize, // False is a Bit (B0)
     1 => typenum::consts::P1::to_int(),
     2 => typenum::consts::P2::to_int(),
     3 => typenum::consts::P3::to_int(),
     4 => typenum::consts::P4::to_int(),
    i  => panic!("out of range: {i}")
};

assert_eq!(y, 3);
```

`NumType` is available inside each match arm, bound to the concrete typenum type for the matched value:

```rust
use typenum::{Bit, ToInt};

let x: isize = 3;

let y: isize = u_num_it::u_num_it!(-5..5, match x {
    N => {
        // NumType is a negative integer type (e.g. typenum::consts::N3 when x = -3)
        NumType::to_int()
    },
    False => {
        // NumType is typenum::consts::False (B0). Use to_u8() and cast if you need an isize.
        let zero: u8 = NumType::to_u8();
        zero as isize
    },
    P => {
        // NumType is typenum::consts::P3 when x = 3
        let val: isize = NumType::to_int();
        val
    }
});

assert_eq!(y, 3);
```

## Notes

- Use `ToInt` for signed/unsigned integer typenum constants (`P*`, `N*`).
- Use `to_u8()` for bit types (`False` = `B0`, `True` = `B1` if you ever introduce it), casting as needed.
- Avoid mixing `P` and `U` in the same macro call (the macro enforces this).
- Literal `0` and `False` are treated as the same value; don't use both in one invocation.