mem-fn

Memoize functions. Similar to mem, but with the ability to set and clear individual keys, all arguments accounted for in the default cache key function, cache key function arguments are passed normally rather than as an array.

Installation

yarn add mem-fn

npm install mem-fn

Usage

mem

import mem from "mem-fn";

let i = 0;

function fn() {
  i += 1;
  return i;
}

const memFn = mem(fn);

memFn(); // 1

memFn(); // 1

maxAge

import mem from "mem-fn";

let i = 0;

function fn() {
  i += 1;
  return i;
}

const memFn = mem(fn, { maxAge: 100 }); // 100ms

memFn(); // 1
setTimeout(() => {
  memFn(); // 2
}, 200);

cacheKeyFn

By default, alpha-stringify is used when more than one argument is present. All arguments are included, and object property order does not matter:

import mem from "mem-fn";

function add({ a, b }: { a: number, b: number }) {
  return a + b;
}

const memAdd = mem(add);

memAdd({ a: 1, b: 2 }); // 3
memAdd({ a: 1, b: 2 }); // cache hit - 3
memAdd({ b: 2, a: 1 }); // cache hit - 3

When creating a custom cacheKeyFn, arguments are passed normally rather than as an array:

import mem from "mem-fn";

function add(a: number, b: number) {
  return a + b;
}

const memAdd = mem(add, {
  cacheKeyFn: (a: number, b: number) => `${a}+${b}`
});

clear and set

import mem from "mem-fn";

function add(a: number, b: number) {
  return a + b;
}

const memAdd = mem(add);

memAdd.set(1, 2)(4);  // set cache for arguments (1, 2) to 4
memAdd(1, 2);         // 4
memAdd.clear(1, 2);   // clear cache corresponding to these arguments
memAdd(1, 2);         // 3
memAdd.clearAll();    // clear entire cache

onSet

A hook is also provided for when set is called:

import mem from "mem-fn";

function add(a: number, b: number) {
  return a + b;
}

const memAdd = mem(add, {
  onSet: ([a, b]: [number, number], result: number) => console.log(`Set: ${a} + ${b} = ${number}`);
});

memAdd.set(1, 2)(4);  // Set: 1 + 2 = 4

Types

import mem, { Options, Fn, MemFn } from "mem-fn";

function mem<F extends Fn<A, T>, A extends any[], T>(
  fn: Fn<A, T>,
  options?: Options<A, T>
): MemFn<A, T>;

type Fn<A extends any[], T> = (...args: A) => T;

type Options<A extends any[], T> = {
  /**
   * Milliseconds until the cache expires. Default: `Infinity`
   */
  maxAge?: number;
  /**
   * Determines cache key to use. Default: `(...args) => stringify(args)`
   */
  cacheKeyFn?: (...args: A) => string;
  /**
   * Hook to run after .set() function is called.
   */
  onSet?: (args: A, data: T) => void;
};

type MemFn<F extends Fn<A, T>, A extends any[], T> = F & {
  clear(...args: A): void;
  clearAll(): void;
  set(...args: A): (value: T) => T;
};

Dependencies

• alpha-stringify: Serialize anything, and sort keys for equality comparison

Dev Dependencies

• @bconnorwhite/bob: Bob is a toolkit for TypeScript projects

License

MIT