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

//! Convenience types and macros for capability sets
//!
//! Provides type aliases and macros for easier capability set construction.

use super::node::Empty;
use super::insert::With;

// =============================================================================
// Convenience Type Aliases
// =============================================================================

/// Empty capability set
pub type CapSet0 = Empty;

/// Capability set with 1 capability
pub type CapSet1<A> = <Empty as With<A>>::Out;

/// Capability set with 2 capabilities
pub type CapSet2<A, B> = <<Empty as With<A>>::Out as With<B>>::Out;

/// Capability set with 3 capabilities
pub type CapSet3<A, B, C> = <<<Empty as With<A>>::Out as With<B>>::Out as With<C>>::Out;

/// Capability set with 4 capabilities
pub type CapSet4<A, B, C, D> = <<<<Empty as With<A>>::Out as With<B>>::Out as With<C>>::Out as With<D>>::Out;

// =============================================================================
// Convenience Macros
// =============================================================================

// Note: hlist!, all!, any! are defined in evaluate.rs

/// Macro to build a CapSet from multiple capabilities
/// Usage: `capset![CapA, CapB, CapC]`
#[macro_export]
macro_rules! capset {
    () => { $crate::trie::Empty };
    ($cap:ty) => {
        <$crate::trie::Empty as $crate::trie::With<$cap>>::Out
    };
    ($cap:ty, $($rest:ty),+ $(,)?) => {
        <$crate::capset![$($rest),+] as $crate::trie::With<$cap>>::Out
    };
}

/// Macro to compute union of two capability sets
/// Usage: `union![SetA, SetB]`
#[macro_export]
macro_rules! union {
    ($a:ty, $b:ty) => {
        <$a as $crate::trie::SetUnion<$b>>::Out
    };
}

/// Macro to compute intersection of two capability sets
/// Usage: `intersect![SetA, SetB]`
#[macro_export]
macro_rules! intersect {
    ($a:ty, $b:ty) => {
        <$a as $crate::trie::SetIntersect<$b>>::Out
    };
}

/// Macro to add a capability to a set
/// Usage:
/// - `with![Set, Cap]` -> Single add
/// - `with![Set, A, B]` -> Chain add (A then B)
/// - `with![Cap]` -> Implicit `__C`
#[macro_export]
macro_rules! with {
    ($cap:ty) => {
        <__C as $crate::trie::With<$cap>>::Out
    };
    ($set:ty, $cap:ty) => {
        <$set as $crate::trie::With<$cap>>::Out
    };
    ($set:ty, $cap:ty, $($rest:ty),+) => {
        $crate::with![ $crate::with![$set, $cap], $($rest),+ ]
    };
}

/// Macro to remove a capability from a set
/// Usage:
/// - `without![Set, Cap]` -> Remove Cap from Set
/// - `without![Set, A, B]` -> Remove A then B
/// - `without![Cap]` -> Remove Cap from implicit `__C`
#[macro_export]
macro_rules! without {
    ($cap:ty) => {
        <__C as $crate::trie::Without<$cap>>::Out
    };
    ($set:ty, $cap:ty) => {
        <$set as $crate::trie::Without<$cap>>::Out
    };
    ($set:ty, $cap:ty, $($rest:ty),+) => {
        $crate::without![ $crate::without![$set, $cap], $($rest),+ ]
    };
}