@effect/typeclass - npm Package Compare versions

Comparing version 0.22.23 to 0.23.0

dist/cjs/data/ReadonlyRecord.js

@@ -6,3 +6,3 @@ "use strict";
 });
-exports.TraversableFilterable = exports.Traversable = exports.Invariant = exports.Filterable = exports.Covariant = void 0;
+exports.traverse = exports.getTraversableFilterable = exports.getTraversable = exports.getInvariant = exports.getFilterable = exports.getCovariant = exports.TraversableFilterable = exports.Traversable = exports.Invariant = exports.Filterable = exports.Covariant = void 0;
 var _Function = /*#__PURE__*/require("effect/Function");
@@ -36,7 +36,5 @@ var ReadonlyRecord = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/ReadonlyRecord"));
 }
-const map = ReadonlyRecord.map;
-const imap = /*#__PURE__*/covariant.imap(map);
-const partitionMap = ReadonlyRecord.partitionMap;
-const filterMap = ReadonlyRecord.filterMap;
+/** @internal */
 const traverse = F => (0, _Function.dual)(2, (self, f) => F.map(F.productAll(Object.entries(self).map(([key, a]) => F.map(f(a, key), b => [key, b]))), Object.fromEntries));
+exports.traverse = traverse;
 const traversePartitionMap = F => (0, _Function.dual)(2, (self, f) => {
@@ -48,2 +46,9 @@ return F.map(traverse(F)(self, f), ReadonlyRecord.separate);
 });
+const _map = ReadonlyRecord.map;
+const _imap = /*#__PURE__*/covariant.imap(_map);
+const _partitionMap = ReadonlyRecord.partitionMap;
+const _filterMap = ReadonlyRecord.filterMap;
+const _traverse = traverse;
+const _traversePartitionMap = traversePartitionMap;
+const _traverseFilterMap = traverseFilterMap;
 /**
@@ -53,6 +58,6 @@ * @category instances
  */
-const Covariant = exports.Covariant = {
-  imap,
-  map
-};
+const getCovariant = () => ({
+  imap: _imap,
+  map: _map
+});
 /**
@@ -62,5 +67,4 @@ * @category instances
  */
-const Invariant = exports.Invariant = {
-  imap
-};
+exports.getCovariant = getCovariant;
+const Covariant = exports.Covariant = /*#__PURE__*/getCovariant();
 /**
@@ -70,6 +74,5 @@ * @category instances
  */
-const Filterable = exports.Filterable = {
-  partitionMap,
-  filterMap
-};
+const getInvariant = () => ({
+  imap: _imap
+});
 /**
@@ -79,5 +82,4 @@ * @category instances
  */
-const Traversable = exports.Traversable = {
-  traverse
-};
+exports.getInvariant = getInvariant;
+const Invariant = exports.Invariant = /*#__PURE__*/getInvariant();
 /**
@@ -87,6 +89,39 @@ * @category instances
  */
-const TraversableFilterable = exports.TraversableFilterable = {
-  traversePartitionMap,
-  traverseFilterMap
-};
+const getFilterable = () => ({
+  partitionMap: _partitionMap,
+  filterMap: _filterMap
+});
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+exports.getFilterable = getFilterable;
+const Filterable = exports.Filterable = /*#__PURE__*/getFilterable();
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+const getTraversable = () => ({
+  traverse: _traverse
+});
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+exports.getTraversable = getTraversable;
+const Traversable = exports.Traversable = /*#__PURE__*/getTraversable();
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+const getTraversableFilterable = () => ({
+  traversePartitionMap: _traversePartitionMap,
+  traverseFilterMap: _traverseFilterMap
+});
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+exports.getTraversableFilterable = getTraversableFilterable;
+const TraversableFilterable = exports.TraversableFilterable = /*#__PURE__*/getTraversableFilterable();
 //# sourceMappingURL=ReadonlyRecord.js.map

dist/dts/data/ReadonlyRecord.d.ts

@@ -11,3 +11,3 @@ import * as ReadonlyRecord from "effect/ReadonlyRecord";
  */
-export declare const Covariant: covariant.Covariant<ReadonlyRecord.ReadonlyRecordTypeLambda>;
+export declare const getCovariant: <K extends string>() => covariant.Covariant<ReadonlyRecord.ReadonlyRecordTypeLambda<K>>;
 /**
@@ -17,3 +17,3 @@ * @category instances
  */
