hibana 0.8.0

Const-projected Affine Multiparty Session Types for choreography-first Rust protocols
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Typed program representation built from const DSL combinators.
//!
//! `Program<Steps>` is the public choreography owner consumed by projection and
//! attach paths. The raw `EffList` source and cheap composition hints stay
//! crate-private behind type-level source builders.

mod projection;
pub(crate) mod source;

pub use projection::Projectable;

use crate::g::Program;

#[cfg(all(test, hibana_repo_tests))]
pub(crate) use source::boundary_source_program_image;

impl<const CONTROLLER: u8, const LOGICAL_LABEL: u8, const LANE: u8>
    Program<
        crate::g::Send<
            CONTROLLER,
            CONTROLLER,
            crate::g::Msg<
                LOGICAL_LABEL,
                (),
                crate::control::cap::resource_kinds::RouteDecisionKind,
            >,
            LANE,
        >,
    >
{
    pub const fn policy<const POLICY_ID: u16>(
        self,
    ) -> Program<
        crate::g::Policy<
            crate::g::Send<
                CONTROLLER,
                CONTROLLER,
                crate::g::Msg<
                    LOGICAL_LABEL,
                    (),
                    crate::control::cap::resource_kinds::RouteDecisionKind,
                >,
                LANE,
            >,
            POLICY_ID,
        >,
    > {
        if POLICY_ID == crate::global::ControlDesc::STATIC_POLICY_SITE {
            panic!("dynamic policy id u16::MAX is reserved for static policy");
        }
        let _ = self;
        Program::new()
    }
}

impl<const CONTROLLER: u8, const LOGICAL_LABEL: u8, const LANE: u8>
    Program<
        crate::g::Send<
            CONTROLLER,
            CONTROLLER,
            crate::g::Msg<LOGICAL_LABEL, (), crate::control::cap::resource_kinds::LoopContinueKind>,
            LANE,
        >,
    >
{
    pub const fn policy<const POLICY_ID: u16>(
        self,
    ) -> Program<
        crate::g::Policy<
            crate::g::Send<
                CONTROLLER,
                CONTROLLER,
                crate::g::Msg<
                    LOGICAL_LABEL,
                    (),
                    crate::control::cap::resource_kinds::LoopContinueKind,
                >,
                LANE,
            >,
            POLICY_ID,
        >,
    > {
        if POLICY_ID == crate::global::ControlDesc::STATIC_POLICY_SITE {
            panic!("dynamic policy id u16::MAX is reserved for static policy");
        }
        let _ = self;
        Program::new()
    }
}

impl<const CONTROLLER: u8, const LOGICAL_LABEL: u8, const LANE: u8>
    Program<
        crate::g::Send<
            CONTROLLER,
            CONTROLLER,
            crate::g::Msg<LOGICAL_LABEL, (), crate::control::cap::resource_kinds::LoopBreakKind>,
            LANE,
        >,
    >
{
    pub const fn policy<const POLICY_ID: u16>(
        self,
    ) -> Program<
        crate::g::Policy<
            crate::g::Send<
                CONTROLLER,
                CONTROLLER,
                crate::g::Msg<
                    LOGICAL_LABEL,
                    (),
                    crate::control::cap::resource_kinds::LoopBreakKind,
                >,
                LANE,
            >,
            POLICY_ID,
        >,
    > {
        if POLICY_ID == crate::global::ControlDesc::STATIC_POLICY_SITE {
            panic!("dynamic policy id u16::MAX is reserved for static policy");
        }
        let _ = self;
        Program::new()
    }
}

#[diagnostic::do_not_recommend]
impl<Steps> projection::seal::Sealed for Program<Steps>
where
    Steps: crate::g::ProgramTerm,
{
    #[inline(always)]
    fn project<const ROLE: u8>(&self) -> crate::global::role_program::RoleProgram<ROLE> {
        crate::g::project(self)
    }
}

#[inline(always)]
pub(crate) fn project_unnamed<const ROLE: u8, P>(
    program: &P,
) -> crate::global::role_program::RoleProgram<ROLE>
where
    P: projection::seal::Sealed + ?Sized,
{
    <P as projection::seal::Sealed>::project(program)
}