@fp-ts/core - npm Package Compare versions

Comparing version 0.0.6 to 0.0.7

package.json

 {
   "name": "@fp-ts/core",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "license": "MIT",
@@ -5,0 +5,0 @@ "repository": {

src/typeclass/Coproduct.ts

@@ -25,4 +25,4 @@ /**
 export const getMonoid = <F extends TypeLambda>(F: Coproduct<F>) =>
-  <A>(): Monoid<
-    Kind<F, unknown, never, never, A>
+  <R, O, E, A>(): Monoid<
+    Kind<F, R, O, E, A>
   > => ({
@@ -29,0 +29,0 @@ ...nonEmptyCoproduct.getSemigroup(F)(),

src/typeclass/Foldable.ts

@@ -20,7 +20,2 @@ /**
   ) => <R, O, E>(self: Kind<F, R, O, E, A>) => B
-
-  readonly reduceRight: <A, B>(
-    b: B,
-    f: (b: B, a: A) => B
-  ) => <R, O, E>(self: Kind<F, R, O, E, A>) => B
 }
@@ -43,14 +38,11 @@
 /**
- * Returns a default `reduceRight` composition.
- *
  * @since 1.0.0
  */
-export const reduceRightComposition = <F extends TypeLambda, G extends TypeLambda>(
-  F: Foldable<F>,
-  G: Foldable<G>
+export const reduceRight = <F extends TypeLambda>(
+  F: Foldable<F>
 ) =>
-  <B, A>(b: B, f: (b: B, a: A) => B) =>
-    <FR, FO, FE, GR, GO, GE>(
-      self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>
-    ): B => pipe(self, F.reduceRight(b, (b, ga) => pipe(ga, G.reduceRight(b, f))))
+  <A, B>(
+    b: B,
+    f: (b: B, a: A) => B
+  ) => <R, O, E>(self: Kind<F, R, O, E, A>): B => toReadonlyArray(F)(self).reduceRight(f, b)
 
@@ -68,9 +60,2 @@ /**
  */
-export const toReadonlyArray = <F extends TypeLambda>(
-  F: Foldable<F>
-): <R, O, E, A>(self: Kind<F, R, O, E, A>) => ReadonlyArray<A> => toReadonlyArrayWith(F)(identity)
-
-/**
- * @since 1.0.0
- */
 export const toReadonlyArrayWith = <F extends TypeLambda>(
@@ -89,2 +74,9 @@ F: Foldable<F>
  */
+export const toReadonlyArray = <F extends TypeLambda>(
+  F: Foldable<F>
+): <R, O, E, A>(self: Kind<F, R, O, E, A>) => ReadonlyArray<A> => toReadonlyArrayWith(F)(identity)
+
+/**
+ * @since 1.0.0
+ */
 export const reduceKind = <F extends TypeLambda>(F: Foldable<F>) =>
@@ -110,3 +102,3 @@ <G extends TypeLambda>(G: Monad<G>) =>
     ): <FR, FO, FE>(self: Kind<F, FR, FO, FE, A>) => Kind<G, R, O, E, B> =>
-      F.reduceRight<A, Kind<G, R, O, E, B>>(
+      reduceRight(F)<A, Kind<G, R, O, E, B>>(
         G.of(b),
@@ -113,0 +105,0 @@ (gb, a) => pipe(gb, G.flatMap(b => f(b, a)))

src/typeclass/NonEmptyCoproduct.ts

@@ -31,4 +31,4 @@ /**
 export const getSemigroup = <F extends TypeLambda>(F: NonEmptyCoproduct<F>) =>
-  <A>(): Semigroup<
-    Kind<F, unknown, never, never, A>
+  <R, O, E, A>(): Semigroup<
+    Kind<F, R, O, E, A>
   > => ({
@@ -35,0 +35,0 @@ combine: F.coproduct,

src/typeclass/NonEmptyProduct.ts

@@ -142,5 +142,5 @@ /**
  */
-export const tuple = <F extends TypeLambda>(F: NonEmptyProduct<F>) =>
+export const nonEmptyTuple = <F extends TypeLambda>(F: NonEmptyProduct<F>) =>
   <T extends [Kind<F, any, any, any, any>, ...ReadonlyArray<Kind<F, any, any, any, any>>]>(
-    ...tuple: T
+    ...components: T
   ): Kind<
@@ -152,3 +152,3 @@ F,
     Readonly<{ [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never }>
-  > => F.productMany(tuple.slice(1))(tuple[0]) as any
+  > => F.productMany(components.slice(1))(components[0]) as any
 
@@ -160,5 +160,5 @@ type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R
  */
-export const struct = <F extends TypeLambda>(F: NonEmptyProduct<F>) =>
+export const nonEmptyStruct = <F extends TypeLambda>(F: NonEmptyProduct<F>) =>
   <R extends Record<string, Kind<F, any, any, any, any>>>(
-    r: EnforceNonEmptyRecord<R> & Record<string, Kind<F, any, any, any, any>>
+    fields: EnforceNonEmptyRecord<R> & Record<string, Kind<F, any, any, any, any>>
   ): Kind<
@@ -171,5 +171,5 @@ F,
   > => {
-    const keys = Object.keys(r)
+    const keys = Object.keys(fields)
     return pipe(
-      F.productMany(keys.slice(1).map(k => r[k]))(r[keys[0]]),
+      F.productMany(keys.slice(1).map(k => fields[k]))(fields[keys[0]]),
       F.imap(([value, ...values]) => {
@@ -176,0 +176,0 @@ const out: any = { [keys[0]]: value }

src/typeclass/NonEmptyTraversable.ts

@@ -7,3 +7,4 @@ /**
 import type { Kind, TypeClass, TypeLambda } from "@fp-ts/core/HKT"
-import { identity } from "@fp-ts/core/internal/Function"
+import { identity, pipe } from "@fp-ts/core/internal/Function"
+import type { Covariant } from "@fp-ts/core/typeclass/Covariant"
 import type { NonEmptyApplicative } from "@fp-ts/core/typeclass/NonEmptyApplicative"
@@ -16,3 +17,3 @@
 export interface NonEmptyTraversable<T extends TypeLambda> extends TypeClass<T> {
-  readonly nonEmptyTraverse: <F extends TypeLambda>(
+  readonly traverseNonEmpty: <F extends TypeLambda>(
     F: NonEmptyApplicative<F>
@@ -24,10 +25,16 @@ ) => <A, R, O, E, B>(
   ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>
+
+  readonly sequenceNonEmpty: <F extends TypeLambda>(
+    F: NonEmptyApplicative<F>
+  ) => <TR, TO, TE, R, O, E, A>(
+    self: Kind<T, TR, TO, TE, Kind<F, R, O, E, A>>
+  ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>
 }
 
 /**
- * Returns a default `nonEmptyTraverse` composition.
+ * Returns a default `traverseNonEmpty` composition.
  *
  * @since 1.0.0
  */
-export const nonEmptyTraverseComposition = <T extends TypeLambda, F extends TypeLambda>(
+export const traverseNonEmptyComposition = <T extends TypeLambda, F extends TypeLambda>(
   T: NonEmptyTraversable<T>,
@@ -40,10 +47,29 @@ G: NonEmptyTraversable<F>
     ): (<TR, TO, TE, GR, GO, GE>(
-      tfa: Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, A>>
+      self: Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, A>>
     ) => Kind<G, R, O, E, Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, B>>>) =>
-      T.nonEmptyTraverse(F)(G.nonEmptyTraverse(F)(f))
+      T.traverseNonEmpty(F)(G.traverseNonEmpty(F)(f))
 
 /**
+ * Returns a default `sequenceNonEmpty` composition.
+ *
  * @since 1.0.0
  */
-export const nonEmptySequence = <T extends TypeLambda>(T: NonEmptyTraversable<T>) =>
+export const sequenceNonEmptyComposition = <T extends TypeLambda, F extends TypeLambda>(
+  T: NonEmptyTraversable<T> & Covariant<T>,
+  G: NonEmptyTraversable<F>
+) =>
+  <G extends TypeLambda>(F: NonEmptyApplicative<G>) =>
+    <TR, TO, TE, GR, GO, GE, R, O, E, A>(
+      self: Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, Kind<G, R, O, E, A>>>
+    ): Kind<G, R, O, E, Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, A>>> =>
+      T.sequenceNonEmpty(F)(pipe(self, T.map(G.sequenceNonEmpty(F))))
+
+/**
+ * Returns a default `sequenceNonEmpty` implementation.
+ *
+ * @since 1.0.0
+ */
+export const sequenceNonEmpty = <T extends TypeLambda>(
+  traverseNonEmpty: NonEmptyTraversable<T>["traverseNonEmpty"]
+): NonEmptyTraversable<T>["sequenceNonEmpty"] =>
   <F extends TypeLambda>(
@@ -53,2 +79,2 @@ F: NonEmptyApplicative<F>
     self: Kind<T, TR, TO, TE, Kind<F, R, O, E, A>>
-  ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>) => T.nonEmptyTraverse(F)(identity)
+  ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>) => traverseNonEmpty(F)(identity)

src/typeclass/Product.ts

@@ -23,3 +23,3 @@ /**
 export const tuple = <F extends TypeLambda>(F: Product<F>) =>
-  <T extends ReadonlyArray<Kind<F, any, any, any, any>>>(...tuple: T): Kind<
+  <T extends ReadonlyArray<Kind<F, any, any, any, any>>>(...components: T): Kind<
     F,
@@ -30,3 +30,3 @@ ([T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never),
     Readonly<{ [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never }>
-  > => F.productAll(tuple) as any
+  > => F.productAll(components) as any
 
@@ -37,3 +37,3 @@ /**
 export const struct = <F extends TypeLambda>(F: Product<F>) =>
-  <R extends Record<string, Kind<F, any, any, any, any>>>(r: R): Kind<
+  <R extends Record<string, Kind<F, any, any, any, any>>>(fields: R): Kind<
     F,
@@ -45,5 +45,5 @@ ([R[keyof R]] extends [Kind<F, infer R, any, any, any>] ? R : never),
   > => {
-    const keys = Object.keys(r)
+    const keys = Object.keys(fields)
     return pipe(
-      F.productAll(keys.map(k => r[k])),
+      F.productAll(keys.map(k => fields[k])),
       F.imap(values => {
@@ -50,0 +50,0 @@ const out: any = {}

src/typeclass/Traversable.ts

@@ -7,2 +7,3 @@ /**
 import type { Applicative } from "@fp-ts/core/typeclass/Applicative"
+import type { Covariant } from "@fp-ts/core/typeclass/Covariant"
 
@@ -19,2 +20,6 @@ /**
   ) => <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>
+
+  readonly sequence: <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, R, O, E, A>(
+    self: Kind<T, TR, TO, TE, Kind<F, R, O, E, A>>
+  ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>
 }
@@ -35,3 +40,3 @@
     ): (<TR, TO, TE, GR, GO, GE>(
-      tga: Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, A>>
+      self: Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, A>>
     ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, B>>>) =>
@@ -41,8 +46,27 @@ T.traverse(F)(G.traverse(F)(f))
 /**
+ * Returns a default `sequence` composition.
+ *
  * @since 1.0.0
  */
-export const sequence = <T extends TypeLambda>(T: Traversable<T>) =>
+export const sequenceComposition = <T extends TypeLambda, G extends TypeLambda>(
+  T: Traversable<T> & Covariant<T>,
+  G: Traversable<G>
+) =>
+  <F extends TypeLambda>(F: Applicative<F>) =>
+    <TR, TO, TE, GR, GO, GE, R, O, E, A>(
+      self: Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, Kind<F, R, O, E, A>>>
+    ): Kind<F, R, O, E, Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, A>>> =>
+      T.sequence(F)(pipe(self, T.map(G.sequence(F))))
+
+/**
+ * Returns a default `sequence` implementation.
+ *
+ * @since 1.0.0
+ */
+export const sequence = <T extends TypeLambda>(
+  traverse: Traversable<T>["traverse"]
+): Traversable<T>["sequence"] =>
   <F extends TypeLambda>(F: Applicative<F>): (<TR, TO, TE, R, O, E, A>(
     self: Kind<T, TR, TO, TE, Kind<F, R, O, E, A>>
-  ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>) => T.traverse(F)(identity)
+  ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>) => traverse(F)(identity)
 
@@ -49,0 +73,0 @@ /**

typeclass/Coproduct.d.ts

@@ -18,3 +18,3 @@ /**
  */
-export declare const getMonoid: <F extends TypeLambda>(F: Coproduct<F>) => <A>() => Monoid<Kind<F, unknown, never, never, A>>;
+export declare const getMonoid: <F extends TypeLambda>(F: Coproduct<F>) => <R, O, E, A>() => Monoid<Kind<F, R, O, E, A>>;
 //# sourceMappingURL=Coproduct.d.ts.map

typeclass/Foldable.d.ts

@@ -14,3 +14,2 @@ /**
     readonly reduce: <A, B>(b: B, f: (b: B, a: A) => B) => <R, O, E>(self: Kind<F, R, O, E, A>) => B;
-    readonly reduceRight: <A, B>(b: B, f: (b: B, a: A) => B) => <R, O, E>(self: Kind<F, R, O, E, A>) => B;
 }
@@ -24,7 +23,5 @@ /**
 /**
- * Returns a default `reduceRight` composition.
- *
  * @since 1.0.0
  */
-export declare const reduceRightComposition: <F extends TypeLambda, G extends TypeLambda>(F: Foldable<F>, G: Foldable<G>) => <B, A>(b: B, f: (b: B, a: A) => B) => <FR, FO, FE, GR, GO, GE>(self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>) => B;
+export declare const reduceRight: <F extends TypeLambda>(F: Foldable<F>) => <A, B>(b: B, f: (b: B, a: A) => B) => <R, O, E>(self: Kind<F, R, O, E, A>) => B;
 /**
@@ -37,7 +34,7 @@ * @since 1.0.0
  */
-export declare const toReadonlyArray: <F extends TypeLambda>(F: Foldable<F>) => <R, O, E, A>(self: Kind<F, R, O, E, A>) => readonly A[];
+export declare const toReadonlyArrayWith: <F extends TypeLambda>(F: Foldable<F>) => <A, B>(f: (a: A) => B) => <R, O, E>(self: Kind<F, R, O, E, A>) => readonly B[];
 /**
  * @since 1.0.0
  */
-export declare const toReadonlyArrayWith: <F extends TypeLambda>(F: Foldable<F>) => <A, B>(f: (a: A) => B) => <R, O, E>(self: Kind<F, R, O, E, A>) => readonly B[];
+export declare const toReadonlyArray: <F extends TypeLambda>(F: Foldable<F>) => <R, O, E, A>(self: Kind<F, R, O, E, A>) => readonly A[];
 /**
@@ -44,0 +41,0 @@ * @since 1.0.0

typeclass/Foldable.js

@@ -6,3 +6,3 @@ "use strict";
 });
-exports.toReadonlyArrayWith = exports.toReadonlyArray = exports.reduceRightKind = exports.reduceRightComposition = exports.reduceKind = exports.reduceComposition = exports.foldMapKind = exports.foldMap = void 0;
+exports.toReadonlyArrayWith = exports.toReadonlyArray = exports.reduceRightKind = exports.reduceRight = exports.reduceKind = exports.reduceComposition = exports.foldMapKind = exports.foldMap = void 0;
 
@@ -22,4 +22,2 @@ var _Function = /*#__PURE__*/require("@fp-ts/core/internal/Function");
 /**
- * Returns a default `reduceRight` composition.
- *
  * @since 1.0.0
@@ -31,3 +29,3 @@ */
 
-const reduceRightComposition = (F, G) => (b, f) => self => (0, _Function.pipe)(self, F.reduceRight(b, (b, ga) => (0, _Function.pipe)(ga, G.reduceRight(b, f))));
+const reduceRight = F => (b, f) => self => toReadonlyArray(F)(self).reduceRight(f, b);
 /**
@@ -38,3 +36,3 @@ * @since 1.0.0
 
-exports.reduceRightComposition = reduceRightComposition;
+exports.reduceRight = reduceRight;
 
@@ -49,3 +47,6 @@ const foldMap = F => M => f => self => M.combineAll(toReadonlyArrayWith(F)(f)(self));
 
-const toReadonlyArray = F => toReadonlyArrayWith(F)(_Function.identity);
+const toReadonlyArrayWith = F => f => self => F.reduce([], (out, a) => {
+  out.push(f(a));
+  return out;
+})(self);
 /**
@@ -56,8 +57,5 @@ * @since 1.0.0
 
-exports.toReadonlyArray = toReadonlyArray;
+exports.toReadonlyArrayWith = toReadonlyArrayWith;
 
-const toReadonlyArrayWith = F => f => self => F.reduce([], (out, a) => {
-  out.push(f(a));
-  return out;
-})(self);
+const toReadonlyArray = F => toReadonlyArrayWith(F)(_Function.identity);
 /**
@@ -68,3 +66,3 @@ * @since 1.0.0
 
-exports.toReadonlyArrayWith = toReadonlyArrayWith;
+exports.toReadonlyArray = toReadonlyArray;
 
@@ -79,3 +77,3 @@ const reduceKind = F => G => (b, f) => F.reduce(G.of(b), (gb, a) => (0, _Function.pipe)(gb, G.flatMap(b => f(b, a))));
 
-const reduceRightKind = F => G => (b, f) => F.reduceRight(G.of(b), (gb, a) => (0, _Function.pipe)(gb, G.flatMap(b => f(b, a))));
+const reduceRightKind = F => G => (b, f) => reduceRight(F)(G.of(b), (gb, a) => (0, _Function.pipe)(gb, G.flatMap(b => f(b, a))));
 /**
@@ -82,0 +80,0 @@ * @since 1.0.0

typeclass/NonEmptyCoproduct.d.ts

@@ -19,3 +19,3 @@ /**
  */
-export declare const getSemigroup: <F extends TypeLambda>(F: NonEmptyCoproduct<F>) => <A>() => Semigroup<Kind<F, unknown, never, never, A>>;
+export declare const getSemigroup: <F extends TypeLambda>(F: NonEmptyCoproduct<F>) => <R, O, E, A>() => Semigroup<Kind<F, R, O, E, A>>;
 /**
@@ -22,0 +22,0 @@ * @since 1.0.0

typeclass/NonEmptyProduct.d.ts

@@ -46,3 +46,3 @@ /**
  */
-export declare const tuple: <F extends TypeLambda>(F: NonEmptyProduct<F>) => <T extends [Kind<F, any, any, any, any>, ...Kind<F, any, any, any, any>[]]>(...tuple: T) => Kind<F, [T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never, [T[number]] extends [Kind<F, any, infer O, any, any>] ? O : never, [T[number]] extends [Kind<F, any, any, infer E, any>] ? E : never, Readonly<{ [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>>;
+export declare const nonEmptyTuple: <F extends TypeLambda>(F: NonEmptyProduct<F>) => <T extends [Kind<F, any, any, any, any>, ...Kind<F, any, any, any, any>[]]>(...components: T) => Kind<F, [T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never, [T[number]] extends [Kind<F, any, infer O, any, any>] ? O : never, [T[number]] extends [Kind<F, any, any, infer E, any>] ? E : never, Readonly<{ [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>>;
 declare type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R;
@@ -52,4 +52,4 @@ /**
  */
-export declare const struct: <F extends TypeLambda>(F: NonEmptyProduct<F>) => <R extends Record<string, Kind<F, any, any, any, any>>>(r: EnforceNonEmptyRecord<R> & Record<string, Kind<F, any, any, any, any>>) => Kind<F, [R[keyof R]] extends [Kind<F, infer R_1, any, any, any>] ? R_1 : never, [R[keyof R]] extends [Kind<F, any, infer O, any, any>] ? O : never, [R[keyof R]] extends [Kind<F, any, any, infer E, any>] ? E : never, { readonly [K in keyof R]: [R[K]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
+export declare const nonEmptyStruct: <F extends TypeLambda>(F: NonEmptyProduct<F>) => <R extends Record<string, Kind<F, any, any, any, any>>>(fields: EnforceNonEmptyRecord<R> & Record<string, Kind<F, any, any, any, any>>) => Kind<F, [R[keyof R]] extends [Kind<F, infer R_1, any, any, any>] ? R_1 : never, [R[keyof R]] extends [Kind<F, any, infer O, any, any>] ? O : never, [R[keyof R]] extends [Kind<F, any, any, infer E, any>] ? E : never, { readonly [K in keyof R]: [R[K]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
 export {};
 //# sourceMappingURL=NonEmptyProduct.d.ts.map

typeclass/NonEmptyProduct.js

@@ -6,3 +6,3 @@ "use strict";
 });
-exports.tuple = exports.struct = exports.productManyComposition = exports.productMany = exports.productFlatten = exports.productComposition = exports.bindKind = void 0;
+exports.productManyComposition = exports.productMany = exports.productFlatten = exports.productComposition = exports.nonEmptyTuple = exports.nonEmptyStruct = exports.bindKind = void 0;
 
@@ -74,3 +74,3 @@ var _Function = /*#__PURE__*/require("@fp-ts/core/internal/Function");
 
-const tuple = F => (...tuple) => F.productMany(tuple.slice(1))(tuple[0]);
+const nonEmptyTuple = F => (...components) => F.productMany(components.slice(1))(components[0]);
 /**
@@ -81,7 +81,7 @@ * @since 1.0.0
 
-exports.tuple = tuple;
+exports.nonEmptyTuple = nonEmptyTuple;
 
-const struct = F => r => {
-  const keys = Object.keys(r);
-  return (0, _Function.pipe)(F.productMany(keys.slice(1).map(k => r[k]))(r[keys[0]]), F.imap(([value, ...values]) => {
+const nonEmptyStruct = F => fields => {
+  const keys = Object.keys(fields);
+  return (0, _Function.pipe)(F.productMany(keys.slice(1).map(k => fields[k]))(fields[keys[0]]), F.imap(([value, ...values]) => {
     const out = {
@@ -99,3 +99,3 @@ [keys[0]]: value
 
-exports.struct = struct;
+exports.nonEmptyStruct = nonEmptyStruct;
 //# sourceMappingURL=NonEmptyProduct.js.map

typeclass/NonEmptyTraversable.d.ts

@@ -7,2 +7,3 @@ /**
 import type { Kind, TypeClass, TypeLambda } from "@fp-ts/core/HKT";
+import type { Covariant } from "@fp-ts/core/typeclass/Covariant";
 import type { NonEmptyApplicative } from "@fp-ts/core/typeclass/NonEmptyApplicative";
@@ -14,14 +15,23 @@ /**
 export interface NonEmptyTraversable<T extends TypeLambda> extends TypeClass<T> {
-    readonly nonEmptyTraverse: <F extends TypeLambda>(F: NonEmptyApplicative<F>) => <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>) => <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>;
+    readonly traverseNonEmpty: <F extends TypeLambda>(F: NonEmptyApplicative<F>) => <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>) => <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>;
+    readonly sequenceNonEmpty: <F extends TypeLambda>(F: NonEmptyApplicative<F>) => <TR, TO, TE, R, O, E, A>(self: Kind<T, TR, TO, TE, Kind<F, R, O, E, A>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>;
 }
 /**
- * Returns a default `nonEmptyTraverse` composition.
+ * Returns a default `traverseNonEmpty` composition.
  *
  * @since 1.0.0
  */
-export declare const nonEmptyTraverseComposition: <T extends TypeLambda, F extends TypeLambda>(T: NonEmptyTraversable<T>, G: NonEmptyTraversable<F>) => <G extends TypeLambda>(F: NonEmptyApplicative<G>) => <A, R, O, E, B>(f: (a: A) => Kind<G, R, O, E, B>) => <TR, TO, TE, GR, GO, GE>(tfa: Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, A>>) => Kind<G, R, O, E, Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, B>>>;
+export declare const traverseNonEmptyComposition: <T extends TypeLambda, F extends TypeLambda>(T: NonEmptyTraversable<T>, G: NonEmptyTraversable<F>) => <G extends TypeLambda>(F: NonEmptyApplicative<G>) => <A, R, O, E, B>(f: (a: A) => Kind<G, R, O, E, B>) => <TR, TO, TE, GR, GO, GE>(self: Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, A>>) => Kind<G, R, O, E, Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, B>>>;
 /**
+ * Returns a default `sequenceNonEmpty` composition.
+ *
  * @since 1.0.0
  */
-export declare const nonEmptySequence: <T extends TypeLambda>(T: NonEmptyTraversable<T>) => <F extends TypeLambda>(F: NonEmptyApplicative<F>) => <TR, TO, TE, R, O, E, A>(self: Kind<T, TR, TO, TE, Kind<F, R, O, E, A>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>;
+export declare const sequenceNonEmptyComposition: <T extends TypeLambda, F extends TypeLambda>(T: NonEmptyTraversable<T> & Covariant<T>, G: NonEmptyTraversable<F>) => <G extends TypeLambda>(F: NonEmptyApplicative<G>) => <TR, TO, TE, GR, GO, GE, R, O, E, A>(self: Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, Kind<G, R, O, E, A>>>) => Kind<G, R, O, E, Kind<T, TR, TO, TE, Kind<F, GR, GO, GE, A>>>;
+/**
+ * Returns a default `sequenceNonEmpty` implementation.
+ *
+ * @since 1.0.0
+ */
+export declare const sequenceNonEmpty: <T extends TypeLambda>(traverseNonEmpty: <F extends TypeLambda>(F: NonEmptyApplicative<F>) => <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>) => <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>) => <F_1 extends TypeLambda>(F: NonEmptyApplicative<F_1>) => <TR_1, TO_1, TE_1, R_1, O_1, E_1, A_1>(self: Kind<T, TR_1, TO_1, TE_1, Kind<F_1, R_1, O_1, E_1, A_1>>) => Kind<F_1, R_1, O_1, E_1, Kind<T, TR_1, TO_1, TE_1, A_1>>;
 //# sourceMappingURL=NonEmptyTraversable.d.ts.map

typeclass/NonEmptyTraversable.js

@@ -6,3 +6,3 @@ "use strict";
 });
-exports.nonEmptyTraverseComposition = exports.nonEmptySequence = void 0;
+exports.traverseNonEmptyComposition = exports.sequenceNonEmptyComposition = exports.sequenceNonEmpty = void 0;
 
@@ -12,8 +12,10 @@ var _Function = /*#__PURE__*/require("@fp-ts/core/internal/Function");
 /**
- * Returns a default `nonEmptyTraverse` composition.
+ * Returns a default `traverseNonEmpty` composition.
  *
  * @since 1.0.0
  */
-const nonEmptyTraverseComposition = (T, G) => F => f => T.nonEmptyTraverse(F)(G.nonEmptyTraverse(F)(f));
+const traverseNonEmptyComposition = (T, G) => F => f => T.traverseNonEmpty(F)(G.traverseNonEmpty(F)(f));
 /**
+ * Returns a default `sequenceNonEmpty` composition.
+ *
  * @since 1.0.0
@@ -23,7 +25,17 @@ */
 
-exports.nonEmptyTraverseComposition = nonEmptyTraverseComposition;
+exports.traverseNonEmptyComposition = traverseNonEmptyComposition;
 
-const nonEmptySequence = T => F => T.nonEmptyTraverse(F)(_Function.identity);
+const sequenceNonEmptyComposition = (T, G) => F => self => T.sequenceNonEmpty(F)((0, _Function.pipe)(self, T.map(G.sequenceNonEmpty(F))));
+/**
+ * Returns a default `sequenceNonEmpty` implementation.
+ *
+ * @since 1.0.0
+ */
 
-exports.nonEmptySequence = nonEmptySequence;
+
+exports.sequenceNonEmptyComposition = sequenceNonEmptyComposition;
+
+const sequenceNonEmpty = traverseNonEmpty => F => traverseNonEmpty(F)(_Function.identity);
+
+exports.sequenceNonEmpty = sequenceNonEmpty;
 //# sourceMappingURL=NonEmptyTraversable.js.map

typeclass/Product.d.ts

@@ -17,7 +17,7 @@ /**
  */
-export declare const tuple: <F extends TypeLambda>(F: Product<F>) => <T extends readonly Kind<F, any, any, any, any>[]>(...tuple: T) => Kind<F, [T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never, [T[number]] extends [Kind<F, any, infer O, any, any>] ? O : never, [T[number]] extends [Kind<F, any, any, infer E, any>] ? E : never, Readonly<{ [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>>;
+export declare const tuple: <F extends TypeLambda>(F: Product<F>) => <T extends readonly Kind<F, any, any, any, any>[]>(...components: T) => Kind<F, [T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never, [T[number]] extends [Kind<F, any, infer O, any, any>] ? O : never, [T[number]] extends [Kind<F, any, any, infer E, any>] ? E : never, Readonly<{ [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>>;
 /**
  * @since 1.0.0
  */
-export declare const struct: <F extends TypeLambda>(F: Product<F>) => <R extends Record<string, Kind<F, any, any, any, any>>>(r: R) => Kind<F, [R[keyof R]] extends [Kind<F, infer R_1, any, any, any>] ? R_1 : never, [R[keyof R]] extends [Kind<F, any, infer O, any, any>] ? O : never, [R[keyof R]] extends [Kind<F, any, any, infer E, any>] ? E : never, { readonly [K in keyof R]: [R[K]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
+export declare const struct: <F extends TypeLambda>(F: Product<F>) => <R extends Record<string, Kind<F, any, any, any, any>>>(fields: R) => Kind<F, [R[keyof R]] extends [Kind<F, infer R_1, any, any, any>] ? R_1 : never, [R[keyof R]] extends [Kind<F, any, infer O, any, any>] ? O : never, [R[keyof R]] extends [Kind<F, any, any, infer E, any>] ? E : never, { readonly [K in keyof R]: [R[K]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
 //# sourceMappingURL=Product.d.ts.map

typeclass/Product.js

@@ -13,3 +13,3 @@ "use strict";
  */
-const tuple = F => (...tuple) => F.productAll(tuple);
+const tuple = F => (...components) => F.productAll(components);
 /**
@@ -22,5 +22,5 @@ * @since 1.0.0
 
-const struct = F => r => {
-  const keys = Object.keys(r);
-  return (0, _Function.pipe)(F.productAll(keys.map(k => r[k])), F.imap(values => {
+const struct = F => fields => {
+  const keys = Object.keys(fields);
+  return (0, _Function.pipe)(F.productAll(keys.map(k => fields[k])), F.imap(values => {
     const out = {};
@@ -27,0 +27,0 @@

typeclass/Traversable.d.ts

@@ -6,2 +6,3 @@ /**
 import type { Applicative } from "@fp-ts/core/typeclass/Applicative";
+import type { Covariant } from "@fp-ts/core/typeclass/Covariant";
 /**
@@ -13,2 +14,3 @@ * @category type class
     readonly traverse: <F extends TypeLambda>(F: Applicative<F>) => <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>) => <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>;
+    readonly sequence: <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, R, O, E, A>(self: Kind<T, TR, TO, TE, Kind<F, R, O, E, A>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>;
 }
@@ -20,8 +22,16 @@ /**
  */
-export declare const traverseComposition: <T extends TypeLambda, G extends TypeLambda>(T: Traversable<T>, G: Traversable<G>) => <F extends TypeLambda>(F: Applicative<F>) => <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>) => <TR, TO, TE, GR, GO, GE>(tga: Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, A>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, B>>>;
+export declare const traverseComposition: <T extends TypeLambda, G extends TypeLambda>(T: Traversable<T>, G: Traversable<G>) => <F extends TypeLambda>(F: Applicative<F>) => <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>) => <TR, TO, TE, GR, GO, GE>(self: Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, A>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, B>>>;
 /**
+ * Returns a default `sequence` composition.
+ *
  * @since 1.0.0
  */
-export declare const sequence: <T extends TypeLambda>(T: Traversable<T>) => <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, R, O, E, A>(self: Kind<T, TR, TO, TE, Kind<F, R, O, E, A>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>;
+export declare const sequenceComposition: <T extends TypeLambda, G extends TypeLambda>(T: Traversable<T> & Covariant<T>, G: Traversable<G>) => <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, GR, GO, GE, R, O, E, A>(self: Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, Kind<F, R, O, E, A>>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, Kind<G, GR, GO, GE, A>>>;
 /**
+ * Returns a default `sequence` implementation.
+ *
+ * @since 1.0.0
+ */
+export declare const sequence: <T extends TypeLambda>(traverse: <F extends TypeLambda>(F: Applicative<F>) => <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>) => <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>) => <F_1 extends TypeLambda>(F: Applicative<F_1>) => <TR_1, TO_1, TE_1, R_1, O_1, E_1, A_1>(self: Kind<T, TR_1, TO_1, TE_1, Kind<F_1, R_1, O_1, E_1, A_1>>) => Kind<F_1, R_1, O_1, E_1, Kind<T, TR_1, TO_1, TE_1, A_1>>;
+/**
  * Given a function which returns a `F` effect, thread this effect
@@ -28,0 +38,0 @@ * through the running of this function on all the values in `T`,

typeclass/Traversable.js

@@ -6,3 +6,3 @@ "use strict";
 });
-exports.traverseTap = exports.traverseComposition = exports.sequence = void 0;
+exports.traverseTap = exports.traverseComposition = exports.sequenceComposition = exports.sequence = void 0;
 
@@ -18,2 +18,4 @@ var _Function = /*#__PURE__*/require("@fp-ts/core/internal/Function");
 /**
+ * Returns a default `sequence` composition.
+ *
  * @since 1.0.0
@@ -25,4 +27,14 @@ */
 
-const sequence = T => F => T.traverse(F)(_Function.identity);
+const sequenceComposition = (T, G) => F => self => T.sequence(F)((0, _Function.pipe)(self, T.map(G.sequence(F))));
 /**
+ * Returns a default `sequence` implementation.
+ *
+ * @since 1.0.0
+ */
+
+
+exports.sequenceComposition = sequenceComposition;
+
+const sequence = traverse => F => traverse(F)(_Function.identity);
+/**
  * Given a function which returns a `F` effect, thread this effect
@@ -29,0 +41,0 @@ * through the running of this function on all the values in `T`,

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

319820

increased by2%

Lines of code

6109

increased by1.5%

Number of medium supply chain risk alerts

0

decreased by-100%

No dependency changes