Add experimental new memoizers: autotrack, weakmap, and signalis

Author: markerikson

.github/workflows/build-and-test-types.yml

@@ -37,6 +37,13 @@ jobs:
       - name: Run linter
         run: yarn lint
 
+      # Note: This shouldn't be necessary here, but Yarn 3
+      # is creating a symlink from RTK's `node_modules/reselect/`
+      # back to the root, and that fails because we haven't built yet.
+      # So, built here and then try testing.
+      - name: Build package
+        run: yarn build
+
       - name: Run tests
         run: yarn test
 

src/autotrackMemoize/autotrackMemoize.ts

@@ -0,0 +1,56 @@
+import { createNode, updateNode } from './proxy'
+import { Node } from './tracking'
+
+import { createCache } from './autotracking'
+import {
+  createCacheKeyComparator,
+  defaultEqualityCheck
+} from '@internal/defaultMemoize'
+
+export function autotrackMemoize<F extends (...args: any[]) => any>(func: F) {
+  // we reference arguments instead of spreading them for performance reasons
+
+  // console.log('Creating autotrack memoizer node')
+  const node: Node<Record<string, unknown>> = createNode(
+    [] as unknown as Record<string, unknown>
+  )
+
+  let lastArgs: IArguments | null = null
+
+  const shallowEqual = createCacheKeyComparator(defaultEqualityCheck)
+
+  // console.log('Creating cache')
+  const cache = createCache(() => {
+    // console.log('Executing cache: ', node.value)
+    const res = func.apply(null, node.proxy as unknown as any[])
+    // console.log('Res: ', res)
+    return res
+  })
+
+  // console.log('Creating memoized function')
+  function memoized() {
+    // console.log('Memoized running')
+    if (!shallowEqual(lastArgs, arguments)) {
+      // console.log(
+      //   'Args are different: lastArgs =',
+      //   lastArgs,
+      //   'newArgs =',
+      //   arguments
+      // )
+      updateNode(node, arguments as unknown as Record<string, unknown>)
+      lastArgs = arguments
+    } else {
+      // console.log('Same args: ', lastArgs, arguments)
+    }
+    // const start = performance.now()
+    // console.log('Calling memoized: ', arguments)
+
+    // const end = performance.now()
+    // console.log('Memoized execution time: ', end - start)
+    return cache.value
+  }
+
+  memoized.clearCache = () => cache.clear()
+
+  return memoized as F & { clearCache: () => void }
+}

src/autotrackMemoize/autotracking.ts