-export declare const Invariant: invariant.Invariant<ReadonlyRecord.ReadonlyRecordTypeLambda>;
+export declare const Covariant: covariant.Covariant<ReadonlyRecord.ReadonlyRecordTypeLambda<string>>;
 /**
@@ -23,3 +23,3 @@ * @category instances
  */
-export declare const Filterable: filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda>;
+export declare const getInvariant: <K extends string>() => invariant.Invariant<ReadonlyRecord.ReadonlyRecordTypeLambda<K>>;
 /**
@@ -29,3 +29,3 @@ * @category instances
  */
-export declare const Traversable: traversable.Traversable<ReadonlyRecord.ReadonlyRecordTypeLambda>;
+export declare const Invariant: invariant.Invariant<ReadonlyRecord.ReadonlyRecordTypeLambda<string>>;
 /**
@@ -35,3 +35,28 @@ * @category instances
  */
-export declare const TraversableFilterable: traversableFilterable.TraversableFilterable<ReadonlyRecord.ReadonlyRecordTypeLambda>;
+export declare const getFilterable: <K extends string>() => filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda<K>>;
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export declare const Filterable: filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda<string>>;
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export declare const getTraversable: <K extends string>() => traversable.Traversable<ReadonlyRecord.ReadonlyRecordTypeLambda<K>>;
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export declare const Traversable: traversable.Traversable<ReadonlyRecord.ReadonlyRecordTypeLambda<string>>;
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export declare const getTraversableFilterable: <K extends string>() => traversableFilterable.TraversableFilterable<ReadonlyRecord.ReadonlyRecordTypeLambda<K>>;
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export declare const TraversableFilterable: traversableFilterable.TraversableFilterable<ReadonlyRecord.ReadonlyRecordTypeLambda<string>>;
 //# sourceMappingURL=ReadonlyRecord.d.ts.map

dist/dts/Filterable.d.ts

@@ -16,4 +16,4 @@ /**
     readonly partitionMap: {
-        <A, B, C>(f: (a: A) => Either.Either<B, C>): <R, O, E>(self: Kind<F, R, O, E, A>) => [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>];
-        <R, O, E, A, B, C>(self: Kind<F, R, O, E, A>, f: (a: A) => Either.Either<B, C>): [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>];
+        <A, B, C>(f: (a: A) => Either.Either<C, B>): <R, O, E>(self: Kind<F, R, O, E, A>) => [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>];
+        <R, O, E, A, B, C>(self: Kind<F, R, O, E, A>, f: (a: A) => Either.Either<C, B>): [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>];
     };
@@ -30,3 +30,3 @@ readonly filterMap: {
  */
-export declare const partitionMapComposition: <F extends TypeLambda, G extends TypeLambda>(F: Covariant<F>, G: Filterable<G>) => <FR, FO, FE, GR, GO, GE, A, B, C>(self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>, f: (a: A) => Either.Either<B, C>) => [Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, B>>, Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, C>>];
+export declare const partitionMapComposition: <F extends TypeLambda, G extends TypeLambda>(F: Covariant<F>, G: Filterable<G>) => <FR, FO, FE, GR, GO, GE, A, B, C>(self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>, f: (a: A) => Either.Either<C, B>) => [Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, B>>, Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, C>>];
 /**
@@ -45,3 +45,3 @@ * Returns a default binary `filterMap` composition.
  */
-export declare const separate: <F extends TypeLambda>(F: Filterable<F>) => <R, O, E, A, B>(self: Kind<F, R, O, E, Either.Either<A, B>>) => [Kind<F, R, O, E, A>, Kind<F, R, O, E, B>];
+export declare const separate: <F extends TypeLambda>(F: Filterable<F>) => <R, O, E, A, B>(self: Kind<F, R, O, E, Either.Either<B, A>>) => [Kind<F, R, O, E, A>, Kind<F, R, O, E, B>];
 /**
@@ -48,0 +48,0 @@ * @since 1.0.0

dist/dts/TraversableFilterable.d.ts

@@ -20,4 +20,4 @@ /**
     readonly traversePartitionMap: <F extends TypeLambda>(F: Applicative<F>) => {
-        <A, R, O, E, B, C>(f: (a: A) => Kind<F, R, O, E, Either<B, C>>): <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>;
-        <TR, TO, TE, A, R, O, E, B, C>(self: Kind<T, TR, TO, TE, A>, f: (a: A) => Kind<F, R, O, E, Either<B, C>>): Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>;
+        <A, R, O, E, B, C>(f: (a: A) => Kind<F, R, O, E, Either<C, B>>): <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>;
+        <TR, TO, TE, A, R, O, E, B, C>(self: Kind<T, TR, TO, TE, A>, f: (a: A) => Kind<F, R, O, E, Either<C, B>>): Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>;
     };
@@ -34,3 +34,3 @@ readonly traverseFilterMap: <F extends TypeLambda>(F: Applicative<F>) => {
  */
