hermann-p / pragmatic-fp-ts Goto Github PK

Currently the lib exports some hundred individual small .js- and .d.ts-files. I would like to bundle them together into a single, minified .min.js file that can be used in node- and browser projects, while keeping type definitions to keep IDEs happy.

This code has problems with large arrays:

Reduce with spread is an anti-pattern because it implicitly makes nested iterations -> see https://www.richsnapp.com/article/2019/06-09-reduce-spread-anti-pattern which is very bad for performance.

Also it would be an advantage to distinguish between a single flatten and a recursive flatten function, like lodash does it with flatten and flattenDeep?

A more performant version of flatten/flattenDeep could be that one:

const doFlattenDeep = (elems: any): any[] =>
  elems instanceof Array
    ? elems.reduce((accum: any[], elem: any) => {
      elem instanceof Array ? accum.push(...doFlattenDeep(elem)) : accum.push(elem);
        return accum;
      }, [])
    : elems;

const doFlatten = (elems: any): any[] =>
  elems instanceof Array
    ? elems.reduce((accum: any[], elem: any) => {
      accum.push(elem);
        return accum;
      }, [])
    : elems;

function flattenDeep<A = any>(coll: any[]): A[] {
  return doFlattenDeep(l.getValueOr([], coll));
}

function flatten<A = any>(coll: any[]): A[] {
  return doFlatten(l.getValueOr([], coll));
}

These are the perf results with the new functions compared against lodash and the old one (nested array with 1000 entries):
flattenDeep is still slower than the lodash versions (but much faster than the old one), maybe because of not be an tail recursion?

Currently using monads with promises can be a bit awkward. For this reason I'd like to implement monadic futures.

Todo:

• research API and implementation details of well-working async- and future-monads
• implement something that follows the spirit of the library