@@ -0,0 +1,179 @@
+import { assert } from './utils'
+
+// The global revision clock. Every time state changes, the clock increments.
+export let $REVISION = 0
+
+// The current dependency tracker. Whenever we compute a cache, we create a Set
+// to track any dependencies that are used while computing. If no cache is
+// computing, then the tracker is null.
+let CURRENT_TRACKER: Set<Cell<any> | TrackingCache> | null = null
+
+type EqualityFn = (a: any, b: any) => boolean
+
+// Storage represents a root value in the system - the actual state of our app.
+export class Cell<T> {
+  revision = $REVISION
+
+  _value: T
+  _lastValue: T
+  _isEqual: EqualityFn = tripleEq
+
+  constructor(initialValue: T, isEqual: EqualityFn = tripleEq) {
+    // console.log('Constructing cell: ', initialValue)
+    this._value = this._lastValue = initialValue
+    this._isEqual = isEqual
+  }
+
+  // Whenever a storage value is read, it'll add itself to the current tracker if
+  // one exists, entangling its state with that cache.
+  get value() {
+    // console.log('Getting cell value: ', this._value)
+    CURRENT_TRACKER?.add(this)
+
+    return this._value
+  }
+
+  // Whenever a storage value is updated, we bump the global revision clock,
+  // assign the revision for this storage to the new value, _and_ we schedule a
+  // rerender. This is important, and it's what makes autotracking  _pull_
+  // based. We don't actively tell the caches which depend on the storage that
+  // anything has happened. Instead, we recompute the caches when needed.
+  set value(newValue) {
+    // console.log('Setting value: ', this.value, newValue)
+    // if (this.value === newValue) return
+
+    this._value = newValue
+    this.revision = ++$REVISION
+    // scheduleRerender()
+  }
+}
+
+function tripleEq(a: unknown, b: unknown) {
+  return a === b
+}
+
+// Caches represent derived state in the system. They are ultimately functions
+// that are memoized based on what state they use to produce their output,
+// meaning they will only rerun IFF a storage value that could affect the output
+// has changed. Otherwise, they'll return the cached value.
+export class TrackingCache {
+  _cachedValue: any
+  _cachedRevision = -1
+  _deps: any[] = []
+  hits = 0
+
+  fn: () => any
+
+  constructor(fn: () => any) {
+    this.fn = fn
+  }
+
+  clear() {
+    this._cachedValue = undefined
+    this._cachedRevision = -1
+    this._deps = []
+    this.hits = 0
+  }
+
+  get value() {
+    // When getting the value for a Cache, first we check all the dependencies of
+    // the cache to see what their current revision is. If the current revision is
+    // greater than the cached revision, then something has changed.
+    if (this.revision > this._cachedRevision) {
+      const { fn } = this
+
+      // We create a new dependency tracker for this cache. As the cache runs
+      // its function, any Storage or Cache instances which are used while
+      // computing will be added to this tracker. In the end, it will be the
+      // full list of dependencies that this Cache depends on.
+      const currentTracker = new Set<Cell<any>>()
+      const prevTracker = CURRENT_TRACKER
+
+      CURRENT_TRACKER = currentTracker
+
+      // try {
+      this._cachedValue = fn()
+      // } finally {
+      CURRENT_TRACKER = prevTracker
+      this.hits++
+      this._deps = Array.from(currentTracker)
+
+      // Set the cached revision. This is the current clock count of all the
+      // dependencies. If any dependency changes, this number will be less
+      // than the new revision.
+      this._cachedRevision = this.revision
+      // }
+    }
+
+    // If there is a current tracker, it means another Cache is computing and
+    // using this one, so we add this one to the tracker.
+    CURRENT_TRACKER?.add(this)
+
+    // Always return the cached value.
+    return this._cachedValue
+  }
+
+  get revision() {
+    // The current revision is the max of all the dependencies' revisions.
+    return Math.max(...this._deps.map(d => d.revision), 0)
+  }
+}
+
+export function getValue<T>(cell: Cell<T>): T {
+  // console.trace('Cell: ', cell)
+  if (!(cell instanceof Cell)) {
+    console.warn('Not a valid cell! ', cell)
+  }
+  // assert(
+  //   cell instanceof Cell,
+  //   'getValue must be passed a tracked store created with `createStorage`.'
+  // )
+
+  // console.log('Storage value: ', cell.value)
+
+  return cell.value
+}
+
+type CellValue<T extends Cell<unknown>> = T extends Cell<infer U> ? U : never
+
+export function setValue<T extends Cell<unknown>>(
+  storage: T,
+  value: CellValue<T>
+): void {
+  assert(
+    storage instanceof Cell,
+    'setValue must be passed a tracked store created with `createStorage`.'
+  )
+
+  // console.log('setValue: ', storage, value)
+
+  // console.log('Setting value: ', storage.value, value)
+  // storage.value = value
+
+  const { _isEqual: isEqual, _lastValue: lastValue } = storage
+
+  // if (!isEqual(value, lastValue)) {
+  storage.value = storage._lastValue = value
+  // }
+}
+
+export function createCell<T = unknown>(
+  initialValue: T,
+  isEqual: EqualityFn = tripleEq
+): Cell<T> {
+  // assert(
+  //   typeof isEqual === 'function',
+  //   'the second parameter to `createStorage` must be an equality function or undefined'
+  // )
+
+  return new Cell(initialValue, isEqual)
+}
+
+export function createCache<T = unknown>(fn: () => T): TrackingCache {
+  assert(
+    typeof fn === 'function',
+    'the first parameter to `createCache` must be a function'
+  )
+
+  return new TrackingCache(fn)
+}