bombay-rs 0.1.0

A pluggable process runtime over Bombay Behavior.
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

//! Runtime construction of children emitted by behavior transitions.

use core::future::Future;

use behavior::{Address, BirthMode, Births, Create, Never, NoBirths};

pub(crate) trait SealedChildRuntime {}
pub(crate) trait SealedBirthMode {}

impl SealedBirthMode for NoBirths {}
impl<C> SealedBirthMode for Births<C> {}

/// Constructs one child generation and returns its affine ownership lease.
#[allow(
    private_bounds,
    reason = "sealing supertrait is deliberately crate-private"
)]
#[doc(hidden)]
pub trait ChildRuntime<A: Address, B, S>: SealedChildRuntime {
    /// Fully typed ownership retained by the parent generation.
    type Lease: super::CoordinatedChild;
    /// Creation failure.
    type Error;

    /// Birth `child` beneath `parent` at the emitted nonce.
    fn birth(
        &self,
        parent: A,
        child: Create<A, B>,
        response: S,
    ) -> impl Future<Output = Result<Self::Lease, Self::Error>> + Send;
}

/// Runtime used when the behavior's birth type is uninhabited.
#[derive(Debug, Clone, Copy)]
#[doc(hidden)]
pub struct NoChildren(());

impl SealedChildRuntime for NoChildren {}

impl NoChildren {
    pub(crate) const fn new() -> Self {
        Self(())
    }
}

impl<A, S> ChildRuntime<A, Never, S> for NoChildren
where
    A: Address + Send,
    A::Nonce: Send,
    S: Send,
{
    type Lease = Never;
    type Error = Never;

    async fn birth(
        &self,
        _parent: A,
        child: Create<A, Never>,
        _response: S,
    ) -> Result<Self::Lease, Self::Error> {
        match child.child {}
    }
}

/// Derives a generation-local child runtime from a behavior's birth mode.
#[allow(
    private_bounds,
    reason = "sealed birth-mode supertrait is deliberately crate-private"
)]
#[doc(hidden)]
pub trait RuntimeBirthMode<A: Address, Y, S>: BirthMode + SealedBirthMode {
    /// Runtime constructed for one parent generation.
    type Runtime: ChildRuntime<A, Self::Child, S>;

    /// Construct an empty runtime for a new parent.
    fn runtime(system: Y) -> Self::Runtime;
}

impl<A, Y, S> RuntimeBirthMode<A, Y, S> for NoBirths
where
    A: Address + Send,
    A::Nonce: Send,
    S: Send,
{
    type Runtime = NoChildren;

    fn runtime(_system: Y) -> Self::Runtime {
        NoChildren::new()
    }
}

/// System-backed child runtime derived for `Births<C>`.
#[doc(hidden)]
pub struct SystemChildren<Y> {
    pub(crate) system: Y,
}

impl<Y> SealedChildRuntime for SystemChildren<Y> {}

impl<A: Address, Y, C, S> RuntimeBirthMode<A, Y, S> for Births<C>
where
    SystemChildren<Y>: ChildRuntime<A, C, S>,
{
    type Runtime = SystemChildren<Y>;

    fn runtime(system: Y) -> Self::Runtime {
        SystemChildren { system }
    }
}

/// Failure while interpreting a behavior effect.
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[doc(hidden)]
pub enum RuntimeEffectError<C, D> {
    /// Child birth failed.
    #[error("child birth failed: {0:?}")]
    Birth(C),
    /// A behavior reused a child identity within one parent incarnation.
    #[error("a behavior reused a child identity within one parent incarnation")]
    DuplicateChild,
    /// Outbound delivery failed.
    #[error("outbound delivery failed: {0:?}")]
    Delivery(D),
}

/// Classifies a child-creation failure for same-action rejection delivery.
///
/// The interpreter keeps the exact typed error for unobserved creations; this
/// classification only selects the [`behavior::CreationRejection`] reported to
/// a behavior that staged an `ObserveCreation` for the failed nonce.
pub trait CreationFailure {
    /// The closed semantic classification of this creation failure.
    fn rejection(&self) -> behavior::CreationRejection;
}

impl CreationFailure for Never {
    fn rejection(&self) -> behavior::CreationRejection {
        match *self {}
    }
}