-export declare const traversePartitionMap: <T extends TypeLambda>(T: Traversable<T> & Covariant<T> & filterable.Filterable<T>) => <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, A, R, O, E, B, C>(self: Kind<T, TR, TO, TE, A>, f: (a: A) => Kind<F, R, O, E, Either<B, C>>) => Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>;
+export declare const traversePartitionMap: <T extends TypeLambda>(T: Traversable<T> & Covariant<T> & filterable.Filterable<T>) => <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, A, R, O, E, B, C>(self: Kind<T, TR, TO, TE, A>, f: (a: A) => Kind<F, R, O, E, Either<C, B>>) => Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>;
 /**
@@ -37,0 +37,0 @@ * Returns a default binary `traverseFilterMap` implementation.

dist/esm/data/ReadonlyRecord.js

 import { dual } from "effect/Function";
 import * as ReadonlyRecord from "effect/ReadonlyRecord";
 import * as covariant from "../Covariant.js";
-const map = ReadonlyRecord.map;
-const imap = /*#__PURE__*/covariant.imap(map);
-const partitionMap = ReadonlyRecord.partitionMap;
-const filterMap = ReadonlyRecord.filterMap;
-const traverse = F => dual(2, (self, f) => F.map(F.productAll(Object.entries(self).map(([key, a]) => F.map(f(a, key), b => [key, b]))), Object.fromEntries));
+/** @internal */
+export const traverse = F => dual(2, (self, f) => F.map(F.productAll(Object.entries(self).map(([key, a]) => F.map(f(a, key), b => [key, b]))), Object.fromEntries));
 const traversePartitionMap = F => dual(2, (self, f) => {
@@ -15,2 +12,9 @@ return F.map(traverse(F)(self, f), ReadonlyRecord.separate);
 });
+const _map = ReadonlyRecord.map;
+const _imap = /*#__PURE__*/covariant.imap(_map);
+const _partitionMap = ReadonlyRecord.partitionMap;
+const _filterMap = ReadonlyRecord.filterMap;
+const _traverse = traverse;
+const _traversePartitionMap = traversePartitionMap;
+const _traverseFilterMap = traverseFilterMap;
 /**
@@ -20,6 +24,6 @@ * @category instances
  */
-export const Covariant = {
-  imap,
-  map
-};
+export const getCovariant = () => ({
+  imap: _imap,
+  map: _map
+});
 /**
@@ -29,5 +33,3 @@ * @category instances
  */
-export const Invariant = {
-  imap
-};
+export const Covariant = /*#__PURE__*/getCovariant();
 /**
@@ -37,6 +39,5 @@ * @category instances
  */
-export const Filterable = {
-  partitionMap,
-  filterMap
-};
+export const getInvariant = () => ({
+  imap: _imap
+});
 /**
@@ -46,5 +47,3 @@ * @category instances
  */
-export const Traversable = {
-  traverse
-};
+export const Invariant = /*#__PURE__*/getInvariant();
 /**
@@ -54,6 +53,36 @@ * @category instances
  */
-export const TraversableFilterable = {
-  traversePartitionMap,
-  traverseFilterMap
-};
+export const getFilterable = () => ({
+  partitionMap: _partitionMap,
+  filterMap: _filterMap
+});
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const Filterable = /*#__PURE__*/getFilterable();
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const getTraversable = () => ({
+  traverse: _traverse
+});
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const Traversable = /*#__PURE__*/getTraversable();
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const getTraversableFilterable = () => ({
+  traversePartitionMap: _traversePartitionMap,
+  traverseFilterMap: _traverseFilterMap
+});
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const TraversableFilterable = /*#__PURE__*/getTraversableFilterable();
 //# sourceMappingURL=ReadonlyRecord.js.map

