trait-set 0.4.0

Support for trait alias feature 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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

# `trait-set`: trait aliases on stable Rust

**Status:**
[![CI](https://github.com/popzxc/trait-set/workflows/CI/badge.svg)](https://github.com/popzxc/trait-set/actions)

**Project info:**
[![Docs.rs](https://docs.rs/trait-set/badge.svg)](https://docs.rs/trait-set)
[![Latest Version](https://img.shields.io/crates/v/trait-set.svg)](https://crates.io/crates/trait-set)
[![License](https://img.shields.io/github/license/popzxc/trait-set.svg)](https://github.com/popzxc/trait-set)
![Rust 1.76+ required](https://img.shields.io/badge/rust-1.76+-blue.svg?label=Rust)

Support for trait aliases on stable Rust.

## Description

This crate provide support for [trait aliases][alias]: a feature
that is already supported by Rust compiler, but is [not stable][tracking_issue]
yet.

The idea is simple: combine group of traits under a single name. The simplest
example will be:

```rust
use trait_set::trait_set;

trait_set! {
    pub trait ThreadSafe = Send + Sync;
}
```

Macro [`trait_set`] displayed here is the main entity of the crate:
it allows declaring multiple trait aliases, each of them is represented
as

```text
[visibility] trait [AliasName][<generics>] = [Element1] + [Element2] + ... + [ElementN];
```

[`trait_set`]: https://docs.rs/trait-set/latest/trait_set/macro.trait_set.html
[alias]: https://doc.rust-lang.org/unstable-book/language-features/trait-alias.html
[tracking_issue]: https://github.com/rust-lang/rust/issues/41517

## Example

```rust
use trait_set::trait_set;

trait_set! {
    // Simple combination of two traits.
    /// Doc-comments are also supported btw.
    pub trait ThreadSafe = Send + Sync;

    // Generic alias that gets passed to the associated type.
    pub trait ThreadSafeIterator<T> = ThreadSafe + Iterator<Item = T>;

    // Specialized alias for a generic trait.
    pub trait ThreadSafeBytesIterator = ThreadSafeIterator<u8>;

    // Lifetime bounds.
    pub trait StaticDebug = 'static + std::fmt::Debug;

    // Higher-ranked trait bounds.
    pub trait Serde = Serialize + for<'de> Deserialize<'de>;

    // Lifetime as a generic parameter.
    pub trait SerdeLifetimeTemplate<'de> = Serialize + Deserialize<'de>;
    
    // Trait bounds on generic parameters for an alias.
    pub trait GenericIteratorSendableT<T: Send> = Iterator<Item = T>;
}
```

## Motivation

Rust is great, and it becomes even better through time. However, a time gap between proposing
a new feature and getting it stabilized is way too big.

Trait aliases is a great example: 20% of functionality will serve the needs of 80%.
So, until they are stabilized, this crate hopefully will allow some folks to write more readable code.

## Contributing

Feel free to submit a PR!

## LICENSE

`trait-set` library is licensed under the MIT License. See [LICENSE](LICENSE) for details.