hooks 3.0.0-alpha.15

Compile-time, async hooks
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

pub use UseSignal as use_signal;

use std::pin::Pin;

use hooks_core::{Hook, HookPollNextUpdate, HookUnmount};

use crate::{ShareValue, ToOwnedShareValue};

mod sealed {
    use hooks_core::{HookValue, HookValueBounds};

    use crate::ShareValue;

    use super::Signal;

    pub trait HookValueImplSignal<'hook, ImplicitBounds: HookValueBounds<'hook, Self> = &'hook Self>:
        HookValue<'hook, ImplicitBounds, Value = Self::HookValueImplSignal>
    {
        type HookValueImplShareValueValue;
        type HookValueImplSignal: Signal<
            SignalHook = Self,
            Value = Self::HookValueImplShareValueValue,
        >;
    }

    impl<'hook, H: ?Sized> HookValueImplSignal<'hook> for H
    where
        H: HookValue<'hook>,
        H::Value: Signal<SignalHook = Self>,
    {
        type HookValueImplShareValueValue = <H::Value as ShareValue>::Value;
        type HookValueImplSignal = H::Value;
    }
}

/// `for<'hook> sealed::HookValueImplSignal<'hook>` here acts like [`for<'hook> HookValue<'hook, Value: Signal<SignalHook = Self, Value = Self::SignalShareValue>>`](crate::HookValue::Value).
pub trait SignalHook:
    Hook
    + Signal<Value = Self::SignalShareValue, SignalHook = Self>
    + for<'hook> sealed::HookValueImplSignal<
        'hook,
        HookValueImplShareValueValue = Self::SignalShareValue,
    >
{
    type SignalShareValue;

    type SignalHookUninitialized: HookPollNextUpdate + HookUnmount + Default;

    /// This is the opposite of [`Signal::to_signal_hook`].
    ///
    /// In contrast to [`Hook::use_hook`], this method just require a `&Self` instead of `Pin<&mut Self>`.
    /// In implementations, [`Hook::use_hook`] might mark the SignalHook's updated value as already read
    /// but this method should not.
    fn to_signal(&self) -> crate::Value<'_, Self>;
}

pub trait Signal: ShareValue {
    type SignalHook: SignalHook<SignalShareValue = Self::Value>;

    fn is_signal_of(&self, signal_hook: &Self::SignalHook) -> bool;

    /// This is the opposite of [`SignalHook::to_signal`].
    fn to_signal_hook(&self) -> Self::SignalHook;

    fn update_signal_hook(&self, hook: Pin<&mut Self::SignalHook>);
    fn h_signal_hook<'hook>(
        &self,
        hook: Pin<&'hook mut <Self::SignalHook as SignalHook>::SignalHookUninitialized>,
    ) -> crate::Value<'hook, Self::SignalHook>;

    fn use_signal(&self) -> UseSignal<'_, Self> {
        UseSignal(self)
    }

    fn notify_changed(&self);

    fn map_mut_and_notify_if<R>(&self, f: impl FnOnce(&mut Self::Value) -> (R, bool)) -> R;
}

impl<S: Signal + ?Sized> Signal for &S {
    type SignalHook = S::SignalHook;

    fn is_signal_of(&self, signal_hook: &Self::SignalHook) -> bool {
        S::is_signal_of(self, signal_hook)
    }
    fn to_signal_hook(&self) -> Self::SignalHook {
        S::to_signal_hook(self)
    }
    fn update_signal_hook(&self, hook: Pin<&mut Self::SignalHook>) {
        S::update_signal_hook(self, hook)
    }
    fn h_signal_hook<'hook>(
        &self,
        hook: ::core::pin::Pin<
            &'hook mut <Self::SignalHook as SignalHook>::SignalHookUninitialized,
        >,
    ) -> crate::Value<'hook, Self::SignalHook> {
        S::h_signal_hook(self, hook)
    }
    fn notify_changed(&self) {
        S::notify_changed(self)
    }
    fn map_mut_and_notify_if<R>(&self, f: impl FnOnce(&mut Self::Value) -> (R, bool)) -> R {
        S::map_mut_and_notify_if(self, f)
    }
}

pub struct UseSignal<'a, S: Signal + ?Sized>(&'a S);

hooks_core::impl_hook!(
    impl<S: Signal> UseSignal<'_, S> {
        fn into_hook(self) -> S::SignalHook {
            self.0.to_signal_hook()
        }

        fn update_hook(self, hook: _) {
            self.0.update_signal_hook(hook)
        }

        fn h(self, hook: <S::SignalHook as SignalHook>::SignalHookUninitialized) {
            self.0.h_signal_hook(hook)
        }
    }
);

pub trait ToOwnedSignal: Signal + ToOwnedShareValue<OwnedShareValue = Self::OwnedSignal> {
    type OwnedSignal: Signal<SignalHook = Self::SignalHook, Value = Self::Value>;
}

/// A trait alias for `Signal + ToOwnedShareValue<OwnedShareValue: Signal<SignalHook = Self::SignalHook, SignalHookUninitialized = Self::SignalHookUninitialized>>`
impl<T: ?Sized + ToOwnedShareValue> ToOwnedSignal for T
where
    T: Signal,
    T::OwnedShareValue: Signal<SignalHook = Self::SignalHook>,
{
    type OwnedSignal = T::OwnedShareValue;
}