samhh/fp-ts-std

The missing pseudo-standard library for fp-ts.

fp-ts-std's Issues

DOM APIs

Probably out of scope if we want to support Node? Or perhaps not, Node users would just need to not import those. Or fp-ts-dom?

Always provide explicit function signatures

Improves docs e.g. O.Option -> Option when using flow.

reject should support refinements

Like ordinary filtering does.

Why are get/setParam IO?

Enforce examples in all exports

Descriptions and versions are now enforced but examples notably are not.

It's probably a good idea to do so, though there are some exports for which an example arguably poses no value.

See also: gcanti/docs-ts#45

Newtypes and/or branded types

Candidates:

• JSONString - Stringified JSON
• Various time units
• Unit - to do away with null and undefined entirely

parseInt proposal

Hello! I'm a big fan of this library!

Maybe it would be useful to have a parseInt function in Number.ts? It might help with #29

import {flow} from 'fp-ts/function'
import * as O from 'fp-ts/Option'
import {invert} from './Boolean'

const parseInt = flow(Number.parseInt, O.fromPredicate(invert(isNaN)))

Or is this too trivial to be worth it?

Support ES modules

Not considered it at all thus far, very likely needs attention.

not should invert bool, not predicate

Current not should be renamed to something else.

This'll make it consistent with Haskell and Ramda.

Update eslint-plugin-functional to ^3.2.x

Blocked by: eslint-functional/eslint-plugin-functional#194

Add docs examples to all exports

`set` and `setW` in the `Record` module?

Port of lodash's set - might be helpful for #29

Implementation

Credit to @qlonik for the idea and for EnsureLiteral

Separate docs from master branch

Or only merge into master for releases. The docs are getting ahead of releases.

unsafeExactKeys looks like fp-ts/Record::keys

Maybe duplicate?

Utilise Prettier

Already a dependency, let's actually use it now.

Add docs categories to all exports

Datum / RemoteData

Datum/RemoteData are nice, it'd be nice to support them without adding any further dependencies.

string surround should take only one argument for both sides

I think?

"fork" function

Can't get this to work without thunking A (where ReturnTypes is just ReturnType over an array via mapped type):

const fork = <A, B, C extends Array<(x: A) => B>>(gs: [...C]) => (x: A): ReturnTypes<C> =>
  gs.map(applyTo(x)) as ReturnTypes<C>

Example of intended usage:

declare const sum: (x: number[]) => number
declare const length: (x: unknown[]) => number
declare const joined: (x: unknown[]) => string

fork([sum, length, joined]) // (xs: number[]) => [number, number, string]

This'd cross out juxt in the Ramda doc but be... better. Can probably then tackle converge too.

Task logDuration

To log a task duration. Something like this. I suppose it can be useful.

export const logDuration = <A>(ma: Task<A>): Task<A> => {
  return () => {
    const start = Date.now();
    return ma().then((a) => {
      // eslint-disable-next-line no-console
      console.log(`${(Date.now() - start) / 1000}s`);
      return a;
    });
  };
};

WebExtension module

Not sure how this'll work in terms of webextension-polyfill-ts. Don't want to include a dependency like that for anyone not using it.

Expand upon the Date module

Some newtypes for things like Milliseconds would be handy.

Achieve parity with Ramda

https://samhh.github.io/fp-ts-std/ramda

New implementations for `pick` and `omit`?

Here's a rough draft of the concept. Pick has become a bit simpler, and they both now accept rest parameters. Omit (may?) have better performance characteristics w/o the use of delete (though this is unclear)

Not sure if one or neither of these are desired as they are breaking changes, but I can spin up a PR if it is/they are!

P.S. Credit to @qlonik for UnionToIntersection and for the delete research

Update Jest to 27.x

The tests using timers fail in 27.0.6 irrespective of which timer strategy is used.

Add documentation

A la fp-ts and other community projects.

Rename when endomorphism to onTrue

Consistency with unless and easier to understand the type signature at a glance.

Ord: minimum / maximum

e.g.

const minimum = <A>(ord: Ord<A>): ((xs: NonEmptyArray<A>) => A) => NEA.fold(getMeetSemigroup(ord))

Like Haskell's minimum and maximum, but total.

Narrow JSON decode output

Instead of unknown, could it be?:

type JSONType = null | string | boolean | number | JSONType[] | Record<string, JSONType>

Date tests can fail on some machines

#44 (comment)

critical: packagejson does not contain field "main"

The files are included with the package but since package.json does not have field main, it doesn't know where to look.

Export unJSONString

Let's not make consumers do this themselves.

Probably don't export mkJSONString.

Either unsafeUnwrap throwing Left value?

Unit newtype

Does anyone care about this? So we could do away with null/undefined entirely.

Achieve parity with Lodash

Some stuff in Lodash that's not in fp-ts or Ramda could be useful here.

zipAll proposal

Zip currently only works for arrays of the same size, which is sometimes fine but sometimes you want to zip up uneven arrays and keep the parts that were uneven. How about a function like:

const zipWithAll = <A, B, C>(
  fa: ReadonlyArray<A>, 
  fb: ReadonlyArray<B>, 
  f: (a: O.Option<A>, b: O.Option<B>) => C): ReadonlyArray<C> => {
  const fc: Array<C> = []
  const len = Math.max(fa.length, fb.length)
  for (let i = 0; i < len; i++) {
    fc[i] = f(i < fa.length ? O.some(fa[i]) : O.none, i < fb.length ? O.some(fb[i]) : O.none)
  }
  return fc
}

// zip but just gives arrays of size 1 when its uneven
const zipAll = <A, B, C>(fa: ReadonlyArray<A>, fb: ReadonlyArray<B>) =>
  zipWithAll(fa, fb, (a, b) => A.compact<(A|B)>([a, b]))

zipAll([1,2,3], [4,5])
// => [[1,4], [2, 5], [3]]

Character type

type Character = string & { length: 1 };

Add guides for "why isn't this here?" stuff

e.g. no need for a sum function when you can just do fold(monoidSum)

Env module

Find myself having to rewrite a functional wrapper around accessing process.env quite often.

Possibly unneeded ts-node dev dep

Improve testing coverage

Published package has no README

Probably need to adjust publish mechanism to copy it into dist/.

LocalStorage module

Take inspiration from fp-ts-local-storage, but encode the possibility of failure into every applicable type signature.

Add helper for URLSearchParams construction

It can throw a TypeError.

Array Concat

I'm a little tired of using a Monoid to concat arrays together all the time, how would y'all feel about a convenience function for Array like

const concat = <A>(a:A[]) => (b:A[]) => A.getMonoid<A>().concat(a, b)

just so we can pipe some stuff together like

pipe(R.keys(x), concat(R.keys(y)), A.uniq(eqString))

Some modules missing from index re-export module

Oops!

Coverage incorrectly reported as <100%

On develop branch in CI. 100% locally with Node 15.

unlines is incorrectly defined

join not split, silly.

guard missing example

https://samhh.github.io/fp-ts-std/modules/Function.ts.html#guard

What have I duplicated?

• Check fp-ts-contrib
• Check not