perf: version based tracking and link reuse

Author: brnrdog

packages/rescript-signals/src/signals/Core.res

@@ -6,51 +6,73 @@ let flag_dirty = 1
 let flag_pending = 2
 let flag_running = 4
 
+// Global tracking version
+let trackingVersion: ref<int> = ref(0)
+
 // Observer kind tag
 type kind = [#Effect | #Computed]
 
-// Forward declare mutually recursive types
-type rec link = {
-  // Direct reference to signal's subscriber list (type-erased)
-  mutable subs: subs,
-  // Direct reference to observer
-  mutable observer: observer,
-  // Links in the observer's dependency chain
-  mutable nextDep: option<link>,
-  mutable prevDep: option<link>,
-  // Links in the signal's subscriber chain
-  mutable nextSub: option<link>,
-  mutable prevSub: option<link>,
-}
+// Mutually recursive types using recursive modules
+module rec Link: {
+  type t = {
+    // Direct reference to signal's subscriber list (type-erased)
+    mutable subs: Subs.t,
+    // Direct reference to observer
+    mutable observer: Observer.t,
+    // Links in the observer's dependency chain
+    mutable nextDep: option<Link.t>,
+    mutable prevDep: option<Link.t>,
+    // Links in the signal's subscriber chain
+    mutable nextSub: option<Link.t>,
+    mutable prevSub: option<Link.t>,
+    // Version stamp for duplicate detection within a compute cycle
+    mutable lastTrackedVersion: int,
+  }
+} = Link
 
 // Signal subscriber list (head/tail of linked list)
 // For computeds, this same object also serves as the observer (combined structure)
-and subs = {
-  mutable first: option<link>,
-  mutable last: option<link>,
-  mutable version: int,
-  // === Observer fields (only used for computeds) ===
-  // If compute is Some, this subs is a computed signal
-  mutable compute: option<unit => unit>,
-  mutable firstDep: option<link>,
-  mutable lastDep: option<link>,
-  mutable flags: int,
-  mutable level: int,
-}
+and Subs: {
+  type t = {
+    mutable first: option<Link.t>,
+    mutable last: option<Link.t>,
+    mutable version: int,
+    // === Observer fields (only used for computeds) ===
+    // If compute is Some, this subs is a computed signal
+    mutable compute: option<unit => unit>,
+    mutable firstDep: option<Link.t>,
+    mutable lastDep: option<Link.t>,
+    mutable flags: int,
+    mutable level: int,
+    // Current tracking version for this compute cycle (for link reuse)
+    mutable currentTrackingVersion: int,
+    // Whether the last recompute changed the value (for equality short-circuit)
+    mutable valueChanged: bool,
+  }
+} = Subs
 
 // Observer for effects only (computeds use subs directly)
-and observer = {
-  id: int,
-  kind: kind,
-  run: unit => unit,
-  mutable firstDep: option<link>,
-  mutable lastDep: option<link>,
-  mutable flags: int,
-  mutable level: int,
-  name: option<string>,
-  // For computed observers: direct reference to backing subs (the combined object)
-  mutable backingSubs: option<subs>,
-}
+and Observer: {
+  type t = {
+    id: int,
+    kind: kind,
+    run: unit => unit,
+    mutable firstDep: option<Link.t>,
+    mutable lastDep: option<Link.t>,
+    mutable flags: int,
+    mutable level: int,
+    name: option<string>,
+    // For computed observers: direct reference to backing subs (the combined object)
+    mutable backingSubs: option<Subs.t>,
+    // Current tracking version for this run cycle (for link reuse)
+    mutable currentTrackingVersion: int,
+  }
+} = Observer
+
+// Type aliases for convenience
+type link = Link.t
+type subs = Subs.t
+type observer = Observer.t
 
 // Create empty subscriber list (for plain signals)
 let makeSubs = (): subs => {
@@ -62,6 +84,8 @@ let makeSubs = (): subs => {
   lastDep: None,
   flags: 0,
   level: 0,
+  currentTrackingVersion: 0,
+  valueChanged: true, // Plain signals always "changed"
 }
 
 // Create subs for a computed (with compute function)
@@ -74,6 +98,8 @@ let makeComputedSubs = (compute: unit => unit): subs => {
   lastDep: None,
   flags: flag_dirty, // start dirty
   level: 0,
+  currentTrackingVersion: 0,
+  valueChanged: true, // Start as changed for initial computation
 }
 
 // Create observer
@@ -93,9 +119,10 @@ let makeObserver = (
   level: 0,
   name,
   backingSubs,
+  currentTrackingVersion: 0,
 }
 
-// Flag operations for observer (using Int.Bitwise module)
+// Flag operations for observer
 let isDirty = (o: observer): bool => Int.bitwiseAnd(o.flags, flag_dirty) !== 0
 let setDirty = (o: observer): unit => o.flags = Int.bitwiseOr(o.flags, flag_dirty)
 let clearDirty = (o: observer): unit =>
@@ -105,7 +132,7 @@ let setPending = (o: observer): unit => o.flags = Int.bitwiseOr(o.flags, flag_pe
 let clearPending = (o: observer): unit =>
   o.flags = Int.bitwiseAnd(o.flags, Int.bitwiseNot(flag_pending))
 
-// Flag operations for subs (for computeds - subs IS the observer)
+// Flag operations for subs
 let isSubsDirty = (s: subs): bool => Int.bitwiseAnd(s.flags, flag_dirty) !== 0
 let setSubsDirty = (s: subs): unit => s.flags = Int.bitwiseOr(s.flags, flag_dirty)
 let clearSubsDirty = (s: subs): unit =>
@@ -115,7 +142,7 @@ let setSubsPending = (s: subs): unit => s.flags = Int.bitwiseOr(s.flags, flag_pe
 let clearSubsPending = (s: subs): unit =>
   s.flags = Int.bitwiseAnd(s.flags, Int.bitwiseNot(flag_pending))
 
-// Check if subs is a computed (has compute function)
+// Check if subs is a computed
 let isComputed = (s: subs): bool => s.compute !== None
 
 // Create a link node
@@ -126,6 +153,7 @@ let makeLink = (subs: subs, observer: observer): link => {
   prevDep: None,
   nextSub: None,
   prevSub: None,
+  lastTrackedVersion: 0,
 }
 
 // Add link to signal's subscriber list
@@ -179,6 +207,20 @@ let unlinkFromDeps = (observer: observer, link: link): unit => {
   link.nextDep = None
 }
 
+// Remove link from subs's dependency list (for computeds - subs IS the observer)
+let unlinkFromSubsDeps = (s: subs, link: link): unit => {
+  switch link.prevDep {
+  | Some(prev) => prev.nextDep = link.nextDep
+  | None => s.firstDep = link.nextDep
+  }
+  switch link.nextDep {
+  | Some(next) => next.prevDep = link.prevDep
+  | None => s.lastDep = link.prevDep
+  }
+  link.prevDep = None
+  link.nextDep = None
+}
+
 // Clear all dependencies from observer (unlinks from all signals)
 let clearDeps = (observer: observer): unit => {
   let link = ref(observer.firstDep)