strict-typing 0.1.0

A procedural macro for ensuring strict type safety.
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
112
113
114
115
116
117
118
119
120

# strict-typing

A Rust procedural macro that enforces strict typing on struct fields, enum variants, function signatures, trait definitions, and impl blocks. It prevents the use of bare primitive types, encouraging newtype wrappers for clarity and safety.

Rust is all about correctness in my humble opinion. And I want it to stay that way
in my personal experience. I think this is how Rust should have been made. This
should be a compiler built-in.

## Motivation

Bare primitives like `u32` or `bool` compile fine but carry no domain meaning. A `u32` could be a user ID, a pixel count, or a port number — the type system won't stop you from mixing them up. Newtype wrappers (`struct UserId(u32)`) make intent explicit and catch misuse at compile time.

In my projects, I always create the transparent newtypes that **precisely** define what they carry.
If I ever need to, I also create only the correct versions of conversions between such and other types.

Originally wrote for my own projects, I decided to share it with others. Enjoy.

`#[strict_types]` turns this from a convention into a compiler-enforced rule.

P.S. I decided to name the project `strict-typing` initially with the intention to
extend its functionality.

## Usage

Add the dependency:

```toml
[dependencies]
strict-typing = "0.1"
```

### Basic — reject primitives in struct fields

```rust
use strict_typing::strict_types;

struct Percentage(u8);
struct Label(String);

#[strict_types]
struct Config {
    ratio: Percentage, // OK — newtype wrapper
    name: Label,       // OK
    // count: u32,     // compile error: disallowed type `u32`
}
```

### Enums

```rust
use strict_typing::strict_types;

struct Velocity(f64);

#[strict_types]
enum Event {
    Click { x: Velocity, y: Velocity },
    Disconnect,
    // Resize(u32, u32), // compile error
}
```

### Functions, traits, and impl blocks

```rust
use strict_typing::strict_types;

struct Distance(f64);
struct Speed(f64);
struct Duration(f64);

#[strict_types]
fn compute_speed(d: Distance, t: Duration) -> Speed {
    Speed(d.0 / t.0)
}
```

### Extending the disallow list

By default, all numeric primitives plus `bool` and `char` are disallowed. Add more with `disallow(...)`:

```rust
use strict_typing::strict_types;

/// # Strictness
///
/// - [String] disallowed because domain names should use a newtype.
#[strict_types(disallow(String))]
struct Name {
    // value: String, // compile error
}
```

### Allowing specific primitives

Remove types from the default disallow list with `allow(...)`:

```rust
use strict_typing::strict_types;

/// # Strictness
///
/// - [bool] allowed here because a simple flag is sufficient.
#[strict_types(allow(bool))]
struct Flags {
    enabled: bool, // OK
}
```

### Documentation requirement

When using `allow(...)` or `disallow(...)`, you must document each override in a `/// # Strictness` doc section. This forces authors to justify every exception, keeping the decision visible in code review.

## Default disallowed types

`u8` `u16` `u32` `u64` `u128` `usize` `i8` `i16` `i32` `i64` `i128` `isize` `f32` `f64` `bool` `char`

## License

MIT