@matechs/effect - npm Package Compare versions

Comparing version 6.0.4 to 6.1.0

es6/effect.d.ts

@@ -18,3 +18,5 @@ import {
   Monad4EC,
+  Monad4ECP,
   MonadThrow4EC,
+  MonadThrow4ECP,
   Alt4EC,
@@ -163,3 +165,3 @@ Monad4EP,
  */
-export declare function raiseError<E, A = never>(e: E): SyncE<E, A>;
+export declare function raiseError<E>(e: E): SyncE<E, never>;
 /**
@@ -835,3 +837,3 @@ * An IO that is failed with an unchecked error
   fy: () => AsyncRE<R2, E2, A>
-): <R, E>(fx: AsyncRE<R, E, A>) => AsyncRE<R & R2, E2, A>;
+): <R, E, B>(fx: AsyncRE<R, E, B>) => AsyncRE<R & R2, E2, A | B>;
 export declare const effect: EffectMonad;
@@ -846,4 +848,3 @@ export declare const Do: () => import("./overloadEff").Do4CE<
 export declare const sequenceS: <NER extends Record<string, Effect<any, any, any, any>>>(
-  r: (keyof NER extends never ? never : NER) &
-    Record<string, import("./overloadEff").GE<any, any, any, any>>
+  r: (keyof NER extends never ? never : NER) & Record<string, Effect<any, any, any, any>>
 ) => Effect<
@@ -882,5 +883,5 @@ { [K in keyof NER]: import("./overloadEff").STypeOf<NER[K]> }[keyof NER],
 export declare const parEffect: Monad4EP<URI> & MonadThrow4EP<URI>;
-export declare const parDo: () => import("./overloadEff").Do4CEP<
+export declare const parDo: () => import("./overloadEff").Do4CE<
   "matechs/Effect",
-  never,
+  unknown,
   {},
@@ -1016,2 +1017,10 @@ unknown,
 ): Monad4EC<"matechs/Effect", E> & MonadThrow4EC<"matechs/Effect", E> & Alt4EC<"matechs/Effect", E>;
+export declare function getParValidationM<E>(
+  S: Sem.Semigroup<E>
+): Monad4ECP<"matechs/Effect", E> &
+  MonadThrow4ECP<"matechs/Effect", E> &
+  Alt4EC<"matechs/Effect", E>;
+export declare function getParCauseValidationM<E>(
+  S: Sem.Semigroup<ex.Cause<E>>
+): Monad4ECP<URI, E> & MonadThrow4ECP<URI, E> & Alt4EC<URI, E>;
 export declare function getCauseValidationM<E>(
@@ -1018,0 +1027,0 @@ S: Sem.Semigroup<ex.Cause<E>>

es6/effect.js

@@ -1005,2 +1005,24 @@ import { either as Ei, function as F, option as Op, array as Ar, tree as TR, record as RE } from "fp-ts";
 }
+export function getParValidationM(S) {
+    return getParCauseValidationM(getCauseSemigroup(S));
+}
+export function getParCauseValidationM(S) {
+    return {
+        URI,
+        _E: undefined,
+        _CTX: "async",
+        of: pure,
+        map: map_,
+        chain: chain_,
+        ap: (fab, fa) => chain_(parZip(result(fa), result(fab)), ([faEx, fabEx]) => fabEx._tag === "Done"
+            ? faEx._tag === "Done"
+                ? pure(fabEx.value(faEx.value))
+                : raised(faEx)
+            : faEx._tag === "Done"
+                ? raised(fabEx)
+                : raised(S.concat(fabEx, faEx))),
+        throwError: raiseError,
+        alt: (fa, fb) => foldExit_(fa, (e) => foldExit_(fb(), (fbe) => raised(S.concat(e, fbe)), pure), pure)
+    };
+}
 export function getCauseValidationM(S) {
@@ -1007,0 +1029,0 @@ return {

es6/managed.d.ts

@@ -253,4 +253,3 @@ import { function as F, semigroup as Sem, monoid as Mon } from "fp-ts";
 export declare const sequenceS: <NER extends Record<string, Managed<any, any, any, any>>>(
-  r: (keyof NER extends never ? never : NER) &
-    Record<string, import("./overloadEff").GE<any, any, any, any>>
+  r: (keyof NER extends never ? never : NER) & Record<string, Managed<any, any, any, any>>
 ) => Managed<
@@ -257,0 +256,0 @@ { [K in keyof NER]: import("./overloadEff").STypeOf<NER[K]> }[keyof NER],

es6/overloadEff.d.ts

@@ -56,12 +56,12 @@ import { Bifunctor4 } from "fp-ts/es6/Bifunctor";
 export interface Applicative4E<F extends MaURIS> extends Apply4E<F> {
-  readonly of: <S = never, R = unknown, E = never, A = unknown>(a: A) => Kind4<F, S, R, E, A>;
+  readonly of: <A>(a: A) => Kind4<F, never, unknown, never, A>;
 }
 export interface Applicative4EP<F extends MaURIS> extends Apply4EP<F> {
-  readonly of: <S = never, R = unknown, E = never, A = unknown>(a: A) => Kind4<F, S, R, E, A>;
+  readonly of: <A>(a: A) => Kind4<F, never, unknown, never, A>;
 }
 export interface Alt4E<F extends MaURIS> extends Functor4<F> {
-  readonly alt: <S1, S2, R, R2, E, E2, A>(
+  readonly alt: <S1, S2, R, R2, E, E2, A, B>(
     fx: Kind4<F, S1, R, E, A>,
-    fy: () => Kind4<F, S2, R2, E2, A>
-  ) => Kind4<F, S1 | S2, R & R2, E2, A>;
+    fy: () => Kind4<F, S2, R2, E2, B>
+  ) => Kind4<F, S1 | S2, R & R2, E2, A | B>;
 }
@@ -71,5 +71,9 @@ export interface Monad4E<M extends MaURIS> extends Applicative4E<M>, Chain4E<M> {}
 export interface Monad4EC<M extends MaURIS, E> extends Applicative4EC<M, E>, Chain4EC<M, E> {}
+export interface Monad4ECP<M extends MaURIS, E> extends Applicative4ECP<M, E>, Chain4ECP<M, E> {}
 export interface Applicative4EC<F extends MaURIS, E> extends Apply4EC<F, E> {
-  readonly of: <S, R, A>(a: A) => Kind4<F, S, R, E, A>;
+  readonly of: <A>(a: A) => Kind4<F, never, unknown, E, A>;
 }
+export interface Applicative4ECP<F extends MaURIS, E> extends Apply4ECP<F, E> {
+  readonly of: <A>(a: A) => Kind4<F, never, unknown, E, A>;
+}
 export interface Apply4EC<F extends MaURIS, E> extends Functor4EC<F, E> {
@@ -81,2 +85,9 @@ readonly ap: <S1, S2, R, R2, A, B>(
 }
+export interface Apply4ECP<F extends MaURIS, E> extends Functor4EC<F, E> {
+  _CTX: "async";
+  readonly ap: <S1, S2, R, R2, A, B>(
+    fab: Kind4<F, S1, R, E, (a: A) => B>,
+    fa: Kind4<F, S2, R2, E, A>
+  ) => Kind4<F, unknown, R & R2, E, B>;
+}
 export interface Chain4EC<F extends MaURIS, E> extends Apply4EC<F, E> {
@@ -88,2 +99,8 @@ readonly chain: <S1, S2, R, A, R2, B>(
 }
+export interface Chain4ECP<F extends MaURIS, E> extends Apply4ECP<F, E> {
+  readonly chain: <S1, S2, R, A, R2, B>(
+    fa: Kind4<F, S1, R, E, A>,
+    f: (a: A) => Kind4<F, S2, R2, E, B>
+  ) => Kind4<F, S1 | S2, R & R2, E, B>;
+}
 export interface Functor4EC<F extends MaURIS, E> {
@@ -174,3 +191,3 @@ readonly URI: F;
     M,
-    SOf<R>,
+    SOf<R> | Q,
     S &
@@ -192,3 +209,3 @@ {
     M,
-    SOf<R>,
+    SOf<R> | Q,
     S &
@@ -204,92 +221,2 @@ {
 }
-export interface Do4CEP<M extends MaURIS, Q, S extends object, U, L> {
-  do: <Q1, E, R>(ma: Kind4<M, Q1, R, E, unknown>) => Do4CE<M, Q | Q1, S, U & R, L | E>;
-  doL: <Q1, E, R>(f: (s: S) => Kind4<M, Q1, R, E, unknown>) => Do4CE<M, Q | Q1, S, U & R, L | E>;
-  bind: <N extends string, Q1, E, R, A>(
-    name: Exclude<N, keyof S>,
-    ma: Kind4<M, Q1, R, E, A>
-  ) => Do4CE<
-    M,
-    Q | Q1,
-    S &
-      {
-        [K in N]: A;
-      },
-    U & R,
-    L | E
-  >;
-  bindL: <N extends string, Q1, E, R, A>(
-    name: Exclude<N, keyof S>,
-    f: (s: S) => Kind4<M, Q1, R, E, A>
-  ) => Do4CE<
-    M,
-    Q | Q1,
-    S &
-      {
-        [K in N]: A;
-      },
-    U & R,
-    L | E
-  >;
-  let: <N extends string, A>(
-    name: Exclude<N, keyof S>,
-    a: A
-  ) => Do4CE<
-    M,
-    Q,
-    S &
-      {
-        [K in N]: A;
-      },
-    U,
-    L
-  >;
-  letL: <N extends string, A>(
-    name: Exclude<N, keyof S>,
-    f: (s: S) => A
-  ) => Do4CE<
-    M,
-    Q,
-    S &
-      {
-        [K in N]: A;
-      },
-    U,
-    L
-  >;
-  sequenceS: <R extends Record<string, GE<unknown, any, any, any>>>(
-    r: EnforceNonEmptyRecord<R> &
-      {
-        [K in keyof S]?: never;
-      }
-  ) => Do4CE<
-    M,
-    unknown,
-    S &
-      {
-        [K in keyof R]: ATypeOf<R[K]>;
-      },
-    U & EnvOf<R>,
-    L | ETypeOf<R[keyof R]>
-  >;
-  sequenceSL: <R extends Record<string, GE<unknown, any, any, any>>>(
-    f: (
-      s: S
-    ) => EnforceNonEmptyRecord<R> &
-      {
-        [K in keyof S]?: never;
-      }
-  ) => Do4CE<
-    M,
-    unknown,
-    S &
-      {
-        [K in keyof R]: ATypeOf<R[K]>;
-      },
-    U & EnvOf<R>,
-    L | ETypeOf<R[keyof R]>
-  >;
-  return: <A>(f: (s: S) => A) => Kind4<M, Q, U, L, A>;
-  done: () => Kind4<M, Q, U, L, S>;
-}
 export interface Do4CE_<M extends MaURIS, Q, S extends object, U, L> {
@@ -350,3 +277,3 @@ do: <Q1, R>(ma: Kind4<M, Q1, R, L, unknown>) => Do4CE_<M, Q | Q1, S, U & R, L>;
   >;
-  sequenceS: <R extends Record<string, GE<any, any, L, any>>>(
+  sequenceS: <R extends Record<string, Kind4<M, any, any, L, any>>>(
     r: EnforceNonEmptyRecord<R> &
@@ -358,3 +285,3 @@ {
     M,
-    SOf<R>,
+    SOf<R> | Q,
     S &
@@ -367,3 +294,3 @@ {
   >;
-  sequenceSL: <R extends Record<string, GE<any, any, L, any>>>(
+  sequenceSL: <R extends Record<string, Kind4<M, any, any, L, any>>>(
     f: (
@@ -377,3 +304,3 @@ s: S
     M,
-    SOf<R>,
+    SOf<R> | Q,
     S &
@@ -391,4 +318,5 @@ {
   function Do<M extends MaURIS>(M: Monad4E<M>): Do4CE<M, never, {}, unknown, never>;
-  function Do<M extends MaURIS>(M: Monad4EP<M>): Do4CEP<M, never, {}, unknown, never>;
+  function Do<M extends MaURIS>(M: Monad4EP<M>): Do4CE<M, unknown, {}, unknown, never>;
   function Do<M extends MaURIS, E>(M: Monad4EC<M, E>): Do4CE_<M, never, {}, unknown, E>;
+  function Do<M extends MaURIS, E>(M: Monad4ECP<M, E>): Do4CE_<M, unknown, {}, unknown, E>;
 }
@@ -399,3 +327,3 @@ declare module "fp-ts/es6/Apply" {
   ): <NER extends Record<string, Kind4<F, any, any, any, any>>>(
-    r: EnforceNonEmptyRecord<NER> & Record<string, GE<any, any, any, any>>
+    r: EnforceNonEmptyRecord<NER> & Record<string, Kind4<F, any, any, any, any>>
   ) => Kind4<
@@ -412,2 +340,28 @@ F,
   >;
+  function sequenceS<F extends MaURIS, E>(
+    F: Apply4ECP<F, E>
+  ): <NER extends Record<string, Kind4<F, any, any, E, any>>>(
+    r: EnforceNonEmptyRecord<NER> & Record<string, Kind4<F, any, any, E, any>>
+  ) => Kind4<
+    F,
+    unknown,
+    EnvOf<NER>,
+    E,
+    {
+      [K in keyof NER]: [NER[K]] extends [Kind4<F, any, any, any, infer A>] ? A : never;
+    }
+  >;
+  function sequenceS<F extends MaURIS, E>(
+    F: Apply4EC<F, E>
+  ): <NER extends Record<string, Kind4<F, any, any, E, any>>>(
+    r: EnforceNonEmptyRecord<NER> & Record<string, Kind4<F, any, any, E, any>>
+  ) => Kind4<
+    F,
+    SOf<NER>,
+    EnvOf<NER>,
+    E,
+    {
+      [K in keyof NER]: [NER[K]] extends [Kind4<F, any, any, any, infer A>] ? A : never;
+    }
+  >;
   function sequenceS<F extends MaURIS>(
@@ -480,2 +434,50 @@ F: Apply4EP<F>
   >;
+  function sequenceT<F extends MaURIS, E>(
+    F: Apply4ECP<F, E>
+  ): <T extends Array<Kind4<F, any, any, E, any>>>(
+    ...t: T & {
+      0: Kind4<F, any, any, E, any>;
+    }
+  ) => Kind4<
+    F,
+    unknown,
+    UnionToIntersection<
+      {
+        [K in keyof T]: [T[K]] extends [Kind4<F, any, infer R, any, any>]
+          ? unknown extends R
+            ? never
+            : R
+          : never;
+      }[number]
+    >,
+    E,
+    {
+      [K in keyof T]: [T[K]] extends [Kind4<F, any, any, any, infer A>] ? A : never;
+    }
+  >;
+  function sequenceT<F extends MaURIS, E>(
+    F: Apply4EC<F, E>
+  ): <T extends Array<Kind4<F, any, any, E, any>>>(
+    ...t: T & {
+      0: Kind4<F, any, any, E, any>;
+    }
+  ) => Kind4<
+    F,
+    {
+      [K in keyof T]: [T[K]] extends [Kind4<F, infer S, any, any, any>] ? S : never;
+    }[number],
+    UnionToIntersection<
+      {
+        [K in keyof T]: [T[K]] extends [Kind4<F, any, infer R, any, any>]
+          ? unknown extends R
+            ? never
+            : R
+          : never;
+      }[number]
+    >,
+    E,
+    {
+      [K in keyof T]: [T[K]] extends [Kind4<F, any, any, any, infer A>] ? A : never;
+    }
+  >;
 }
@@ -631,2 +633,5 @@ export interface PipeableChain4E<F extends MaURIS> extends PipeableApply4E<F> {
 }
+export interface MonadThrow4ECP<M extends MaURIS, E> extends Monad4ECP<M, E> {
+  readonly throwError: (e: E) => Kind4<M, never, unknown, E, never>;
+}
 export interface Alt4EC<F extends MaURIS, E> extends Functor4EC<F, E> {
@@ -663,2 +668,6 @@ readonly alt: <S1, S2, R, R2, A>(
   interface Traverse1<T extends URIS> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <A, S, R, B>(
+      ta: Kind<T, A>,
+      f: (a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, unknown, R, E, Kind<T, B>>;
     <F extends MaURIS, E>(F: Applicative4EC<F, E>): <A, S, R, B>(
@@ -668,4 +677,2 @@ ta: Kind<T, A>,
     ) => Kind4<F, S, R, E, Kind<T, B>>;
-  }
-  interface Traverse1<T extends URIS> {
     <F extends MaURIS>(F: Applicative4EP<F>): <A, S, R, E, B>(
@@ -681,2 +688,5 @@ ta: Kind<T, A>,
   interface Sequence1<T extends URIS> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <S, R, A>(
+      ta: Kind<T, Kind4<F, S, R, E, A>>
+    ) => Kind4<F, unknown, R, E, Kind<T, A>>;
     <F extends MaURIS, E>(F: Applicative4EC<F, E>): <S, R, A>(
@@ -693,2 +703,10 @@ ta: Kind<T, Kind4<F, S, R, E, A>>
   interface Traverse2<T extends URIS2> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <TE, A, S, R, B>(
+      ta: Kind2<T, TE, A>,
+      f: (a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, unknown, R, E, Kind2<T, TE, B>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <TE, A, S, R, B>(
+      ta: Kind2<T, TE, A>,
+      f: (a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, S, R, E, Kind2<T, TE, B>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <TE, A, S, R, FE, B>(
@@ -704,2 +722,8 @@ ta: Kind2<T, TE, A>,
   interface Sequence2<T extends URIS2> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <TE, S, R, A>(
+      ta: Kind2<T, E, Kind4<F, S, R, E, A>>
+    ) => Kind4<F, unknown, R, E, Kind2<T, TE, A>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <TE, S, R, A>(
+      ta: Kind2<T, E, Kind4<F, S, R, E, A>>
+    ) => Kind4<F, S, R, E, Kind2<T, TE, A>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <TE, S, R, FE, A>(
@@ -715,2 +739,10 @@ ta: Kind2<T, TE, Kind4<F, S, R, FE, A>>
   interface Wilt1<W extends URIS> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <A, S, R, B, C>(
+      wa: Kind<W, A>,
+      f: (a: A) => Kind4<F, S, R, E, Either<B, C>>
+    ) => Kind4<F, unknown, R, E, Separated<Kind<W, B>, Kind<W, C>>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <A, S, R, B, C>(
+      wa: Kind<W, A>,
+      f: (a: A) => Kind4<F, S, R, E, Either<B, C>>
+    ) => Kind4<F, S, R, E, Separated<Kind<W, B>, Kind<W, C>>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <A, S, R, E, B, C>(
@@ -726,2 +758,10 @@ wa: Kind<W, A>,
   interface Wither1<W extends URIS> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <A, S, R, B>(
+      ta: Kind<W, A>,
+      f: (a: A) => Kind4<F, S, R, E, Option<B>>
+    ) => Kind4<F, unknown, R, E, Kind<W, B>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <A, S, R, B>(
+      ta: Kind<W, A>,
+      f: (a: A) => Kind4<F, S, R, E, Option<B>>
+    ) => Kind4<F, S, R, E, Kind<W, B>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <A, S, R, E, B>(
@@ -739,2 +779,10 @@ ta: Kind<W, A>,
   interface TraverseWithIndex1<T extends URIS, I> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <A, S, R, B>(
+      ta: Kind<T, A>,
+      f: (i: I, a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, unknown, R, E, Kind<T, B>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <A, S, R, B>(
+      ta: Kind<T, A>,
+      f: (i: I, a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, S, R, E, Kind<T, B>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <A, S, R, E, B>(
@@ -741,0 +789,0 @@ ta: Kind<T, A>,

es6/stream/stream.d.ts

@@ -360,5 +360,5 @@ /// <reference types="node" />
 export { su };
-export declare const Do: () => import("../overloadEff").Do4CEP<
+export declare const Do: () => import("../overloadEff").Do4CE<
   "matechs/Stream",
-  never,
+  unknown,
   {},
@@ -365,0 +365,0 @@ unknown,

es6/streameither/index.d.ts

@@ -162,5 +162,5 @@ import * as T from "../effect";
   ) => <S, R, E>(fa: StreamEither<S, R, E, A>) => StreamEither<S, R, E, B>;
-export declare const Do: () => import("../overloadEff").Do4CEP<
+export declare const Do: () => import("../overloadEff").Do4CE<
   "matechs/StreamEither",
-  never,
+  unknown,
   {},
@@ -167,0 +167,0 @@ unknown,

lib/effect.d.ts

@@ -18,3 +18,5 @@ import {
   Monad4EC,
+  Monad4ECP,
   MonadThrow4EC,
+  MonadThrow4ECP,
   Alt4EC,
@@ -163,3 +165,3 @@ Monad4EP,
  */
-export declare function raiseError<E, A = never>(e: E): SyncE<E, A>;
+export declare function raiseError<E>(e: E): SyncE<E, never>;
 /**
@@ -835,3 +837,3 @@ * An IO that is failed with an unchecked error
   fy: () => AsyncRE<R2, E2, A>
-): <R, E>(fx: AsyncRE<R, E, A>) => AsyncRE<R & R2, E2, A>;
+): <R, E, B>(fx: AsyncRE<R, E, B>) => AsyncRE<R & R2, E2, A | B>;
 export declare const effect: EffectMonad;
@@ -846,4 +848,3 @@ export declare const Do: () => import("./overloadEff").Do4CE<
 export declare const sequenceS: <NER extends Record<string, Effect<any, any, any, any>>>(
-  r: (keyof NER extends never ? never : NER) &
-    Record<string, import("./overloadEff").GE<any, any, any, any>>
+  r: (keyof NER extends never ? never : NER) & Record<string, Effect<any, any, any, any>>
 ) => Effect<
@@ -882,5 +883,5 @@ { [K in keyof NER]: import("./overloadEff").STypeOf<NER[K]> }[keyof NER],
 export declare const parEffect: Monad4EP<URI> & MonadThrow4EP<URI>;
-export declare const parDo: () => import("./overloadEff").Do4CEP<
+export declare const parDo: () => import("./overloadEff").Do4CE<
   "matechs/Effect",
-  never,
+  unknown,
   {},
@@ -1016,2 +1017,10 @@ unknown,
 ): Monad4EC<"matechs/Effect", E> & MonadThrow4EC<"matechs/Effect", E> & Alt4EC<"matechs/Effect", E>;
+export declare function getParValidationM<E>(
+  S: Sem.Semigroup<E>
+): Monad4ECP<"matechs/Effect", E> &
+  MonadThrow4ECP<"matechs/Effect", E> &
+  Alt4EC<"matechs/Effect", E>;
+export declare function getParCauseValidationM<E>(
+  S: Sem.Semigroup<ex.Cause<E>>
+): Monad4ECP<URI, E> & MonadThrow4ECP<URI, E> & Alt4EC<URI, E>;
 export declare function getCauseValidationM<E>(
@@ -1018,0 +1027,0 @@ S: Sem.Semigroup<ex.Cause<E>>

lib/effect.js

@@ -1209,2 +1209,33 @@ "use strict";
 exports.getValidationM = getValidationM;
+function getParValidationM(S) {
+    return getParCauseValidationM(getCauseSemigroup(S));
+}
+exports.getParValidationM = getParValidationM;
+function getParCauseValidationM(S) {
+    return {
+        URI: exports.URI,
+        _E: undefined,
+        _CTX: "async",
+        of: pure,
+        map: map_,
+        chain: chain_,
+        ap: function (fab, fa) {
+            return chain_(parZip(result(fa), result(fab)), function (_a) {
+                var faEx = _a[0], fabEx = _a[1];
+                return fabEx._tag === "Done"
+                    ? faEx._tag === "Done"
+                        ? pure(fabEx.value(faEx.value))
+                        : raised(faEx)
+                    : faEx._tag === "Done"
+                        ? raised(fabEx)
+                        : raised(S.concat(fabEx, faEx));
+            });
+        },
+        throwError: raiseError,
+        alt: function (fa, fb) {
+            return foldExit_(fa, function (e) { return foldExit_(fb(), function (fbe) { return raised(S.concat(e, fbe)); }, pure); }, pure);
+        }
+    };
+}
+exports.getParCauseValidationM = getParCauseValidationM;
 function getCauseValidationM(S) {
@@ -1211,0 +1242,0 @@ return {

lib/managed.d.ts

@@ -253,4 +253,3 @@ import { function as F, semigroup as Sem, monoid as Mon } from "fp-ts";
 export declare const sequenceS: <NER extends Record<string, Managed<any, any, any, any>>>(
-  r: (keyof NER extends never ? never : NER) &
-    Record<string, import("./overloadEff").GE<any, any, any, any>>
+  r: (keyof NER extends never ? never : NER) & Record<string, Managed<any, any, any, any>>
 ) => Managed<
@@ -257,0 +256,0 @@ { [K in keyof NER]: import("./overloadEff").STypeOf<NER[K]> }[keyof NER],

lib/overloadEff.d.ts

@@ -56,12 +56,12 @@ import { Bifunctor4 } from "fp-ts/lib/Bifunctor";
 export interface Applicative4E<F extends MaURIS> extends Apply4E<F> {
-  readonly of: <S = never, R = unknown, E = never, A = unknown>(a: A) => Kind4<F, S, R, E, A>;
+  readonly of: <A>(a: A) => Kind4<F, never, unknown, never, A>;
 }
 export interface Applicative4EP<F extends MaURIS> extends Apply4EP<F> {
-  readonly of: <S = never, R = unknown, E = never, A = unknown>(a: A) => Kind4<F, S, R, E, A>;
+  readonly of: <A>(a: A) => Kind4<F, never, unknown, never, A>;
 }
 export interface Alt4E<F extends MaURIS> extends Functor4<F> {
-  readonly alt: <S1, S2, R, R2, E, E2, A>(
+  readonly alt: <S1, S2, R, R2, E, E2, A, B>(
     fx: Kind4<F, S1, R, E, A>,
-    fy: () => Kind4<F, S2, R2, E2, A>
-  ) => Kind4<F, S1 | S2, R & R2, E2, A>;
+    fy: () => Kind4<F, S2, R2, E2, B>
+  ) => Kind4<F, S1 | S2, R & R2, E2, A | B>;
 }
@@ -71,5 +71,9 @@ export interface Monad4E<M extends MaURIS> extends Applicative4E<M>, Chain4E<M> {}
 export interface Monad4EC<M extends MaURIS, E> extends Applicative4EC<M, E>, Chain4EC<M, E> {}
+export interface Monad4ECP<M extends MaURIS, E> extends Applicative4ECP<M, E>, Chain4ECP<M, E> {}
 export interface Applicative4EC<F extends MaURIS, E> extends Apply4EC<F, E> {
-  readonly of: <S, R, A>(a: A) => Kind4<F, S, R, E, A>;
+  readonly of: <A>(a: A) => Kind4<F, never, unknown, E, A>;
 }
+export interface Applicative4ECP<F extends MaURIS, E> extends Apply4ECP<F, E> {
+  readonly of: <A>(a: A) => Kind4<F, never, unknown, E, A>;
+}
 export interface Apply4EC<F extends MaURIS, E> extends Functor4EC<F, E> {
@@ -81,2 +85,9 @@ readonly ap: <S1, S2, R, R2, A, B>(
 }
+export interface Apply4ECP<F extends MaURIS, E> extends Functor4EC<F, E> {
+  _CTX: "async";
+  readonly ap: <S1, S2, R, R2, A, B>(
+    fab: Kind4<F, S1, R, E, (a: A) => B>,
+    fa: Kind4<F, S2, R2, E, A>
+  ) => Kind4<F, unknown, R & R2, E, B>;
+}
 export interface Chain4EC<F extends MaURIS, E> extends Apply4EC<F, E> {
@@ -88,2 +99,8 @@ readonly chain: <S1, S2, R, A, R2, B>(
 }
+export interface Chain4ECP<F extends MaURIS, E> extends Apply4ECP<F, E> {
+  readonly chain: <S1, S2, R, A, R2, B>(
+    fa: Kind4<F, S1, R, E, A>,
+    f: (a: A) => Kind4<F, S2, R2, E, B>
+  ) => Kind4<F, S1 | S2, R & R2, E, B>;
+}
 export interface Functor4EC<F extends MaURIS, E> {
@@ -174,3 +191,3 @@ readonly URI: F;
     M,
-    SOf<R>,
+    SOf<R> | Q,
     S &
@@ -192,3 +209,3 @@ {
     M,
-    SOf<R>,
+    SOf<R> | Q,
     S &
@@ -204,92 +221,2 @@ {
 }
-export interface Do4CEP<M extends MaURIS, Q, S extends object, U, L> {
-  do: <Q1, E, R>(ma: Kind4<M, Q1, R, E, unknown>) => Do4CE<M, Q | Q1, S, U & R, L | E>;
-  doL: <Q1, E, R>(f: (s: S) => Kind4<M, Q1, R, E, unknown>) => Do4CE<M, Q | Q1, S, U & R, L | E>;
-  bind: <N extends string, Q1, E, R, A>(
-    name: Exclude<N, keyof S>,
-    ma: Kind4<M, Q1, R, E, A>
-  ) => Do4CE<
-    M,
-    Q | Q1,
-    S &
-      {
-        [K in N]: A;
-      },
-    U & R,
-    L | E
-  >;
-  bindL: <N extends string, Q1, E, R, A>(
-    name: Exclude<N, keyof S>,
-    f: (s: S) => Kind4<M, Q1, R, E, A>
-  ) => Do4CE<
-    M,
-    Q | Q1,
-    S &
-      {
-        [K in N]: A;
-      },
-    U & R,
-    L | E
-  >;
-  let: <N extends string, A>(
-    name: Exclude<N, keyof S>,
-    a: A
-  ) => Do4CE<
-    M,
-    Q,
-    S &
-      {
-        [K in N]: A;
-      },
-    U,
-    L
-  >;
-  letL: <N extends string, A>(
-    name: Exclude<N, keyof S>,
-    f: (s: S) => A
-  ) => Do4CE<
-    M,
-    Q,
-    S &
-      {
-        [K in N]: A;
-      },
-    U,
-    L
-  >;
-  sequenceS: <R extends Record<string, GE<unknown, any, any, any>>>(
-    r: EnforceNonEmptyRecord<R> &
-      {
-        [K in keyof S]?: never;
-      }
-  ) => Do4CE<
-    M,
-    unknown,
-    S &
-      {
-        [K in keyof R]: ATypeOf<R[K]>;
-      },
-    U & EnvOf<R>,
-    L | ETypeOf<R[keyof R]>
-  >;
-  sequenceSL: <R extends Record<string, GE<unknown, any, any, any>>>(
-    f: (
-      s: S
-    ) => EnforceNonEmptyRecord<R> &
-      {
-        [K in keyof S]?: never;
-      }
-  ) => Do4CE<
-    M,
-    unknown,
-    S &
-      {
-        [K in keyof R]: ATypeOf<R[K]>;
-      },
-    U & EnvOf<R>,
-    L | ETypeOf<R[keyof R]>
-  >;
-  return: <A>(f: (s: S) => A) => Kind4<M, Q, U, L, A>;
-  done: () => Kind4<M, Q, U, L, S>;
-}
 export interface Do4CE_<M extends MaURIS, Q, S extends object, U, L> {
@@ -350,3 +277,3 @@ do: <Q1, R>(ma: Kind4<M, Q1, R, L, unknown>) => Do4CE_<M, Q | Q1, S, U & R, L>;
   >;
-  sequenceS: <R extends Record<string, GE<any, any, L, any>>>(
+  sequenceS: <R extends Record<string, Kind4<M, any, any, L, any>>>(
     r: EnforceNonEmptyRecord<R> &
@@ -358,3 +285,3 @@ {
     M,
-    SOf<R>,
+    SOf<R> | Q,
     S &
@@ -367,3 +294,3 @@ {
   >;
-  sequenceSL: <R extends Record<string, GE<any, any, L, any>>>(
+  sequenceSL: <R extends Record<string, Kind4<M, any, any, L, any>>>(
     f: (
@@ -377,3 +304,3 @@ s: S
     M,
-    SOf<R>,
+    SOf<R> | Q,
     S &
@@ -391,4 +318,5 @@ {
   function Do<M extends MaURIS>(M: Monad4E<M>): Do4CE<M, never, {}, unknown, never>;
-  function Do<M extends MaURIS>(M: Monad4EP<M>): Do4CEP<M, never, {}, unknown, never>;
+  function Do<M extends MaURIS>(M: Monad4EP<M>): Do4CE<M, unknown, {}, unknown, never>;
   function Do<M extends MaURIS, E>(M: Monad4EC<M, E>): Do4CE_<M, never, {}, unknown, E>;
+  function Do<M extends MaURIS, E>(M: Monad4ECP<M, E>): Do4CE_<M, unknown, {}, unknown, E>;
 }
@@ -399,3 +327,3 @@ declare module "fp-ts/lib/Apply" {
   ): <NER extends Record<string, Kind4<F, any, any, any, any>>>(
-    r: EnforceNonEmptyRecord<NER> & Record<string, GE<any, any, any, any>>
+    r: EnforceNonEmptyRecord<NER> & Record<string, Kind4<F, any, any, any, any>>
   ) => Kind4<
@@ -412,2 +340,28 @@ F,
   >;
+  function sequenceS<F extends MaURIS, E>(
+    F: Apply4ECP<F, E>
+  ): <NER extends Record<string, Kind4<F, any, any, E, any>>>(
+    r: EnforceNonEmptyRecord<NER> & Record<string, Kind4<F, any, any, E, any>>
+  ) => Kind4<
+    F,
+    unknown,
+    EnvOf<NER>,
+    E,
+    {
+      [K in keyof NER]: [NER[K]] extends [Kind4<F, any, any, any, infer A>] ? A : never;
+    }
+  >;
+  function sequenceS<F extends MaURIS, E>(
+    F: Apply4EC<F, E>
+  ): <NER extends Record<string, Kind4<F, any, any, E, any>>>(
+    r: EnforceNonEmptyRecord<NER> & Record<string, Kind4<F, any, any, E, any>>
+  ) => Kind4<
+    F,
+    SOf<NER>,
+    EnvOf<NER>,
+    E,
+    {
+      [K in keyof NER]: [NER[K]] extends [Kind4<F, any, any, any, infer A>] ? A : never;
+    }
+  >;
   function sequenceS<F extends MaURIS>(
@@ -480,2 +434,50 @@ F: Apply4EP<F>
   >;
+  function sequenceT<F extends MaURIS, E>(
+    F: Apply4ECP<F, E>
+  ): <T extends Array<Kind4<F, any, any, E, any>>>(
+    ...t: T & {
+      0: Kind4<F, any, any, E, any>;
+    }
+  ) => Kind4<
+    F,
+    unknown,
+    UnionToIntersection<
+      {
+        [K in keyof T]: [T[K]] extends [Kind4<F, any, infer R, any, any>]
+          ? unknown extends R
+            ? never
+            : R
+          : never;
+      }[number]
+    >,
+    E,
+    {
+      [K in keyof T]: [T[K]] extends [Kind4<F, any, any, any, infer A>] ? A : never;
+    }
+  >;
+  function sequenceT<F extends MaURIS, E>(
+    F: Apply4EC<F, E>
+  ): <T extends Array<Kind4<F, any, any, E, any>>>(
+    ...t: T & {
+      0: Kind4<F, any, any, E, any>;
+    }
+  ) => Kind4<
+    F,
+    {
+      [K in keyof T]: [T[K]] extends [Kind4<F, infer S, any, any, any>] ? S : never;
+    }[number],
+    UnionToIntersection<
+      {
+        [K in keyof T]: [T[K]] extends [Kind4<F, any, infer R, any, any>]
+          ? unknown extends R
+            ? never
+            : R
+          : never;
+      }[number]
+    >,
+    E,
+    {
+      [K in keyof T]: [T[K]] extends [Kind4<F, any, any, any, infer A>] ? A : never;
+    }
+  >;
 }
@@ -631,2 +633,5 @@ export interface PipeableChain4E<F extends MaURIS> extends PipeableApply4E<F> {
 }
+export interface MonadThrow4ECP<M extends MaURIS, E> extends Monad4ECP<M, E> {
+  readonly throwError: (e: E) => Kind4<M, never, unknown, E, never>;
+}
 export interface Alt4EC<F extends MaURIS, E> extends Functor4EC<F, E> {
@@ -663,2 +668,6 @@ readonly alt: <S1, S2, R, R2, A>(
   interface Traverse1<T extends URIS> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <A, S, R, B>(
+      ta: Kind<T, A>,
+      f: (a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, unknown, R, E, Kind<T, B>>;
     <F extends MaURIS, E>(F: Applicative4EC<F, E>): <A, S, R, B>(
@@ -668,4 +677,2 @@ ta: Kind<T, A>,
     ) => Kind4<F, S, R, E, Kind<T, B>>;
-  }
-  interface Traverse1<T extends URIS> {
     <F extends MaURIS>(F: Applicative4EP<F>): <A, S, R, E, B>(
@@ -681,2 +688,5 @@ ta: Kind<T, A>,
   interface Sequence1<T extends URIS> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <S, R, A>(
+      ta: Kind<T, Kind4<F, S, R, E, A>>
+    ) => Kind4<F, unknown, R, E, Kind<T, A>>;
     <F extends MaURIS, E>(F: Applicative4EC<F, E>): <S, R, A>(
@@ -693,2 +703,10 @@ ta: Kind<T, Kind4<F, S, R, E, A>>
   interface Traverse2<T extends URIS2> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <TE, A, S, R, B>(
+      ta: Kind2<T, TE, A>,
+      f: (a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, unknown, R, E, Kind2<T, TE, B>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <TE, A, S, R, B>(
+      ta: Kind2<T, TE, A>,
+      f: (a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, S, R, E, Kind2<T, TE, B>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <TE, A, S, R, FE, B>(
@@ -704,2 +722,8 @@ ta: Kind2<T, TE, A>,
   interface Sequence2<T extends URIS2> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <TE, S, R, A>(
+      ta: Kind2<T, E, Kind4<F, S, R, E, A>>
+    ) => Kind4<F, unknown, R, E, Kind2<T, TE, A>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <TE, S, R, A>(
+      ta: Kind2<T, E, Kind4<F, S, R, E, A>>
+    ) => Kind4<F, S, R, E, Kind2<T, TE, A>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <TE, S, R, FE, A>(
@@ -715,2 +739,10 @@ ta: Kind2<T, TE, Kind4<F, S, R, FE, A>>
   interface Wilt1<W extends URIS> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <A, S, R, B, C>(
+      wa: Kind<W, A>,
+      f: (a: A) => Kind4<F, S, R, E, Either<B, C>>
+    ) => Kind4<F, unknown, R, E, Separated<Kind<W, B>, Kind<W, C>>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <A, S, R, B, C>(
+      wa: Kind<W, A>,
+      f: (a: A) => Kind4<F, S, R, E, Either<B, C>>
+    ) => Kind4<F, S, R, E, Separated<Kind<W, B>, Kind<W, C>>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <A, S, R, E, B, C>(
@@ -726,2 +758,10 @@ wa: Kind<W, A>,
   interface Wither1<W extends URIS> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <A, S, R, B>(
+      ta: Kind<W, A>,
+      f: (a: A) => Kind4<F, S, R, E, Option<B>>
+    ) => Kind4<F, unknown, R, E, Kind<W, B>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <A, S, R, B>(
+      ta: Kind<W, A>,
+      f: (a: A) => Kind4<F, S, R, E, Option<B>>
+    ) => Kind4<F, S, R, E, Kind<W, B>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <A, S, R, E, B>(
@@ -739,2 +779,10 @@ ta: Kind<W, A>,
   interface TraverseWithIndex1<T extends URIS, I> {
+    <F extends MaURIS, E>(F: Applicative4ECP<F, E>): <A, S, R, B>(
+      ta: Kind<T, A>,
+      f: (i: I, a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, unknown, R, E, Kind<T, B>>;
+    <F extends MaURIS, E>(F: Applicative4EC<F, E>): <A, S, R, B>(
+      ta: Kind<T, A>,
+      f: (i: I, a: A) => Kind4<F, S, R, E, B>
+    ) => Kind4<F, S, R, E, Kind<T, B>>;
     <F extends MaURIS>(F: Applicative4EP<F>): <A, S, R, E, B>(
@@ -741,0 +789,0 @@ ta: Kind<T, A>,

lib/stream/stream.d.ts

@@ -360,5 +360,5 @@ /// <reference types="node" />
 export { su };
-export declare const Do: () => import("../overloadEff").Do4CEP<
+export declare const Do: () => import("../overloadEff").Do4CE<
   "matechs/Stream",
-  never,
+  unknown,
   {},
@@ -365,0 +365,0 @@ unknown,

lib/streameither/index.d.ts

@@ -162,5 +162,5 @@ import * as T from "../effect";
   ) => <S, R, E>(fa: StreamEither<S, R, E, A>) => StreamEither<S, R, E, B>;
-export declare const Do: () => import("../overloadEff").Do4CEP<
+export declare const Do: () => import("../overloadEff").Do4CE<
   "matechs/StreamEither",
-  never,
+  unknown,
   {},
@@ -167,0 +167,0 @@ unknown,

package.json

 {
   "name": "@matechs/effect",
-  "version": "6.0.4",
+  "version": "6.1.0",
   "license": "MIT",
@@ -43,3 +43,3 @@ "private": false,
   },
-  "gitHead": "6bbef56b33af53d44b06b65b8437106877702de2"
+  "gitHead": "192c7b95548e48c62f3cb0937cef3cc20f9f585f"
 }

No alert changes

Improved metrics

Total package byte prevSize

653388

increased by1.38%

Lines of code

18808

increased by0.89%

No dependency changes