Introduces Memo

and `Signal` constructs to handle reactive patterns and dependency
tracking. Simplified macro implementations to utilize the new caching
mechanism.

Author: fxdmhtt

cache/src/cache.rs

@@ -1,33 +1,35 @@
 use lru::LruCache;
 use std::{any::Any, num::NonZeroUsize, rc::Rc};
 
-use crate::OperatorFunc;
+use crate::Observable;
+
+type CacheKey = *const dyn Observable;
 
 const CACHE_CAP: usize = 128;
 
-static mut CACHE: Option<LruCache<OperatorFunc, Rc<dyn Any>>> = None;
+static mut CACHE: Option<LruCache<CacheKey, Rc<dyn Any>>> = None;
 
-fn cache() -> &'static mut LruCache<OperatorFunc, Rc<dyn Any>> {
+fn cache() -> &'static mut LruCache<CacheKey, Rc<dyn Any>> {
     #[allow(static_mut_refs)]
     unsafe {
         CACHE.get_or_insert_with(|| LruCache::new(NonZeroUsize::new(CACHE_CAP).unwrap()))
     }
 }
 
-pub fn touch<T: 'static>(key: OperatorFunc) -> Option<Rc<T>> {
+pub fn touch<T: 'static>(key: &'static dyn Observable) -> Option<Rc<T>> {
     cache()
-        .get(&key)
+        .get(&(key as _))
         .map(Rc::clone)
         .filter(|rc| rc.is::<T>())
         .map(|rc| unsafe { Rc::from_raw(Rc::into_raw(rc) as *const T) })
 }
 
-pub fn store_in_cache<T: 'static>(key: OperatorFunc, val: T) -> Rc<T> {
+pub fn store_in_cache<T: 'static>(key: &'static dyn Observable, val: T) -> Rc<T> {
     let rc = Rc::new(val);
     cache().put(key, Rc::clone(&rc) as _);
     rc
 }
 
-pub fn remove_from_cache(key: OperatorFunc) {
-    cache().pop(&key);
-}
+pub fn remove_from_cache(key: &'static dyn Observable) {
+    cache().pop(&(key as _));
+}

cache/src/call_stack.rs

@@ -1,22 +1,22 @@
-use crate::OperatorFunc;
+use crate::Observable;
 
-static mut CALL_STACK: Option<Vec<OperatorFunc>> = None;
+static mut CALL_STACK: Option<Vec<&'static dyn Observable>> = None;
 
-fn call_stack() -> &'static mut Vec<OperatorFunc> {
+fn call_stack() -> &'static mut Vec<&'static dyn Observable> {
     #[allow(static_mut_refs)]
     unsafe {
         CALL_STACK.get_or_insert_with(Vec::new)
     }
 }
 
-pub fn push(op: OperatorFunc) {
+pub fn push(op: &'static dyn Observable) {
     call_stack().push(op)
 }
 
-pub fn last() -> Option<&'static OperatorFunc> {
+pub fn last() -> Option<&'static &'static dyn Observable> {
     call_stack().last()
 }
 
-pub fn pop() -> Option<OperatorFunc> {
+pub fn pop() -> Option<&'static dyn Observable> {
     call_stack().pop()
-}
+}

cache/src/lib.rs

@@ -8,9 +8,15 @@ pub enum MemoOperator {
     Pop,
 }
 
-pub type OperatorFunc = fn(MemoOperator);
-
 pub mod cache;
 pub mod call_stack;
+pub mod memo;
+pub mod signal;
 
 pub use cache::{remove_from_cache, store_in_cache, touch};
