Memorize and re-run a function when its arguments are changed. The output is passed to callback function upon each update.
- Memorize variadic function by arguments (compare each argument)
- Memorize unary function by options object (compare each key-value pairs)
- Built-in Typescript support
- 100% tested with ts-mocha
- No dependencies*
*: except tslib to support await for pre-es2017 runtime
Typescript Example
import {
newComputeByArgumentsCachePool,
newComputeByOptionsCachePool,
Callback,
} from 'cache-compute'
type State = { acc: number }
let sum2 = (a: number, b: number): number => {
console.log('perform some expensive computation...:', [a, b])
return a + b
}
let sum2Cache = newComputeByArgumentsCachePool(sum2)
type SumOptions = { a: number; b: number }
let sumDict = ({ a, b }: SumOptions): number => {
console.log('perform some expensive computation...:', { a, b })
return a + b
}
let sumDictCache = newComputeByOptionsCachePool(sumDict)
export let selector_dict = {
getBigger2(
state: State,
options: { delta: number },
callback: Callback<number>,
) {
let compute = sum2Cache(callback)
compute(state.acc, options.delta)
},
getBiggerDict(
state: State,
options: { delta: number },
callback: Callback<number>,
) {
let compute = sumDictCache(callback)
let a = state.acc
let b = options.delta
compute({ a, b })
},
}More example refers to demo-selector.ts and cache-compute.spec.ts
Typescript Example
import { makeSyncComputeCacheByArguments } from 'cache-compute'
let users = [
{ name: 'Alice', birthday: new Date('2000-01-01').getTime() },
{ name: 'Bob', birthday: new Date('2000-02-02').getTime() },
]
const YEAR = 1000 * 60 * 60 * 24 * 365.25
function toProfile(user) {
const now = Date.now()
return {
name: user.name,
age: Math.floor((now - user.birthday) / YEAR),
}
}
function updateUser(index, user) {
users = [...users]
users[index] = { ...users[index], ...user }
runSelectors()
}
let selectors = []
function runSelectors() {
selectors.forEach(fn => fn())
}
function watchProfile(index) {
const watchUsers = profile =>
// e.g. push to websocket client
console.log({ index, profile })
const checkUsers = makeSyncComputeCacheByArguments(toProfile, watchUsers)
const selector = () => checkUsers(users[index])
selector()
selectors.push(selector)
}
console.log('== init ==')
watchProfile(0)
watchProfile(1)
// will print both user profiles
console.log('== update alice ==')
updateUser(0, { name: 'Alex' })
// only print first user profile
console.log('== update bob ==')
updateUser(1, { name: 'Bobby' })
// only print second user profileMore example refers to demo.ts and cache-compute.spec.ts
The input (a.k.a. dependencies) of a function is memorized.
When the checker function is called, it compares the current input against that last input.
If any of the input is changed, the provided function will be re-run, and the return value will be passed to the callback function.
Error handling is intentionally not handled by the checker function. To handle errors properly, either do application-specific try-catch in the compute function or when calling the checker function.
This project is licensed with BSD-2-Clause
This is free, libre, and open-source software. It comes down to four essential freedoms [ref]:
- The freedom to run the program as you wish, for any purpose
- The freedom to study how the program works, and change it so it does your computing as you wish
- The freedom to redistribute copies so you can help others
- The freedom to distribute copies of your modified versions to others