Giter VIP home page Giter VIP logo

cache-compute's Introduction

cache-compute

Memorize and re-run a function when its arguments are changed. The output is passed to callback function upon each update.

npm Package Version

Main Functions

  • Memorize variadic function by arguments (compare each argument)
  • Memorize unary function by options object (compare each key-value pairs)

Features

  • Built-in Typescript support
  • 100% tested with ts-mocha
  • No dependencies*

*: except tslib to support await for pre-es2017 runtime

Usage Example

Using compute cache pool

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

Using compute cache directly

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 profile

More example refers to demo.ts and cache-compute.spec.ts

How it works

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.

Remark

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.

License

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

cache-compute's People

Contributors

beenotung avatar

Watchers

 avatar  avatar

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.