rearch 0.10.2

Re-imagined approach to application design and architecture
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

use std::{any::Any, cell::OnceCell};

use crate::{
    CData, SideEffect, SideEffectStateMutationRunner, SideEffectTxnRunner, EFFECT_FAILED_CAST_MSG,
};

/// Registers the given side effect and returns its build api.
/// You can only call register once on purpose (it consumes self);
/// to register multiple side effects, simply pass them in together!
pub struct SideEffectRegistrar<'a> {
    side_effect: &'a mut OnceCell<Box<dyn Any + Send>>,
    side_effect_state_mutation_runner: SideEffectStateMutationRunner,
    side_effect_txn_runner: SideEffectTxnRunner,
}

impl<'a> SideEffectRegistrar<'a> {
    /// Creates a new `SideEffectRegistrar`.
    ///
    /// This is public only to enable easier mocking in your code,
    /// or for other libraries looking to deeply integrate;
    /// do not use this method in other contexts.
    pub fn new(
        side_effect: &'a mut OnceCell<Box<dyn Any + Send>>,
        side_effect_state_mutation_runner: SideEffectStateMutationRunner,
        side_effect_txn_runner: SideEffectTxnRunner,
    ) -> Self {
        Self {
            side_effect,
            side_effect_state_mutation_runner,
            side_effect_txn_runner,
        }
    }

    /// Registers the given side effect.
    pub fn register<S: SideEffect>(self, effect: S) -> S::Api<'a> {
        effect.build(self)
    }
}

impl<'a> SideEffectRegistrar<'a> {
    /// The basic building block for all side effects.
    #[allow(clippy::missing_panics_doc)] // false positive
    pub fn raw<T>(
        self,
        initial: T,
    ) -> (
        &'a mut T,
        impl CData + for<'f> Fn(Box<dyn 'f + FnOnce(&mut T)>),
        SideEffectTxnRunner,
    )
    where
        T: Send + 'static,
    {
        self.side_effect.get_or_init(|| Box::new(initial));
        let data = self
            .side_effect
            .get_mut()
            .expect("Side effect should've been initialized in get_or_init above")
            .downcast_mut::<T>()
            .unwrap_or_else(|| panic!("{}", EFFECT_FAILED_CAST_MSG));

        let mutation_runner = move |mutation: Box<dyn '_ + FnOnce(&mut T)>| {
            (self.side_effect_state_mutation_runner)(Box::new(|data| {
                let data = data
                    .downcast_mut::<T>()
                    .unwrap_or_else(|| panic!("{}", EFFECT_FAILED_CAST_MSG));
                mutation(data);
            }));
        };

        (data, mutation_runner, self.side_effect_txn_runner)
    }
}

// One arg register needs its own impl because tuples with one effect don't impl SideEffect
#[cfg(feature = "experimental-api")]
impl<'a, S: SideEffect> FnOnce<(S,)> for SideEffectRegistrar<'a> {
    type Output = S::Api<'a>;
    extern "rust-call" fn call_once(self, (effect,): (S,)) -> Self::Output {
        self.register(effect)
    }
}
macro_rules! generate_side_effect_registrar_fn_impl {
    ($($types:ident),*) => {
        #[allow(unused_parens, non_snake_case)]
        #[cfg(feature = "experimental-api")]
        impl<'a, $($types: SideEffect),*> FnOnce<($($types,)*)> for SideEffectRegistrar<'a> {
            type Output = ($($types::Api<'a>),*);
            extern "rust-call" fn call_once(self, args: ($($types),*)) -> Self::Output {
                self.register(args)
            }
        }
    }
}
generate_side_effect_registrar_fn_impl!();
generate_side_effect_registrar_fn_impl!(A, B);
generate_side_effect_registrar_fn_impl!(A, B, C);
generate_side_effect_registrar_fn_impl!(A, B, C, D);
generate_side_effect_registrar_fn_impl!(A, B, C, D, E);
generate_side_effect_registrar_fn_impl!(A, B, C, D, E, F);
generate_side_effect_registrar_fn_impl!(A, B, C, D, E, F, G);
generate_side_effect_registrar_fn_impl!(A, B, C, D, E, F, G, H);