feat: Proxy pattern base api

Author: aureat

Cargo.lock

@@ -6,3 +6,4 @@ edition = "2021"
 [dependencies]
 lazy_static = "1.4.0"
 once_cell = "1.18.0"
+slotmap = "1.0"

patterns/Cargo.toml

@@ -1,4 +1,9 @@
+#![feature(fn_traits)]
+#![feature(type_alias_impl_trait)]
+
+#[allow(dead_code)]
+mod observer;
+#[allow(dead_code)]
 mod proxy;
-mod singleton;
 #[allow(dead_code)]
-mod observer;
+mod singleton;

patterns/src/lib.rs

@@ -52,7 +52,6 @@ impl<T> Clone for ListenerCell<T> {
     }
 }
 
-#[derive(Eq)]
 pub struct ListenerRef {
     weak: Weak<RefCell<dyn ListenerUpdate>>,
 }
@@ -84,6 +83,8 @@ impl ListenerRef {
     }
 }
 
+impl Eq for ListenerRef {}
+
 impl PartialEq for ListenerRef {
     fn eq(&self, other: &Self) -> bool {
         self.weak.ptr_eq(&other.weak)

patterns/src/observer/events.rs

@@ -0,0 +1,23 @@
+use crate::proxy::node::NodeId;
+use crate::proxy::runtime::RuntimeContext;
+use std::marker::PhantomData;
+
+pub struct Computed<T> {
+    id: NodeId,
+    ty: PhantomData<T>,
+}
+
+impl<T> Computed<T> {
+    pub(crate) fn new(id: NodeId) -> Self {
+        Self {
+            id,
+            ty: PhantomData,
+        }
+    }
+
+    pub fn get() -> T {}
+}
+
+pub fn computed<T>(f: impl Fn() -> T) -> Computed<T> {
+    RuntimeContext.create_computed(f)
+}

patterns/src/proxy/computed.rs

@@ -0,0 +1,7 @@
+use std::any::Any;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub(crate) trait AnyComputation {
+    fn run(&self, value: Rc<RefCell<dyn Any>>) -> bool;
+}

patterns/src/proxy/effect.rs

@@ -0,0 +1,60 @@
+use crate::proxy::effect::AnyComputation;
+use crate::proxy::node::NodeId;
+use std::any::Any;
+use std::cell::RefCell;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+
+pub(crate) type FnMemo<T> = impl Fn(&T) -> T;
+
+pub struct Memo<T> {
+    id: NodeId,
+    ty: PhantomData<T>,
+}
+
+impl<T> Memo<T> {
+    pub(crate) fn new(id: NodeId) -> Self {
+        Self {
+            id,
+            ty: PhantomData,
+        }
+    }
+
+    pub fn as_ref(&self) -> &T {
+        self.val.borrow().deref()
+    }
+}
+
+impl<T: Copy> Memo<T> {
+    pub fn get(&self) -> T {
+        self.val.borrow().to_owned()
+    }
+}
+
+pub struct MemoState<T> {
+    f: FnMemo<T>,
+    ty: PhantomData<T>,
+}
+
+impl<T> MemoState<T> {
+    pub(crate) fn new(f: FnMemo<T>) -> Self {
+        Self { f, ty: PhantomData }
+    }
+}
+
+impl<T> AnyComputation for MemoState<T> {
+    fn run(&self, value: Rc<RefCell<dyn Any>>) -> bool {
+        let (new_value, is_different) = {
+            let curr_value = value.borrow().downcast_ref::<Option<&T>>();
+            let new_value = (self.f)(curr_value.as_ref());
+            let is_different = curr_value.as_ref() != Some(&new_value);
+            (new_value, is_different)
+        };
+        if is_different {
+            let mut curr_value = value.borrow_mut().downcast_mut().unwrap();
+            *curr_value = Some(new_value);
+        }
+        is_different
+    }
+}

patterns/src/proxy/memo.rs

@@ -0,0 +1,57 @@
+//! This is an implementation of a proxy pattern heavily based on the `leptos_reactive` crate,
+//! Part of the `leptos` framework https://crates.io/crates/leptos.
+//!
+//! This implementation combines the proxy + singleton + observer patterns.
+//! For an implementation of the observer pattern, check out the `observer` module in this crate.
+//!
+//! Many UI frameworks have reactive values that appear in this module.
+//! It's a good way to see and understand how values can be proxied using their getters/setters
+//! and made reactive. For a good explanation of reactivity in Vue, check out:
+//! https://vuejs.org/guide/extras/reactivity-in-depth.html
+//!
+//! Also, check out the video by the creator of `leptos`:
+//! https://youtu.be/UrMHPrumJEs?si=S5LrQNGS-fnNL8WJ
+//!
+//! Crate Link: https://crates.io/crates/leptos_reactive
+//! Github Link: https://github.com/leptos-rs/leptos/blob/main/leptos_reactive
+
+mod effect;
+mod memo;
+mod node;
+mod reference;
+mod runtime;
+mod watch;
+mod computed;
+
+#[cfg(test)]
+mod tests {
+    use crate::proxy::reference::create_ref;
+
+    #[test]
+    fn ref_test() {
+        // create a ref
+        let number = reference(0);
+
+        // watch value change
+        let mut number_change_counter = 0;
+        number.watch(|curr, prev| number_change_counter += 1);
+
+        // memoized value also watches for change
+        let doubled = number.memoized(|x| (*x) * 2);
+        assert_eq!(number.get(), 0);
+
+        // create computed values with multiple dependencies
+        let counter = create_ref(0);
+        let computed = computed(|| number.get() * counter.get());
+
+        // update the value two times
+        value.set(1);
+        value.update(|x| *x = 2);
+
+        // at this point there should be two changes to `value`
+        assert_eq!(change_counter, 2);
+
+        // and doubled should be equal to 2
+        assert_eq!(doubled.get(), 4);
+    }
+}

patterns/src/proxy/mod.rs

@@ -0,0 +1,36 @@
+use crate::proxy::effect::AnyComputation;
+use crate::proxy::runtime::Runtime;
+use slotmap::new_key_type;
+use std::any::Any;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+new_key_type! {
+    pub struct NodeId;
+}
+
+pub(crate) enum ReactiveError {
+    Disposed,
+    BadCast,
+}
+
+impl NodeId {
+    pub fn try_with<T, U>(
+        &self,
+        runtime: &Runtime,
+        f: impl FnOnce(&T) -> U,
+    ) -> Result<U, ReactiveError> {
+    }
+}
+
+pub(crate) enum ReactiveNodeType {
+    Reference,
+    Memo { f: Rc<dyn AnyComputation> },
+    Computed { f: Rc<dyn AnyComputation> },
+    Effect { f: Rc<dyn AnyComputation> },
+}
+
+pub(crate) struct ReactiveNode {
+    pub value: Option<Rc<RefCell<dyn Any>>>,
+    pub node_type: ReactiveNodeType,
+}

patterns/src/proxy/node.rs

@@ -0,0 +1,53 @@
+use crate::proxy::memo::{FnMemo, Memo};
+use crate::proxy::node::NodeId;
+use crate::proxy::runtime::{with_runtime, Runtime, RuntimeContext};
+use std::any::Any;
+use std::cell::RefCell;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+
+pub(crate) type FnUpdate<T> = impl FnOnce(&mut T);
+
+pub(crate) type FnWatch<T> = impl Fn(&Option<T>);
+
+pub struct Reference<T> {
+    pub(crate) id: NodeId,
+    pub(crate) ty: PhantomData<T>,
+}
+
+impl<T> Reference<T> {
+    pub(crate) fn new(id: NodeId) -> Self {
+        Reference {
+            id,
+            ty: PhantomData,
+        }
+    }
+
+    pub fn update(&self, f: FnUpdate<T>) {}
+
+    pub fn watch(&self, f: FnWatch<T>) {}
+
+    pub fn memo(&self, f: FnMemo<T>) -> Memo<T> {
+        let memo = RuntimeContext.create_memo(f);
+        memo
+    }
+
+    pub fn as_ref(&self) -> &T {
+        self.val.borrow().deref()
+    }
+
+    pub(crate) fn try_with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O> {
+        with_runtime(|runtime| self.id.try_with(runtime, f))
+    }
+}
+
+impl<T: Copy> Reference<T> {
+    pub fn get(&self) -> T {
+        self.try_with()
+    }
+}
+
+pub fn reference<T>(value: T) -> Reference<T> {
+    RuntimeContext.create_ref(value)
+}

patterns/src/proxy/reference.rs

@@ -0,0 +1,57 @@
+use crate::proxy::memo::{FnMemo, Memo, MemoState};
+use crate::proxy::node::{NodeId, ReactiveNode, ReactiveNodeType};
+use crate::proxy::reference::Reference;
+use slotmap::{SecondaryMap, SlotMap};
+use std::cell::RefCell;
+use std::collections::HashSet;
+use std::rc::Rc;
+
+thread_local! {
+    pub(crate) static RUNTIME: Runtime = Runtime::new();
+}
+
+pub struct Runtime {
+    nodes: RefCell<SlotMap<NodeId, ReactiveNode>>,
+    node_subscribers: RefCell<SecondaryMap<NodeId, RefCell<HashSet<NodeId>>>>,
+}
+
+impl Runtime {
+    pub(crate) fn new() -> Self {
+        Self {
+            nodes: RefCell::new(SlotMap::default()),
+            node_subscribers: RefCell::new(SecondaryMap::default()),
+        }
+    }
+}
+
+pub(crate) fn with_runtime<T, F>(f: F) -> T
+where
+    F: FnOnce(&Runtime) -> T,
+{
+    RUNTIME.with(|runtime| f(runtime))
+}
+
+pub(crate) struct RuntimeContext;
+
+impl RuntimeContext {
+    pub(crate) fn create_ref<T>(self, value: T) -> Reference<T> {
+        let id = with_runtime(|runtime| {
+            runtime.nodes.borrow_mut().insert(ReactiveNode {
+                value: Some(value),
+                node_type: ReactiveNodeType::Ref,
+            })
+        });
+        Reference::new(id)
+    }
+
+    pub(crate) fn create_memo<T>(self, f: FnMemo<T>) -> Memo<T> {
+        let state = Rc::new(MemoState::new(f));
+        let id = with_runtime(|runtime| {
+            runtime.nodes.borrow_mut().insert(ReactiveNode {
+                value: Some(Rc::new(RefCell::new(None::<T>))),
+                node_type: ReactiveNodeType::Memo { f: state },
+            })
+        });
+        Memo::new(id)
+    }
+}

patterns/src/proxy/runtime.rs

@@ -0,0 +1 @@
+