tola-caps 0.2.0

Capability system enabling type-level state tracking, trait detection, and stable specialization.
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
121
122
123
124
125
126

//! Type-level boolean logic.
//!
//! Core types: `Present` (true), `Absent` (false), `Bool` trait.

use crate::spec::dispatch::StaticMethodImpl;

/// Type-level boolean.
pub trait Bool: 'static {
    const VALUE: bool;
    /// Type-level conditional: If<Then, Else> (General Type Selector)
    type If<Then, Else>;

    /// Type-level boolean conditional: Then<T, E> where T, E are Bool.
    /// Returns a type guaranteed to implement Bool.
    type Elif<Then: Bool, Else: Bool>: Bool;

    /// Logical AND
    type And<Other: Bool>: Bool;

    /// Logical OR
    type Or<Other: Bool>: Bool;

    /// Call a static method based on this boolean value.
    /// If true (Present), calls Then::call().
    /// If false (Absent), calls Else::call().
    fn static_dispatch<Then, Else, Output>() -> Output
    where
        Then: StaticMethodImpl<Output>,
        Else: StaticMethodImpl<Output>;
}

/// Type-level True.
#[derive(Debug)]
pub struct Present;

/// Type-level False.
#[derive(Debug)]
pub struct Absent;

impl Bool for Present {
    const VALUE: bool = true;
    type If<Then, Else> = Then;
    type Elif<Then: Bool, Else: Bool> = Then;

    type And<Other: Bool> = Other;
    type Or<Other: Bool> = Present;

    #[inline(always)]
    fn static_dispatch<Then, Else, Output>() -> Output
    where
        Then: StaticMethodImpl<Output>,
        Else: StaticMethodImpl<Output>,
    {
        Then::call()
    }
}

impl Bool for Absent {
    const VALUE: bool = false;
    type If<Then, Else> = Else;
    type Elif<Then: Bool, Else: Bool> = Else;

    type And<Other: Bool> = Absent;
    type Or<Other: Bool> = Other;

    #[inline(always)]
    fn static_dispatch<Then, Else, Output>() -> Output
    where
        Then: StaticMethodImpl<Output>,
        Else: StaticMethodImpl<Output>,
    {
        Else::call()
    }
}

// Deprecated separate traits (kept for compatibility if needed, or remove?)
// Let's alias them to the new associated types to minimize breakage
pub trait BoolAnd<Other: Bool>: Bool {
    type Out: Bool;
}
impl<A: Bool, B: Bool> BoolAnd<B> for A {
    type Out = A::And<B>;
}

pub trait BoolOr<Other: Bool>: Bool {
    type Out: Bool;
}
impl<A: Bool, B: Bool> BoolOr<B> for A {
    type Out = A::Or<B>;
}




/// Type-level NOT.
pub trait BoolNot: Bool {
    type Out: Bool;
}

impl BoolNot for Present {
    type Out = Absent;
}

impl BoolNot for Absent {
    type Out = Present;
}

/// Convert const bool to type-level Bool.
pub trait SelectBool<const B: bool> {
    type Out: Bool;
}

impl SelectBool<true> for () {
    type Out = Present;
}

impl SelectBool<false> for () {
    type Out = Absent;
}

/// Conditional Type Alias
pub type If<const C: bool, T, E> = <<() as SelectBool<C>>::Out as Bool>::If<T, E>;

/// Strict Conditional Type Alias (Result is Bool)
pub type Elif<const C: bool, T, E> = <<() as SelectBool<C>>::Out as Bool>::Elif<T, E>;