+pub use memo::Memo;
+pub use signal::Signal;
+
+pub trait Observable {
+    fn invalidate(&'static self);
+}

cache/src/memo.rs

@@ -0,0 +1,54 @@
+use crate::{Observable, call_stack, remove_from_cache, store_in_cache, touch};
+
+pub struct Memo<T, F>
+where
+    T: Clone,
+    F: Fn() -> T,
+{
+    f: F,
+    dependents: Vec<&'static dyn Observable>,
+}
+
+impl<T, F> Observable for Memo<T, F>
+where
+    T: Clone,
+    F: Fn() -> T,
+{
+    fn invalidate(&'static self) {
+        remove_from_cache(self);
+        self.dependents
+            .iter()
+            .for_each(|dependent| dependent.invalidate());
+    }
+}
+
+impl<T, F> Memo<T, F>
+where
+    T: Clone,
+    F: Fn() -> T,
+{
+    pub fn new(f: F) -> Self {
+        Memo {
+            f,
+            dependents: vec![],
+        }
+    }
+
+    pub fn get(&'static mut self) -> T {
+        if let Some(last) = call_stack::last() {
+            self.dependents.push(*last);
+        }
+        call_stack::push(self);
+
+        let rc = if let Some(rc) = touch(self) {
+            rc
+        } else {
+            let result: T = (self.f)();
+            store_in_cache(self, result)
+        };
+
+        call_stack::pop();
+
+        (*rc).clone()
+    }
+}

cache/src/signal.rs

@@ -0,0 +1,61 @@
+use crate::{Observable, call_stack};
+
+pub struct Signal<T, F>
+where
+    T: Eq + Clone,
+    F: Fn() -> T,
+{
+    value: T,
+    f: F,
+    dependents: Vec<&'static dyn Observable>,
+}
+
+impl<T, F> Observable for Signal<T, F>
+where
+    T: Eq + Clone,
+    F: Fn() -> T,
+{
+    fn invalidate(&'static self) {
+        self.dependents
+            .iter()
+            .for_each(|dependent| dependent.invalidate());
+    }
+}
+
+impl<T, F> Signal<T, F>
+where
+    T: Eq + Clone,
+    F: Fn() -> T,
+{
+    pub fn new(f: F) -> Self {
+        let value = f();
+        Signal {
+            value,
+            f,
+            dependents: vec![],
+        }
+    }
+
+    pub fn get(&'static mut self) -> T {
+        if let Some(last) = call_stack::last() {
+            self.dependents.push(*last);
+        }
+
+        let result: T = (self.f)();
+        self.set(result.clone());
+
+        result
+    }
+
+    pub fn set(&'static mut self, value: T) -> bool {
+        if self.value == value {
+            return false;
+        }
+
+        self.value = value;
+
+        self.invalidate();
+
+        true
+    }
+}

macros/src/lib.rs

@@ -1,6 +1,6 @@
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
-use syn::{ItemFn, ReturnType, parse_macro_input, parse_quote};
+use syn::{ItemFn, ReturnType, parse_macro_input};
 
 #[proc_macro_attribute]
 pub fn memo(_attr: TokenStream, item: TokenStream) -> TokenStream {
@@ -29,53 +29,16 @@ pub fn memo(_attr: TokenStream, item: TokenStream) -> TokenStream {
         .into();
     }
 
-    let op_ident = format_ident!("{}_op", ident);
-    let mut op_sig = sig.clone();
-    op_sig.ident = op_ident.clone();
-    op_sig
-        .inputs
-        .insert(0, parse_quote! { op: cache::MemoOperator });
-    op_sig.output = parse_quote! { -> () };
+    let memo_ident = format_ident!("{}", ident.to_string().to_uppercase());
 
     let expanded = quote! {
+        static mut #memo_ident: Option<cache::Memo<#output_ty, fn() -> #output_ty>> = None;
+
         #vis #sig
         where #output_ty: Clone + 'static
         {
-            #op_ident(cache::MemoOperator::Memo(cache::Trace::Push));
-
-            let key: cache::OperatorFunc = #op_ident;
-            let rc = if let Some(rc) = cache::touch(key) {
-                rc
-            } else {
-                let result: #output_ty = (|| #block)();
-                cache::store_in_cache(key, result)
-            };
-
-            #op_ident(cache::MemoOperator::Memo(cache::Trace::Pop));
-
-            (*rc).clone()
-        }
-
-        #vis #op_sig
-        {
-            static mut dependents: Vec<cache::OperatorFunc> = Vec::new();
-            match op {
-                cache::MemoOperator::Memo(cache::Trace::Push) => {
-                    if let Some(last) = cache::call_stack::last() {
-                        unsafe { dependents.push(last.clone()) };
-                    }
-                    cache::call_stack::push(#op_ident);
-                },
-                cache::MemoOperator::Memo(cache::Trace::Pop) => {
-                    cache::call_stack::pop();
-                },
-                cache::MemoOperator::Pop => {
-                    for dependent in unsafe { dependents.iter() } {
-                        cache::remove_from_cache(*dependent);
-                        dependent(cache::MemoOperator::Pop);
-                    }
-                },
-            }
+            #[allow(static_mut_refs)]
+            unsafe { &mut #memo_ident }.get_or_insert_with(|| cache::Memo::new(|| #block)).get()
         }
     };
 

macros/tests/dep.rs

@@ -1,3 +1,4 @@
+use cache::Observable as _;
 use macros::memo;
 
 static mut SOURCE_A_CALLED: bool = false;
@@ -70,8 +71,10 @@ fn complex_dependency_memo_test() {
     assert_eq!(d2, d1);
     assert_eq!(e2, e1);
 
-    cache::remove_from_cache(source_a_op);
-    source_a_op(cache::MemoOperator::Pop);
+    #[allow(static_mut_refs)]
+    if let Some(memo) = unsafe { &SOURCE_A } {
+        memo.invalidate();
+    }
 
     unsafe { SOURCE_A_CALLED = false };
     unsafe { SOURCE_C_CALLED = false };