package.json

 {
   "name": "@effect/typeclass",
-  "version": "0.22.23",
+  "version": "0.23.0",
   "description": "A collection of reusable typeclasses for the Effect ecosystem",
@@ -13,3 +13,3 @@ "license": "MIT",
   "peerDependencies": {
-    "effect": "^2.3.8"
+    "effect": "^2.4.0"
   },
@@ -16,0 +16,0 @@ "main": "./dist/cjs/index.js",

src/data/Either.ts

@@ -35,15 +35,15 @@ /**
     onRight: (a: A) => B
-  ): (self: Either.Either<E1, A>) => Either.Either<E2, B>
+  ): (self: Either.Either<A, E1>) => Either.Either<B, E2>
   <E1, A, E2, B>(
-    self: Either.Either<E1, A>,
+    self: Either.Either<A, E1>,
     onLeft: (e: E1) => E2,
     onRight: (a: A) => B
-  ): Either.Either<E2, B>
+  ): Either.Either<B, E2>
 } = dual(
   3,
   <E1, A, E2, B>(
-    self: Either.Either<E1, A>,
+    self: Either.Either<A, E1>,
     onLeft: (e: E1) => E2,
     onRight: (a: A) => B
-  ): Either.Either<E2, B> => Either.mapBoth(self, { onLeft, onRight })
+  ): Either.Either<B, E2> => Either.mapBoth(self, { onLeft, onRight })
 )
@@ -53,20 +53,20 @@
   <A, E2, B>(
-    f: (a: A) => Either.Either<E2, B>
-  ): <E1>(self: Either.Either<E1, A>) => Either.Either<E1 | E2, B>
+    f: (a: A) => Either.Either<B, E2>
+  ): <E1>(self: Either.Either<A, E1>) => Either.Either<B, E1 | E2>
   <E1, A, E2, B>(
-    self: Either.Either<E1, A>,
-    f: (a: A) => Either.Either<E2, B>
-  ): Either.Either<E1 | E2, B>
+    self: Either.Either<A, E1>,
+    f: (a: A) => Either.Either<B, E2>
+  ): Either.Either<B, E1 | E2>
 } = dual(
   2,
   <E1, A, E2, B>(
-    self: Either.Either<E1, A>,
-    f: (a: A) => Either.Either<E2, B>
-  ): Either.Either<E1 | E2, B> => Either.isLeft(self) ? Either.left(self.left) : f(self.right)
+    self: Either.Either<A, E1>,
+    f: (a: A) => Either.Either<B, E2>
+  ): Either.Either<B, E1 | E2> => Either.isLeft(self) ? Either.left(self.left) : f(self.right)
 )
 
 const product = <E1, A, E2, B>(
-  self: Either.Either<E1, A>,
-  that: Either.Either<E2, B>
-): Either.Either<E1 | E2, [A, B]> =>
+  self: Either.Either<A, E1>,
+  that: Either.Either<B, E2>
+): Either.Either<[A, B], E1 | E2> =>
   Either.isRight(self) ?
@@ -77,5 +77,5 @@ (Either.isRight(that) ? Either.right([self.right, that.right]) : Either.left(that.left)) :
 const productMany = <E, A>(
-  self: Either.Either<E, A>,
-  collection: Iterable<Either.Either<E, A>>
-): Either.Either<E, [A, ...Array<A>]> => {
+  self: Either.Either<A, E>,
+  collection: Iterable<Either.Either<A, E>>
+): Either.Either<[A, ...Array<A>], E> => {
   if (Either.isLeft(self)) {
@@ -95,4 +95,4 @@ return Either.left(self.left)
 const productAll = <E, A>(
-  collection: Iterable<Either.Either<E, A>>
-): Either.Either<E, Array<A>> => {
+  collection: Iterable<Either.Either<A, E>>
+): Either.Either<Array<A>, E> => {
   const out: Array<A> = []
@@ -109,10 +109,10 @@ for (const e of collection) {
 const coproduct = <E1, A, E2, B>(
-  self: Either.Either<E1, A>,
-  that: Either.Either<E2, B>
-): Either.Either<E1 | E2, A | B> => Either.isRight(self) ? self : that
+  self: Either.Either<A, E1>,
+  that: Either.Either<B, E2>
+): Either.Either<A | B, E1 | E2> => Either.isRight(self) ? self : that
 
 const coproductMany = <E, A>(
-  self: Either.Either<E, A>,
-  collection: Iterable<Either.Either<E, A>>
-): Either.Either<E, A> => {
+  self: Either.Either<A, E>,
+  collection: Iterable<Either.Either<A, E>>
+): Either.Either<A, E> => {
   let out = self
@@ -135,15 +135,15 @@ if (Either.isRight(out)) {
     f: (a: A) => Kind<F, R, O, E, B>
-  ): <TE>(self: Either.Either<TE, A>) => Kind<F, R, O, E, Either.Either<TE, B>>
+  ): <TE>(self: Either.Either<A, TE>) => Kind<F, R, O, E, Either.Either<B, TE>>
   <TE, A, R, O, E, B>(
-    self: Either.Either<TE, A>,
+    self: Either.Either<A, TE>,
     f: (a: A) => Kind<F, R, O, E, B>
-  ): Kind<F, R, O, E, Either.Either<TE, B>>
+  ): Kind<F, R, O, E, Either.Either<B, TE>>
 } =>
   dual(2, <TE, A, R, O, E, B>(
-    self: Either.Either<TE, A>,
+    self: Either.Either<A, TE>,
     f: (a: A) => Kind<F, R, O, E, B>
-  ): Kind<F, R, O, E, Either.Either<TE, B>> =>
+  ): Kind<F, R, O, E, Either.Either<B, TE>> =>
     Either.isLeft(self) ?
-      F.of<Either.Either<TE, B>>(Either.left(self.left)) :
-      F.map<R, O, E, B, Either.Either<TE, B>>(f(self.right), Either.right))
+      F.of<Either.Either<B, TE>>(Either.left(self.left)) :
+      F.map<R, O, E, B, Either.Either<B, TE>>(f(self.right), Either.right))
 
@@ -296,3 +296,3 @@ /**
     3,
-    <E, A, B>(self: Either.Either<E, A>, b: B, f: (b: B, a: A) => B): B => Either.isLeft(self) ? b : f(b, self.right)
+    <E, A, B>(self: Either.Either<A, E>, b: B, f: (b: B, a: A) => B): B => Either.isLeft(self) ? b : f(b, self.right)
   )
@@ -299,0 +299,0 @@ }

src/data/ReadonlyArray.ts

@@ -73,7 +73,7 @@ /**
   <A, R, O, E, B, C>(
-    f: (a: A) => Kind<F, R, O, E, Either<B, C>>
+    f: (a: A) => Kind<F, R, O, E, Either<C, B>>
   ): (self: ReadonlyArray<A>) => Kind<F, R, O, E, [Array<B>, Array<C>]>
   <A, R, O, E, B, C>(
     self: ReadonlyArray<A>,
-    f: (a: A) => Kind<F, R, O, E, Either<B, C>>
+    f: (a: A) => Kind<F, R, O, E, Either<C, B>>
   ): Kind<F, R, O, E, [Array<B>, Array<C>]>
@@ -83,3 +83,3 @@ } =>
     self: ReadonlyArray<A>,
-    f: (a: A) => Kind<F, R, O, E, Either<B, C>>
+    f: (a: A) => Kind<F, R, O, E, Either<C, B>>
   ): Kind<F, R, O, E, [Array<B>, Array<C>]> => {
@@ -86,0 +86,0 @@ return F.map(traverse(F)(self, f), ReadonlyArray.separate)

src/data/ReadonlyRecord.ts

@@ -16,23 +16,16 @@ /**
 
-const map = ReadonlyRecord.map
-
-const imap = covariant.imap<ReadonlyRecord.ReadonlyRecordTypeLambda>(map)
-
-const partitionMap = ReadonlyRecord.partitionMap
-
-const filterMap = ReadonlyRecord.filterMap
-
-const traverse = <F extends TypeLambda>(F: applicative.Applicative<F>): {
+/** @internal */
+export const traverse = <F extends TypeLambda>(F: applicative.Applicative<F>): {
   <K extends string, A, R, O, E, B>(
     f: (a: A, key: K) => Kind<F, R, O, E, B>
-  ): (self: Record<K, A>) => Kind<F, R, O, E, Record<string, B>>
+  ): (self: Record<K, A>) => Kind<F, R, O, E, Record<K, B>>
   <K extends string, A, R, O, E, B>(
     self: Record<K, A>,
     f: (a: A, key: K) => Kind<F, R, O, E, B>
-  ): Kind<F, R, O, E, Record<string, B>>
+  ): Kind<F, R, O, E, Record<K, B>>
 } =>
