generic_constants 0.1.0

Traits providing type-generic numeric constants (Zero, One, ..., OneHundredTwentySeven) implemented across common integer and float types.
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
104
105
106
107
108
109
110
111

# Typed Constants via Traits: Zero, One, ..., OneHundredTwentySeven

This crate provides a family of traits, one per integer constant in the range 0 through 127.
Each trait defines a single associated constant whose value is implemented across common numeric types (i8, u8, i16, u16, i32, i64, usize, f32, f64, etc.).

The traits allow writing generic code that refers to numeric constants without requiring conversion or From bounds, and without depending on unstable generic constant features.

## Motivation

When writing generic numeric code in Rust, one often wants to refer to numeric constants that work across different numeric types. However:

`T::from(127)` requires trait bounds and may not be available for all numeric types

as conversions are lossy when crossing from signed to unsigned or integer to float

Generic constant expressions are still limited in stable Rust

This crate provides a simple and predictable alternative:
one trait per number, one associated constant, implemented for common numeric types.

Example
```Rust
use generic_constants::OneHundredTwentySeven;

fn saturate_to_127<T: OneHundredTwentySeven + Ord>(value: T) -> T {
    if value > T::ONE_HUNDRED_TWENTY_SEVEN {
        T::ONE_HUNDRED_TWENTY_SEVEN
    } else {
        value
    }
}

fn main() {
    assert_eq!(saturate_to_127(200u32), 127u32);
    assert_eq!(saturate_to_127(50u32), 50u32);
}
```

No casts, no conversion traits, no intermediate types.

Trait Structure

Each trait follows the same pattern:

```rust
pub trait OneHundredTwentySeven {
    const ONE_HUNDRED_TWENTY_SEVEN: Self;
}
```

and is implemented for a consistent set of numeric types:

All signed and unsigned integers: i8 u8 i16 u16 i32 u32 i64 u64 i128 u128 isize usize

Floating types: f32, f64

Example implementation:

```rust
impl OneHundredTwentySeven for i8   { const ONE_HUNDRED_TWENTY_SEVEN: Self = 127; }
impl OneHundredTwentySeven for u8   { const ONE_HUNDRED_TWENTY_SEVEN: Self = 127; }
impl OneHundredTwentySeven for f32  { const ONE_HUNDRED_TWENTY_SEVEN: Self = 127.0; }
// etc...
```

## Naming Conventions

Traits are named using English number words: Zero, One, Two, ..., FortyTwo, ..., OneHundredTwentySeven

Associated constants follow the same English spelling, but in uppercase with underscores

This ensures:

- Fully deterministic naming

- No ambiguity regarding spelling, hyphens, short forms, or ordinals

- Easy auto-completion in IDEs

## Use Cases

- Generic numeric algorithms

- Compile-time bounds and limits

- Avoiding lossy casts

- Writing crates that work across integer and float types without feature gates

- Type-directed constant selection

## Status and Scope

### Range: 0 to 127 inclusive

All traits are stable, pure Rust, and require no features

### No dependencies

If desired, the range can be extended.
Open an issue if you need OneHundredTwentyEight and beyond.

### License

This project is available under:

- MIT License

- Apache License 2.0

At your choice.