fjl v2.0

[elycruz]

Version goals:

• Better performance, and better ergonimics (idiomatic syntaxes should be used instead of custom implementation ones (E.g., currying, et al.)).

Acceptance Criteria:

Idiomatic Curry

• Update all 'pseudo' curried methods, in the library, to use idiomatic currying: E.g., instead of const equal$ = curry(equal); should be `const equal$ = a => b => equal(a, b), etc. (latter options is better for readability, performance, and debugging).
• Add tests for 'curried' methods - will help ensure all curried methods are indeed curried.
• next - fjl - Remove use of 'curry_' methods from tests and test helpers. #40

Convert methods in:

... and update tests as required:

• 'src/boolean/'.
• 'src/data/'.
• 'src/errorThrowing/'.
• 'src/function/'.
• 'src/list/utils/'.
• 'src/list/'.
• 'src/number/'.
• 'src/object/'.
• 'src/platform/'.
• 'src/string/'.
• fjl v3.0: Move tests near the member call sites #77

Slice type removal Allow inferred types

Tickets in this section need consolidating.

• Replaces overloaded generic/otherwise types with any, and/or allow implicit inference where it makes sense.
  • Turns out typescript has a good inference engine (any). Where things get to hairy, and we need overloaded types, "typings" information should be removed.
• next: Consolidate generic base types #32
• next: Replace Slice type with Iterable type  #43
• [] next: Allow infered types #61
• All methods that take slices should either take an Indexable, a string, an array, or an interface type, that isn't a 'sum' type, but has it's own definition.
  • Remove Slice type, and it's usages.
    • Remove in sources.
    • Remove in tests.
    • Remove in docs.

Flatten userland 'complexity 0-1' curried methods

Curried methods that have a complexity of 0-1 should just have their definitions declared 'explicitly'; E.g., instead of

const 

  fmap = <T, RetT>(fn: FunctorMapFn<RetT>, x: Functor<T>): Functor<RetT> | Functor => x.map(fn),

  $fmap = <T, RetT>(fn: FunctorMapFn<RetT>) =>
    (x: Functor<T>): Functor<RetT> | Functor =>
      fmap(fn, x)

;

The second declaration should be

// ...
$fmap = <T, RetT>(fn: FunctorMapFn<RetT>, x: Functor<T>): Functor<RetT> | Functor => x.map(fn);

Removing that one layer of indirection provides a small performance bump (in extreme functional cases, et al.).

Perform aforementioned updates for sub packages in repo

• fjl-validator
• fjl-inputfilter
• fjl-validator-recaptcha
• ...

Repo Level

• Consolidate 'tsconfig.prod.esm.json' into adjacent tsconfigs.
• CI/CD: Choose documentation generating strategy #102
  • Currently considering typedoc but we also need to decide on where the documentation will be generated (separate repo (can it be linked as documentation to this repo?)?).
• next: Methods that return booleans but take more than one arg, should not have their members flipped #80
• next: Consolidate set theory methods into one set #79

General

• Remove use of 'curry_' module, in tests (improves performance of tests that are using the module). #86
• next: Rename 'platform' dir to '_platform' to disambiguate from exported packages. #91
• next: take, takeWhile, and similar, methods should also work with generators #87
• next: Remove 'nullish' checks in utility/library methods (unless required) #90
• Re-add apply method to the library as it can serve as the functional version of the 'spread' operator. #94
• Keep generic defaults for method types #113
• Remove the use of generics defined in 'data/list'. #114
• Remove the use of 'unknown' as generic values. #115
• Types that take more than three generic args should have clear type names for their generics #116
• v2.0 - feature: Update iterator family of methods to just be generators, where it makes sense
• v2.0 - Implementations review #122