-  dual(2, <A, R, O, E, B>(
+  dual(2, <K extends string, A, R, O, E, B>(
     self: Record<string, A>,
     f: (a: A, key: string) => Kind<F, R, O, E, B>
-  ): Kind<F, R, O, E, Record<string, B>> =>
+  ): Kind<F, R, O, E, Record<K, B>> =>
     F.map(
@@ -49,15 +42,42 @@ F.productAll(
   <A, R, O, E, B, C>(
-    f: (a: A) => Kind<F, R, O, E, Either<B, C>>
-  ): (
-    self: ReadonlyRecord.ReadonlyRecord<A>
-  ) => Kind<F, R, O, E, [Record<string, B>, Record<string, C>]>
-  <A, R, O, E, B, C>(
-    self: ReadonlyRecord.ReadonlyRecord<A>,
-    f: (a: A) => Kind<F, R, O, E, Either<B, C>>
-  ): Kind<F, R, O, E, [Record<string, B>, Record<string, C>]>
+    f: (a: A) => Kind<F, R, O, E, Either<C, B>>
+  ): <K extends string>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>
+  ) => Kind<
+    F,
+    R,
+    O,
+    E,
+    [
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>,
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, C>
+    ]
+  >
+  <K extends string, A, R, O, E, B, C>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>,
+    f: (a: A) => Kind<F, R, O, E, Either<C, B>>
+  ): Kind<
+    F,
+    R,
+    O,
+    E,
+    [
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>,
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, C>
+    ]
+  >
 } =>
