type-sets 0.2.3

Sets implemented in the rust type-system
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

[![Crates.io](https://img.shields.io/crates/v/type-sets.svg)](https://crates.io/crates/type-sets)
[![Documentation](https://docs.rs/type-sets/badge.svg)](https://docs.rs/type-sets)
[![License](https://img.shields.io/crates/l/type-sets.svg)](https://crates.io/crates/type-sets)

# type-sets

Compile-time set operations on Rust tuples.

`type-sets` treats tuples as sets of types. You can check whether a set contains a type, compare two sets, and build new sets, all in the type system with no runtime cost. The order of the types doesn't matter, so `(A, B)` and `(B, A)` are the same set. Sets can have up to 24 members.

## Operations

- **`Contains<E>`**: the set contains the type `E`.
- **`Subset<S>`**: every member of the set is also in `S`.
- **`Superset<S>`**: the set contains every member of `S`.
- **`SetEqual<R>`**: the two sets have the same members, in any order.
- **`IsEmpty`**: the set has no members.
- **`Insert<T, E>`**: the set `T` with `E` added.
- **`Union<T, R>`**: all members of `T` and `R`.
- **`Members`**: the members of a set as `TypeId`s, available at runtime.

Most of these are traits that you use as bounds:

```rust
use type_sets::Contains;

/// Only accepts messages that are in the set `S`.
fn send<S: Contains<M>, M>(message: M) {
    // ...
}
```

## Assertions

With the `assertions` feature, the `assert` module provides functions that check set relations at compile time. They are handy in tests:

```toml
[dev-dependencies]
type-sets = { version = "0.2", features = ["assertions"] }
```

```rust
use type_sets::*;

assert::contains::<(i32, i16), i32>();
assert::subset::<(i32,), (i32, i64)>();
assert::superset::<(i32, i16), (i32,)>();
assert::eq::<(i32, i16), (i16, i32)>();
assert::eq::<Union<(i32,), (i16,)>, (i16, i32)>();
```

Read the [documentation](https://docs.rs/type-sets) for more details.

## Libraries using type-sets

- [zestors](https://github.com/Zestors/zestors): an actor framework with Erlang/OTP-style supervision. An actor's interface is a set of message types. Sending a message checks that the interface `Contains` it, and addresses can be converted into dynamic addresses for any `Subset` of the interface.
- [axum-error-sets](https://github.com/jvdwrf/axum-error-sets): typed, composable HTTP error sets for axum. Each handler declares the set of status codes it can return, and smaller sets convert into any `Superset`.

## License

Licensed under either of [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-APACHE), at your option.