freya_core/lifecycle/
memo.rs

1use std::{
2    mem::MaybeUninit,
3    ops::Deref,
4};
5
6use crate::{
7    lifecycle::writable_utils::WritableUtils,
8    prelude::{
9        ReadRef,
10        State,
11        spawn,
12        use_hook,
13    },
14    reactive_context::ReactiveContext,
15};
16
17/// Registers a callback that will run every time a [State] which was [.read()](State::read) inside, changes.
18/// It also returning a type that will get cached after the callback runs, thus allowing this to be used as a way to cache expensive values.
19/// ```rust, no_run
20/// # use freya::prelude::*;
21/// let state = use_state(|| 0);
22///
23/// let expensive_value = use_memo(move || {
24///     // The moment `.read()` is called this side effect callback gets subscribed to it
25///     let value = *state.read();
26///     value * 2
27/// });
28/// ```
29pub fn use_memo<T: 'static + PartialEq>(callback: impl FnMut() -> T + 'static) -> Memo<T> {
30    use_hook(|| Memo::create(callback))
31}
32
33pub struct Memo<T> {
34    pub(crate) state: State<T>,
35}
36
37impl<T: 'static> PartialEq for Memo<T> {
38    fn eq(&self, other: &Self) -> bool {
39        self.state == other.state
40    }
41}
42
43impl<T: 'static> Eq for Memo<T> {}
44
45impl<T> Clone for Memo<T> {
46    fn clone(&self) -> Self {
47        *self
48    }
49}
50impl<T> Copy for Memo<T> {}
51
52/// Allow calling the states as functions.
53/// Limited to `Copy` values only.
54impl<T: Copy + PartialEq + 'static> Deref for Memo<T> {
55    type Target = dyn Fn() -> T;
56
57    fn deref(&self) -> &Self::Target {
58        unsafe { Memo::deref_impl(self) }
59    }
60}
61
62impl<T: PartialEq> Memo<T> {
63    /// Adapted from https://github.com/DioxusLabs/dioxus/blob/a4aef33369894cd6872283d6d7d265303ae63913/packages/signals/src/read.rs#L246
64    /// SAFETY: You must call this function directly with `self` as the argument.
65    /// This function relies on the size of the object you return from the deref
66    /// being the same as the object you pass in
67    #[doc(hidden)]
68    unsafe fn deref_impl<'a>(memo: &Memo<T>) -> &'a dyn Fn() -> T
69    where
70        Self: Sized + 'a,
71        T: Clone + 'static,
72    {
73        // https://github.com/dtolnay/case-studies/tree/master/callable-types
74
75        // First we create a closure that captures something with the Same in memory layout as Self (MaybeUninit<Self>).
76        let uninit_callable = MaybeUninit::<Self>::uninit();
77        // Then move that value into the closure. We assume that the closure now has a in memory layout of Self.
78        let uninit_closure = move || Memo::read(unsafe { &*uninit_callable.as_ptr() }).clone();
79
80        // Check that the size of the closure is the same as the size of Self in case the compiler changed the layout of the closure.
81        let size_of_closure = std::mem::size_of_val(&uninit_closure);
82        assert_eq!(size_of_closure, std::mem::size_of::<Self>());
83
84        // Then cast the lifetime of the closure to the lifetime of &self.
85        fn cast_lifetime<'a, T>(_a: &T, b: &'a T) -> &'a T {
86            b
87        }
88        let reference_to_closure = cast_lifetime(
89            {
90                // The real closure that we will never use.
91                &uninit_closure
92            },
93            #[allow(clippy::missing_transmute_annotations)]
94            // We transmute self into a reference to the closure. This is safe because we know that the closure has the same memory layout as Self so &Closure == &Self.
95            unsafe {
96                std::mem::transmute(memo)
97            },
98        );
99
100        // Cast the closure to a trait object.
101        reference_to_closure as &_
102    }
103}
104
105impl<T: 'static + PartialEq> Memo<T> {
106    pub fn create(mut callback: impl FnMut() -> T + 'static) -> Memo<T> {
107        let (rx, rc) = ReactiveContext::new_for_task();
108        let mut state = State::create(ReactiveContext::run(rc.clone(), &mut callback));
109        spawn(async move {
110            loop {
111                rx.notified().await;
112                state.set_if_modified(ReactiveContext::run(rc.clone(), &mut callback));
113            }
114        });
115        Memo { state }
116    }
117
118    #[track_caller]
119    pub fn read(&self) -> ReadRef<'static, T> {
120        self.state.read()
121    }
122
123    #[track_caller]
124    pub fn peek(&self) -> ReadRef<'static, T> {
125        self.state.peek()
126    }
127}
freya_core/lifecycle/memo.rs

freya_core/lifecycle/
memo.rs