-  dual(2, <A, R, O, E, B, C>(
-    self: ReadonlyRecord.ReadonlyRecord<A>,
-    f: (a: A) => Kind<F, R, O, E, Either<B, C>>
-  ): Kind<F, R, O, E, [Record<string, B>, Record<string, C>]> => {
+  dual(2, <K extends string, A, R, O, E, B, C>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>,
+    f: (a: A) => Kind<F, R, O, E, Either<C, B>>
+  ): Kind<
+    F,
+    R,
+    O,
+    E,
+    [
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>,
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, C>
+    ]
+  > => {
     return F.map(traverse(F)(self, f), ReadonlyRecord.separate)
@@ -71,15 +91,37 @@ })
     f: (a: A) => Kind<F, R, O, E, Option<B>>
-  ): (self: ReadonlyRecord.ReadonlyRecord<A>) => Kind<F, R, O, E, Record<string, B>>
-  <A, R, O, E, B>(
-    self: ReadonlyRecord.ReadonlyRecord<A>,
+  ): <K extends string>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>
+  ) => Kind<F, R, O, E, Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>>
+  <K extends string, A, R, O, E, B>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>,
     f: (a: A) => Kind<F, R, O, E, Option<B>>
-  ): Kind<F, R, O, E, Record<string, B>>
+  ): Kind<F, R, O, E, Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>>
 } =>
-  dual(2, <A, R, O, E, B>(
-    self: ReadonlyRecord.ReadonlyRecord<A>,
+  dual(2, <K extends string, A, R, O, E, B>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>,
     f: (a: A) => Kind<F, R, O, E, Option<B>>
-  ): Kind<F, R, O, E, Record<string, B>> => {
+  ): Kind<F, R, O, E, Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>> => {
     return F.map(traverse(F)(self, f), ReadonlyRecord.getSomes)
   })
 
+const _map: covariant.Covariant<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>["map"] = ReadonlyRecord.map
+
+const _imap = covariant.imap<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>(_map)
+
+const _partitionMap: filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>["partitionMap"] =
+  ReadonlyRecord.partitionMap
+
+const _filterMap: filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>["filterMap"] =
+  ReadonlyRecord.filterMap
+
+const _traverse: traversable.Traversable<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>["traverse"] = traverse
+
+const _traversePartitionMap: traversableFilterable.TraversableFilterable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<any>
+>["traversePartitionMap"] = traversePartitionMap
+
+const _traverseFilterMap: traversableFilterable.TraversableFilterable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<any>
+>["traverseFilterMap"] = traverseFilterMap
+
 /**
@@ -89,6 +131,8 @@ * @category instances
  */
-export const Covariant: covariant.Covariant<ReadonlyRecord.ReadonlyRecordTypeLambda> = {
-  imap,
-  map
-}
+export const getCovariant = <K extends string>(): covariant.Covariant<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  imap: _imap,
+  map: _map
+})
 
