mm1-sup 0.7.23

An Erlang-style actor runtime for Rust.
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

use std::sync::Arc;

use crate::common::factory::ActorFactory;
use crate::mixed::{ChildType, ErasedActorFactory, MixedSup};
type ChildSpec<F> = crate::common::child_spec::ChildSpec<F, ChildType>;

pub trait Append<K, F> {
    type Out;
    fn append(self, key: K, child_spec: ChildSpec<F>) -> Self::Out;
}

pub trait CollectInto<K, R> {
    fn collect_into(self, into: &mut impl Extend<(K, ChildSpec<ErasedActorFactory<R>>)>);
}

pub struct KV<K, R> {
    key:        K,
    child_spec: ChildSpec<ErasedActorFactory<R>>,
}

impl<K, F, T> Append<K, F> for T
where
    F: ActorFactory<Args = ()>,
{
    type Out = (Self, KV<K, F::Runnable>);

    fn append(self, key: K, child_spec: ChildSpec<F>) -> Self::Out {
        let child_spec = child_spec.map_launcher::<ErasedActorFactory<_>, _>(|f| Arc::pin(f));
        (self, KV { key, child_spec })
    }
}

impl<K, R> CollectInto<K, R> for () {
    fn collect_into(self, _into: &mut impl Extend<(K, ChildSpec<ErasedActorFactory<R>>)>) {}
}
impl<K, R> CollectInto<K, R> for KV<K, R> {
    fn collect_into(self, into: &mut impl Extend<(K, ChildSpec<ErasedActorFactory<R>>)>) {
        let Self { key, child_spec } = self;
        into.extend([(key, child_spec)]);
    }
}
impl<K, R, Le, Ri> CollectInto<K, R> for (Le, Ri)
where
    Le: CollectInto<K, R>,
    Ri: CollectInto<K, R>,
{
    fn collect_into(self, into: &mut impl Extend<(K, ChildSpec<ErasedActorFactory<R>>)>) {
        let (le, ri) = self;
        le.collect_into(into);
        ri.collect_into(into);
    }
}

impl<RS, C> MixedSup<RS, C> {
    pub fn with_child<K, F>(
        self,
        key: K,
        child_spec: ChildSpec<F>,
    ) -> MixedSup<RS, <C as Append<K, F>>::Out>
    where
        C: Append<K, F>,
    {
        let Self {
            restart_strategy,
            children,
        } = self;
        let children = children.append(key, child_spec);
        MixedSup {
            restart_strategy,
            children,
        }
    }
}

impl<RS, C> Clone for MixedSup<RS, C>
where
    RS: Clone,
    C: Clone,
{
    fn clone(&self) -> Self {
        Self {
            restart_strategy: self.restart_strategy.clone(),
            children:         self.children.clone(),
        }
    }
}