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

use crate::TypeEq;

/// Emulation of `T == U` bounds.
/// 
/// This trait emulates `T == U` bounds with `T: Identity<Type = U>`.
/// 
/// # Projection
/// 
/// Because this trait uses [`TypeEq`] for casting between `Self` and [`Self::Type`],
/// you can transform the arguments of that `TypeEq` to cast any composition of those types,
/// e.g: cast between `Vec<Self>` and `Vec<Self::Type>`
/// 
/// # Example
/// 
/// ### Type Parameter Alias
/// 
/// (this example requires Rust 1.61.0, because it uses trait bounds in a `const fn`)
/// 
#[cfg_attr(not(feature = "rust_1_61"), doc = "```ignore")]
#[cfg_attr(feature = "rust_1_61", doc = "```rust")]
/// use typewit::{Identity, TypeEq};
/// 
/// assert_eq!(foo(3), [3, 3]);
/// 
/// assert_eq!(foo::<&str, 2, _>("hello"), ["hello", "hello"]);
///
///
/// const fn foo<T, const N: usize, R>(val: T) -> R
/// where
///     // emulates a `[T; N] == R` bound
///     [T; N]: Identity<Type = R>,
///     T: Copy,
/// {
///     Identity::TYPE_EQ // returns a `TypeEq<[T; N], R>`
///         .to_right([val; N]) // casts `[T; N]` to `R`
/// }
/// ```
/// 
/// ### Projection
/// 
/// Demonstrating that any projection of `Self` and `Self::Type` can 
/// be casted to each other.
/// 
/// ```rust
/// use typewit::{Identity, TypeEq, type_fn};
/// 
/// assert_eq!(make_vec::<u8>(), vec![3, 5, 8]);
/// 
/// fn make_vec<T>() -> Vec<T> 
/// where
///     T: Identity<Type = u8>
/// {
///     let te: TypeEq<Vec<T>, Vec<u8>> = T::TYPE_EQ.project::<VecFn>();
///     
///     te.to_left(vec![3, 5, 8]) // casts `Vec<u8>` to `Vec<T>`
/// }
/// 
/// type_fn!{
///     // A type-level function (TypeFn implementor) from `T` to `Vec<T>`
///     struct VecFn;
///     impl<T> T => Vec<T>
/// }
/// ```
/// 
pub trait Identity {
    /// The same type as `Self`,
    /// used to emulate type equality bounds (`T == U`)
    /// with associated type equality constraints
    /// (`T: Identity<Type = U>`).
    type Type: ?Sized;
    
    /// Proof that `Self` is the same type as `Self::Type`,
    /// provides methods for casting between `Self` and `Self::Type`.
    const TYPE_EQ: TypeEq<Self, Self::Type>;
}

impl<T: ?Sized> Identity for T {
    type Type = T;

    const TYPE_EQ: TypeEq<Self, Self::Type> = TypeEq::NEW;
}