Run results for: npm:fast-cartesian product vs native .reduce() vs cartesian from https://stackoverflow.com/a/43053803

Test name	Executions per second
✓ cartesian from https://stackoverflow.com/a/43053803	256,142,512 Ops/sec
native .reduce() with flatmap, concat	5,050,263 Ops/sec
native .reduce() with map, spread	3,371,457 Ops/sec
npm:fast-cartesian	2,166 Ops/sec

npm:fast-cartesian

// Does a cartesian product on several arrays.
// Returns an array with the results.
// Optimized to be the fastest implementation in JavaScript.
function fastCartesian(arrays) {
  
  if (arrays.length === 0) {
    return []
  }

  const loopFunc = getLoopFunc(arrays.length)
  const result = []
  loopFunc(arrays, result)
  return result
}

const getLoopFunc = function (length) {
  const cachedLoopFunc = cache[length]

  if (cachedLoopFunc !== undefined) {
    return cachedLoopFunc
  }

  const loopFunc = mGetLoopFunc(length)
  // eslint-disable-next-line fp/no-mutation
  cache[length] = loopFunc
  return loopFunc
}

const cache = {}

// Create a function with `new Function()` that does:
//   function(arrays, results) {
//     for (const value0 of arrays[0]) {
//       for (const value1 of arrays[1]) {
//         // and so on
//         results.push([value0, value1])
//       }
//     }
//   }
const mGetLoopFunc = function (length) {
  const indexes = Array.from({ length }, getIndex)
  const start = indexes
    .map((index) => `for (const value${index} of arrays[${index}]) {`)
    .join('\n')
  const middle = indexes.map((index) => `value${index}`).join(', ')
  const end = '}\n'.repeat(length)

  // eslint-disable-next-line no-new-func
  return new Function(
    'arrays',
    'result',
    `${start}\nresult.push([${middle}])\n${end}`,
  )
}

const getIndex = function (value, index) {
  return String(index)
}
const product = fastCartesian(data)

native .reduce() with flatmap, concat

const cartesianProduct = (...allEntries) => allEntries.reduce(
        (subsetsSoFar, entries) => [
            ...subsetsSoFar.flatMap((result) => entries.map((entry) => result.concat([entry]))),
        ],
        [[]]
    )
const product2 = cartesianProduct(data)

native .reduce() with map, spread

function cartesianProductWithSpread(...allEntries) {
  return allEntries.reduce(
    (results, entries) =>
      results
        .map(result => entries.map(entry => [...result, entry] ))
        .reduce((subResults, result) => [...subResults, ...result]   , []), 
    [[]]
  )
}
const product3 = cartesianProductWithSpread(data)

cartesian from https://stackoverflow.com/a/43053803

const cartesian = (...a) => {
    console.log(a)
    return a.reduce((a, b) => a.flatMap(d => {
    // console.log(b)
    return b.map(e => [d, e].flat())
  }))}