trait-bounds 0.1.0

Trait bounds primitives using generic_const_exprs
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

//! This nightly-only library provides useful primitives for defining trait bounds
//!
//! [`eq`] and [`ne`] functions allow to check whether two types are equal in a `const` context
//!
//! [`type_id`] is similar to [`core::intrinsics::type_id`], but it can be used on [`PointeeSized`](core::marker::PointeeSized) types
//!
//! [`Assert<true>`] implements [`IsTrue`]
//!
//! [`Assert<false>`] implements [`IsFalse`]
//!
//! [`Is<T>`] is implemented for `U` if and only if `U` is equal to `T`
//!
//! [`Not<T>`] is implemented for `U` if and only if `U` is not equal to `T`
//!
//! The [`Not`] trait can be used to define multiple blanket implementations, which is particularly useful with the [`From<T>`] trait,
//! as [`From<T> for T`](From<T>#impl-From<T>-for-T) often collides with user-defined blanket impls
//!
//! ```
#![doc = include_str!("../examples/from_many.rs")]
//! ```
//! ```
#![doc = include_str!("../examples/somehow.rs")]
//! ```
#![no_std]
#![expect(internal_features)]
#![expect(incomplete_features)]
#![feature(core_intrinsics)]
#![feature(generic_const_exprs)]
#![feature(fundamental)]
#![feature(rustc_attrs)]
#![feature(intrinsics)]
#![rustc_no_implicit_bounds]

use core::{any::TypeId, intrinsics::type_id_eq};

/// Returns a [`TypeId`] of a given type
///
/// Unlike [`core::intrinsics::type_id`], this can be used on [`PointeeSized`](core::marker::PointeeSized) types
#[must_use]
#[rustc_nounwind]
#[rustc_intrinsic]
pub const fn type_id<T>() -> TypeId;

/// Returns `true` if `This` and `Other` types are equal, `false` otherwise
#[must_use]
pub const fn eq<This, Other>() -> bool {
    type_id_eq(type_id::<This>(), type_id::<Other>())
}

/// Returns `true` if `This` and `Other` types are not equal, `false` otherwise
#[must_use]
pub const fn ne<This, Other>() -> bool {
    !eq::<This, Other>()
}

/// Implements [`IsTrue`] if and only if `COND` is `true`,
/// implements [`IsFalse`] if and only if `COND` is `false`
pub struct Assert<const COND: bool>;

/// Trait used for [`Assert<bool>`] bounds, implemented by [`Assert<true>`] and not implemented by [`Assert<false>`]
#[fundamental]
pub trait IsTrue {}
impl IsTrue for Assert<true> {}

/// Trait used for [`Assert<bool>`] bounds, implemented by [`Assert<false>`] and not implemented by [`Assert<true>`]
#[fundamental]
pub trait IsFalse {}
impl IsFalse for Assert<false> {}

/// [`Is<T>`] is implemented for `U` if and only if `U` is equal to `T`
#[fundamental]
pub trait Is<T> {}
impl<T> Is<T> for T {}

/// [`Not<T>`] is implemented for `U` if and only if `U` is not equal to `T`
#[fundamental]
pub trait Not<T> {}
impl<This, Other> Not<Other> for This where Assert<{ ne::<This, Other>() }>: IsTrue {}