function memoize(fn, options = {}) { const { maxSize = 1000, keyOf = (...a) => JSON.stringify(a), lruTouch = true, } = options; let hits = 0; let misses = 0; const cache = new Map(); const getKey = (...args) => keyOf(...args); const wrapped = (...args) => { // code to be written here return fn(...args); }; // additional code here return wrapped; }

The memoize function is designed to cache the results of calling the fn function with specific arguments, so that subsequent calls with the same arguments return the stored result, improving performance.

Below is an implementation example considering the maxSize, keyOf, and lruTouch parameters:

function memoize(fn, options = {}) {
  const {
    maxSize = 1000,
    keyOf = (...a) => JSON.stringify(a),
    lruTouch = true,
  } = options;

  let hits = 0;
  let misses = 0;

  const cache = new Map();
  const getKey = (...args) => keyOf(...args);

  const wrapped = (...args) => {
    const key = getKey(...args);
    if (cache.has(key)) {
      hits++;
      const value = cache.get(key);
      if (lruTouch) {
        // Update order for LRU: delete and re-insert
        cache.delete(key);
        cache.set(key, value);
      }
      return value;
    }

    misses++;
    const result = fn(...args);
    cache.set(key, result);

    if (cache.size > maxSize) {
      // Remove the oldest element (first inserted)
      const firstKey = cache.keys().next().value;
      cache.delete(firstKey);
    }

    return result;
  };

  // Methods for statistics can be added
  wrapped.cache = cache;
  wrapped.getHits = () => hits;
  wrapped.getMisses = () => misses;

  return wrapped;
}

In this code:

• cache is a Map where the key is the result of keyOf from the arguments, and the value is the function result.
• On cache hit (cache.has(key)), return the stored value and update the order if LRU is enabled.
• When adding a new element, if the size exceeds maxSize, remove the oldest one.
• Counts hits and misses for statistics.