@@ -99,5 +143,3 @@ /**
  */
-export const Invariant: invariant.Invariant<ReadonlyRecord.ReadonlyRecordTypeLambda> = {
-  imap
-}
+export const Covariant = getCovariant()
 
@@ -108,6 +150,7 @@ /**
  */
-export const Filterable: filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda> = {
-  partitionMap,
-  filterMap
-}
+export const getInvariant = <K extends string>(): invariant.Invariant<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  imap: _imap
+})
 
@@ -118,5 +161,3 @@ /**
  */
-export const Traversable: traversable.Traversable<ReadonlyRecord.ReadonlyRecordTypeLambda> = {
-  traverse
-}
+export const Invariant = getInvariant()
 
@@ -127,7 +168,46 @@ /**
  */
-export const TraversableFilterable: traversableFilterable.TraversableFilterable<
-  ReadonlyRecord.ReadonlyRecordTypeLambda
-> = {
-  traversePartitionMap,
-  traverseFilterMap
-}
+export const getFilterable = <K extends string>(): filterable.Filterable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  partitionMap: _partitionMap,
+  filterMap: _filterMap
+})
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const Filterable = getFilterable()
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const getTraversable = <K extends string>(): traversable.Traversable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  traverse: _traverse
+})
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const Traversable = getTraversable()
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const getTraversableFilterable = <K extends string>(): traversableFilterable.TraversableFilterable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  traversePartitionMap: _traversePartitionMap,
+  traverseFilterMap: _traverseFilterMap
+})
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const TraversableFilterable = getTraversableFilterable()

src/Filterable.ts

@@ -19,7 +19,7 @@ /**
     <A, B, C>(
-      f: (a: A) => Either.Either<B, C>
+      f: (a: A) => Either.Either<C, B>
     ): <R, O, E>(self: Kind<F, R, O, E, A>) => [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>]
     <R, O, E, A, B, C>(
       self: Kind<F, R, O, E, A>,
-      f: (a: A) => Either.Either<B, C>
+      f: (a: A) => Either.Either<C, B>
     ): [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>]
@@ -47,3 +47,3 @@ }
   self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>,
-  f: (a: A) => Either.Either<B, C>
+  f: (a: A) => Either.Either<C, B>
 ): [Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, B>>, Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, C>>] => {
@@ -84,3 +84,3 @@ const filterMap = filterMapComposition(F, G)
 ): <R, O, E, A, B>(
-  self: Kind<F, R, O, E, Either.Either<A, B>>
+  self: Kind<F, R, O, E, Either.Either<B, A>>
 ) => [Kind<F, R, O, E, A>, Kind<F, R, O, E, B>] => F.partitionMap(identity)
@@ -87,0 +87,0 @@

src/TraversableFilterable.ts

@@ -27,3 +27,3 @@ /**
     <A, R, O, E, B, C>(
-      f: (a: A) => Kind<F, R, O, E, Either<B, C>>
+      f: (a: A) => Kind<F, R, O, E, Either<C, B>>
     ): <TR, TO, TE>(
@@ -34,3 +34,3 @@ self: Kind<T, TR, TO, TE, A>
       self: Kind<T, TR, TO, TE, A>,
-      f: (a: A) => Kind<F, R, O, E, Either<B, C>>
+      f: (a: A) => Kind<F, R, O, E, Either<C, B>>
     ): Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>
@@ -63,3 +63,3 @@ }
   self: Kind<T, TR, TO, TE, A>,
-  f: (a: A) => Kind<F, R, O, E, Either<B, C>>
+  f: (a: A) => Kind<F, R, O, E, Either<C, B>>
 ) => Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]> =>
@@ -66,0 +66,0 @@ (F) =>

No alert changes

Improved metrics

Total package byte prevSize

538765

increased by1.26%

Lines of code

11125

increased by1.47%

No dependency changes