@matechs/effect - npm Package Compare versions

Comparing version 6.2.0 to 6.3.0

es6/managed.d.ts

@@ -8,3 +8,3 @@ import { function as F, semigroup as Sem, monoid as Mon } from "fp-ts";
 import { Separated } from "fp-ts/es6/Compactable";
-import { Monad4E } from "./overloadEff";
+import { Monad4E, Monad4EP, MonadThrow4E } from "./overloadEff";
 export declare enum ManagedTag {
@@ -107,16 +107,2 @@ Pure = 0,
 /**
- * Curried form of chain
- * @param bind
- */
-export declare function chain<S, R, E, L, A>(
-  bind: F.FunctionN<[L], Managed<S, R, E, A>>
-): <S2, R2, E2>(ma: Managed<S2, R2, E2, L>) => Managed<S | S2, R & R2, E | E2, A>;
-/**
- * Curried form of map
- * @param f
- */
-export declare function map<L, A>(
-  f: F.FunctionN<[L], A>
-): <S, R, E>(res: Managed<S, R, E, L>) => Managed<S, R, E, A>;
-/**
  * Zip two resources together with the given function.
@@ -146,11 +132,35 @@ *
 /**
- * Apply the function produced by resfab to the value produced by resa to produce a new resource.
+ * Zip two resources together with provided function, while allocating and
+ * releasing them in parallel and returning first error that was raised.
+ *
  * @param resa
- * @param resfab
+ * @param resb
+ * @param f
  */
-export declare function ap<S, R, E, A, S2, R2, E2, B>(
+export declare function parZipWith<S, S2, R, R2, E, E2, A, B, C>(
   resa: Managed<S, R, E, A>,
-  resfab: Managed<S2, R2, E2, F.FunctionN<[A], B>>
-): Managed<S | S2, R & R2, E | E2, B>;
+  resb: Managed<S2, R2, E2, B>,
+  f: F.FunctionN<[A, B], C>
+): AsyncRE<R & R2, E | E2, C>;
 /**
+ * Zip two resources together into tuple, while allocating and releasing them
+ * in parallel and returning first error that was raised.
+ *
+ * @param resa
+ * @param resb
+ */
+export declare function parZip<S, S2, R, R2, E, A, B>(
+  resa: Managed<S, R, E, A>,
+  resb: Managed<S2, R2, E, B>
+): AsyncRE<R & R2, E, [A, B]>;
+/**
+ * Parallel form of ap_
+ * @param iof
+ * @param ioa
+ */
+export declare function parAp_<S, S2, R, R2, E, E2, A, B>(
+  iof: Managed<S, R, E, F.FunctionN<[A], B>>,
+  ioa: Managed<S2, R2, E2, A>
+): AsyncRE<R & R2, E | E2, B>;
+/**
  * Map a resource to a static value
@@ -241,3 +251,4 @@ *
 }
-export declare const managed: Monad4E<URI>;
+export declare const managed: Monad4E<URI> & MonadThrow4E<URI>;
+export declare const parManaged: Monad4EP<URI>;
 export declare function getSemigroup<S, R, E, A>(
@@ -290,2 +301,43 @@ Semigroup: Sem.Semigroup<A>
 >;
+export declare const parDo: () => import("./overloadEff").Do4CE<
+  "matechs/Managed",
+  unknown,
+  {},
+  unknown,
+  never
+>;
+export declare const parSequenceS: <NER extends Record<string, Managed<any, any, any, any>>>(
+  r: (keyof NER extends never ? never : NER) & Record<string, Managed<any, any, any, any>>
+) => Managed<
+  unknown,
+  import("./overloadEff").UnionToIntersection<
+    {
+      [K in keyof NER]: unknown extends import("./overloadEff").EffypeOf<NER[K]>
+        ? never
+        : import("./overloadEff").EffypeOf<NER[K]>;
+    }[keyof NER]
+  >,
+  {
+    [K_1 in keyof NER]: [NER[K_1]] extends [Managed<any, any, infer E, any>] ? E : never;
+  }[keyof NER],
+  { [K_2 in keyof NER]: [NER[K_2]] extends [Managed<any, any, any, infer A>] ? A : never }
+>;
+export declare const parSequenceT: <T extends Managed<any, any, any, any>[]>(
+  ...t: T & {
+    0: Managed<any, any, any, any>;
+  }
+) => Managed<
+  unknown,
+  import("./overloadEff").UnionToIntersection<
+    {
+      [K in keyof T]: [T[K]] extends [Managed<any, infer R, any, any>]
+        ? unknown extends R
+          ? never
+          : R
+        : never;
+    }[number]
+  >,
+  { [K_1 in keyof T]: [T[K_1]] extends [Managed<any, any, infer E, any>] ? E : never }[number],
+  { [K_2 in keyof T]: [T[K_2]] extends [Managed<any, any, any, infer A>] ? A : never }
+>;
 export declare const sequenceOption: <S, R, E, A>(
@@ -303,2 +355,14 @@ ta: Op.Option<Managed<S, R, E, A>>
 ) => (ta: Op.Option<A>) => Managed<S, R, E, Op.Option<B>>;
+export declare const parSequenceOption: <S, R, E, A>(
+  ta: Op.Option<Managed<S, R, E, A>>
+) => Managed<unknown, R, E, Op.Option<A>>;
+export declare const parTraverseOption: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, B>
+) => (ta: Op.Option<A>) => Managed<unknown, R, E, Op.Option<B>>;
+export declare const parWiltOption: <S, A, R, E, B, C>(
+  f: (a: A) => Managed<S, R, E, Ei.Either<B, C>>
+) => (wa: Op.Option<A>) => Managed<unknown, R, E, Separated<Op.Option<B>, Op.Option<C>>>;
+export declare const parWitherOption: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, Op.Option<B>>
+) => (ta: Op.Option<A>) => Managed<unknown, R, E, Op.Option<B>>;
 export declare const sequenceEither: <TE, S, R, FE, A>(
@@ -316,2 +380,14 @@ ta: Ei.Either<TE, Managed<S, R, FE, A>>
 ) => (ta: TR.Tree<A>) => Managed<S, R, E, TR.Tree<B>>;
+export declare const parSequenceEither: <TE, S, R, FE, A>(
+  ta: Ei.Either<TE, Managed<S, R, FE, A>>
+) => Managed<unknown, R, FE, Ei.Either<TE, A>>;
+export declare const parTraverseEither: <S, A, R, FE, B>(
+  f: (a: A) => Managed<S, R, FE, B>
+) => <TE>(ta: Ei.Either<TE, A>) => Managed<unknown, R, FE, Ei.Either<TE, B>>;
+export declare const parSequenceTree: <S, R, E, A>(
+  ta: TR.Tree<Managed<S, R, E, A>>
+) => Managed<S, R, E, TR.Tree<A>>;
+export declare const parTraverseTree: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, B>
+) => (ta: TR.Tree<A>) => Managed<unknown, R, E, TR.Tree<B>>;
 export declare const sequenceArray: <S, R, E, A>(
@@ -332,2 +408,17 @@ ta: Managed<S, R, E, A>[]
 ) => (ta: Array<A>) => Managed<S, R, E, Array<B>>;
+export declare const parSequenceArray: <S, R, E, A>(
+  ta: Managed<S, R, E, A>[]
+) => Managed<unknown, R, E, A[]>;
+export declare const parTraverseArray: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, B>
+) => (ta: Array<A>) => Managed<unknown, R, E, Array<B>>;
+export declare const parTraverseArrayWithIndex: <S, A, R, E, B>(
+  f: (i: number, a: A) => Managed<S, R, E, B>
+) => (ta: Array<A>) => Managed<unknown, R, E, Array<B>>;
+export declare const parWiltArray: <S, A, R, E, B, C>(
+  f: (a: A) => Managed<S, R, E, Ei.Either<B, C>>
+) => (wa: Array<A>) => Managed<unknown, R, E, Separated<Array<B>, Array<C>>>;
+export declare const parWitherArray: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, Op.Option<B>>
+) => (ta: Array<A>) => Managed<unknown, R, E, Array<B>>;
 export declare const sequenceRecord: <S, R, E, A>(
@@ -348,1 +439,64 @@ ta: Record<string, Managed<S, R, E, A>>
 ) => (ta: Record<string, A>) => Managed<S, R, E, Record<string, B>>;
+export declare const parSequenceRecord: <S, R, E, A>(
+  ta: Record<string, Managed<S, R, E, A>>
+) => Managed<unknown, R, E, Record<string, A>>;
+export declare const parTraverseRecord: <A, S, R, E, B>(
+  f: (a: A) => Managed<S, R, E, B>
+) => (ta: Record<string, A>) => Managed<unknown, R, E, Record<string, B>>;
+export declare const parTraverseRecordWithIndex: <A, S, R, E, B>(
+  f: (k: string, a: A) => Managed<S, R, E, B>
+) => (ta: Record<string, A>) => Managed<unknown, R, E, Record<string, B>>;
+export declare const parWiltRecord: <A, S, R, E, B, C>(
+  f: (a: A) => Managed<S, R, E, Ei.Either<B, C>>
+) => (
+  wa: Record<string, A>
+) => Managed<unknown, R, E, Separated<Record<string, B>, Record<string, C>>>;
+export declare const parWitherRecord: <A, S, R, E, B>(
+  f: (a: A) => Managed<S, R, E, Op.Option<B>>
+) => (ta: Record<string, A>) => Managed<unknown, R, E, Record<string, B>>;
+export declare const ap: <S1, R, E, A, E2>(
+    fa: Managed<S1, R, E, A>
+  ) => <S2, R2, B>(fab: Managed<S2, R2, E2, (a: A) => B>) => Managed<S1 | S2, R & R2, E | E2, B>,
+  apFirst: <S1, R, E, B>(
+    fb: Managed<S1, R, E, B>
+  ) => <A, S2, R2, E2>(fa: Managed<S2, R2, E2, A>) => Managed<S1 | S2, R & R2, E | E2, A>,
+  apSecond: <S1, R, E, B>(
+    fb: Managed<S1, R, E, B>
+  ) => <A, S2, R2, E2>(fa: Managed<S2, R2, E2, A>) => Managed<S1 | S2, R & R2, E | E2, B>,
+  chain: <S1, R, E, A, B>(
+    f: (a: A) => Managed<S1, R, E, B>
+  ) => <S2, R2, E2>(ma: Managed<S2, R2, E2, A>) => Managed<S1 | S2, R & R2, E | E2, B>,
+  chainFirst: <S1, R, E, A, B>(
+    f: (a: A) => Managed<S1, R, E, B>
+  ) => <S2, R2, E2>(ma: Managed<S2, R2, E2, A>) => Managed<S1 | S2, R & R2, E | E2, A>,
+  flatten: <S1, S2, R, E, R2, E2, A>(
+    mma: Managed<S1, R, E, Managed<S2, R2, E2, A>>
+  ) => Managed<S1 | S2, R & R2, E | E2, A>,
+  map: <A, B>(f: (a: A) => B) => <S, R, E>(fa: Managed<S, R, E, A>) => Managed<S, R, E, B>,
+  filterOrElse: {
+    <E, A, B extends A>(refinement: F.Refinement<A, B>, onFalse: (a: A) => E): <S, R>(
+      ma: Managed<S, R, E, A>
+    ) => Managed<S, R, E, B>;
+    <E_1, A_1>(predicate: F.Predicate<A_1>, onFalse: (a: A_1) => E_1): <S_1, R_1>(
+      ma: Managed<S_1, R_1, E_1, A_1>
+    ) => Managed<S_1, R_1, E_1, A_1>;
+  },
+  fromEither: <E, A>(ma: Ei.Either<E, A>) => Managed<never, unknown, E, A>,
+  fromOption: <E>(onNone: () => E) => <A>(ma: Op.Option<A>) => Managed<never, unknown, E, A>,
+  fromPredicate: {
+    <E, A, B extends A>(refinement: F.Refinement<A, B>, onFalse: (a: A) => E): (
+      a: A
+    ) => Managed<never, unknown, E, B>;
+    <E_1, A_1>(predicate: F.Predicate<A_1>, onFalse: (a: A_1) => E_1): (
+      a: A_1
+    ) => Managed<never, unknown, E_1, A_1>;
+  };
+export declare const parAp: <S1, R, E, A, E2>(
+    fa: Managed<S1, R, E, A>
+  ) => <S2, R2, B>(fab: Managed<S2, R2, E2, (a: A) => B>) => Managed<unknown, R & R2, E | E2, B>,
+  parApFirst: <S1, R, E, B>(
+    fb: Managed<S1, R, E, B>
+  ) => <A, S2, R2, E2>(fa: Managed<S2, R2, E2, A>) => Managed<unknown, R & R2, E | E2, A>,
+  parApSecond: <S1, R, E, B>(
+    fb: Managed<S1, R, E, B>
+  ) => <A, S2, R2, E2>(fa: Managed<S2, R2, E2, A>) => Managed<unknown, R & R2, E | E2, B>;

es6/managed.js

@@ -11,2 +11,3 @@ import { function as F } from "fp-ts";
 import * as RE from "fp-ts/es6/Record";
+import { pipe, pipeable } from "fp-ts/es6/pipeable";
 export var ManagedTag;
@@ -89,9 +90,2 @@ (function (ManagedTag) {
 /**
- * Curried form of chain
- * @param bind
- */
-export function chain(bind) {
-    return (left) => chain_(left, bind);
-}
-/**
  * Map a resource
@@ -105,9 +99,2 @@ * @param res
 /**
- * Curried form of map
- * @param f
- */
-export function map(f) {
-    return (res) => map_(res, f);
-}
-/**
  * Zip two resources together with the given function.
@@ -133,11 +120,42 @@ *
 }
+function foldExitAndFiber(aExit, bFiber, onBFail, onAFail) {
+    return T.effect.chain(bFiber.wait, (bExit) => aExit._tag === "Done"
+        ? bExit._tag === "Done"
+            ? F.unsafeCoerce(T.pure(F.tuple(aExit.value, bExit.value)))
+            : pipe(onBFail(aExit.value), T.chain(() => T.raised(bExit)), T.chainError(() => T.raised(bExit)))
+        : bExit._tag === "Done"
+            ? pipe(onAFail(bExit.value), T.chain(() => T.raised(aExit)), T.chainError(() => T.raised(aExit)))
+            : T.raised(aExit));
+}
 /**
- * Apply the function produced by resfab to the value produced by resa to produce a new resource.
+ * Zip two resources together with provided function, while allocating and
+ * releasing them in parallel and returning first error that was raised.
+ *
  * @param resa
- * @param resfab
+ * @param resb
+ * @param f
  */
-export function ap(resa, resfab) {
-    return zipWith(resa, resfab, (a, f) => f(a));
+export function parZipWith(resa, resb, f) {
+    const alloc = T.raceFold(allocate(resa), allocate(resb), (aExit, bFiber) => foldExitAndFiber(aExit, bFiber, (aLeak) => aLeak.release, (bLeak) => bLeak.release), (bExit, aFiber) => T.effect.map(foldExitAndFiber(bExit, aFiber, (bLeak) => bLeak.release, (aLeak) => aLeak.release), ([b, a]) => F.tuple(a, b)));
+    return map_(bracket(alloc, ([aLeak, bLeak]) => T.raceFold(aLeak.release, bLeak.release, (aExit, bFiber) => foldExitAndFiber(aExit, bFiber, () => T.unit, () => T.unit), (bExit, aFiber) => foldExitAndFiber(bExit, aFiber, () => T.unit, () => T.unit))), ([aLeak, bLeak]) => f(aLeak.a, bLeak.a));
 }
 /**
+ * Zip two resources together into tuple, while allocating and releasing them
+ * in parallel and returning first error that was raised.
+ *
+ * @param resa
+ * @param resb
+ */
+export function parZip(resa, resb) {
+    return parZipWith(resa, resb, F.tuple);
+}
+/**
+ * Parallel form of ap_
+ * @param iof
+ * @param ioa
+ */
+export function parAp_(iof, ioa) {
+    return parZipWith(iof, ioa, (f, a) => f(a));
+}
+/**
  * Flipped version of ap
@@ -274,2 +292,11 @@ * @param resfab
     ap: ap_,
+    chain: chain_,
+    throwError: (e) => encaseEffect(T.raiseError(e))
+};
+export const parManaged = {
+    URI,
+    _CTX: "async",
+    of: pure,
+    map: map_,
+    ap: parAp_,
     chain: chain_
@@ -293,2 +320,5 @@ };
 export const sequenceT = ST(managed);
+export const parDo = () => DoG(parManaged);
+export const parSequenceS = SS(parManaged);
+export const parSequenceT = ST(parManaged);
 export const sequenceOption = Op.option.sequence(managed);
@@ -298,2 +328,6 @@ export const traverseOption = (f) => (ta) => Op.option.traverse(managed)(ta, f);
 export const witherOption = (f) => (ta) => Op.option.wither(managed)(ta, f);
+export const parSequenceOption = Op.option.sequence(parManaged);
+export const parTraverseOption = (f) => (ta) => Op.option.traverse(parManaged)(ta, f);
+export const parWiltOption = (f) => (wa) => Op.option.wilt(parManaged)(wa, f);
+export const parWitherOption = (f) => (ta) => Op.option.wither(parManaged)(ta, f);
 export const sequenceEither = Ei.either.sequence(managed);
@@ -303,2 +337,6 @@ export const traverseEither = (f) => (ta) => Ei.either.traverse(managed)(ta, f);
 export const traverseTree = (f) => (ta) => TR.tree.traverse(managed)(ta, f);
+export const parSequenceEither = Ei.either.sequence(parManaged);
+export const parTraverseEither = (f) => (ta) => Ei.either.traverse(parManaged)(ta, f);
+export const parSequenceTree = TR.tree.sequence(managed);
+export const parTraverseTree = (f) => (ta) => TR.tree.traverse(parManaged)(ta, f);
 export const sequenceArray = Ar.array.sequence(managed);
@@ -309,2 +347,7 @@ export const traverseArray = (f) => (ta) => Ar.array.traverse(managed)(ta, f);
 export const witherArray = (f) => (ta) => Ar.array.wither(managed)(ta, f);
+export const parSequenceArray = Ar.array.sequence(parManaged);
+export const parTraverseArray = (f) => (ta) => Ar.array.traverse(parManaged)(ta, f);
+export const parTraverseArrayWithIndex = (f) => (ta) => Ar.array.traverseWithIndex(parManaged)(ta, f);
+export const parWiltArray = (f) => (wa) => Ar.array.wilt(parManaged)(wa, f);
+export const parWitherArray = (f) => (ta) => Ar.array.wither(parManaged)(ta, f);
 export const sequenceRecord = RE.record.sequence(managed);
@@ -315,1 +358,8 @@ export const traverseRecord = (f) => (ta) => RE.record.traverse(managed)(ta, f);
 export const witherRecord = (f) => (ta) => RE.record.wither(managed)(ta, f);
+export const parSequenceRecord = RE.record.sequence(parManaged);
+export const parTraverseRecord = (f) => (ta) => RE.record.traverse(parManaged)(ta, f);
+export const parTraverseRecordWithIndex = (f) => (ta) => RE.record.traverseWithIndex(parManaged)(ta, f);
+export const parWiltRecord = (f) => (wa) => RE.record.wilt(parManaged)(wa, f);
+export const parWitherRecord = (f) => (ta) => RE.record.wither(parManaged)(ta, f);
+export const { ap, apFirst, apSecond, chain, chainFirst, flatten, map, filterOrElse, fromEither, fromOption, fromPredicate } = pipeable(managed);
+export const { ap: parAp, apFirst: parApFirst, apSecond: parApSecond } = pipeable(parManaged);

lib/managed.d.ts

@@ -8,3 +8,3 @@ import { function as F, semigroup as Sem, monoid as Mon } from "fp-ts";
 import { Separated } from "fp-ts/lib/Compactable";
-import { Monad4E } from "./overloadEff";
+import { Monad4E, Monad4EP, MonadThrow4E } from "./overloadEff";
 export declare enum ManagedTag {
@@ -107,16 +107,2 @@ Pure = 0,
 /**
- * Curried form of chain
- * @param bind
- */
-export declare function chain<S, R, E, L, A>(
-  bind: F.FunctionN<[L], Managed<S, R, E, A>>
-): <S2, R2, E2>(ma: Managed<S2, R2, E2, L>) => Managed<S | S2, R & R2, E | E2, A>;
-/**
- * Curried form of map
- * @param f
- */
-export declare function map<L, A>(
-  f: F.FunctionN<[L], A>
-): <S, R, E>(res: Managed<S, R, E, L>) => Managed<S, R, E, A>;
-/**
  * Zip two resources together with the given function.
@@ -146,11 +132,35 @@ *
 /**
- * Apply the function produced by resfab to the value produced by resa to produce a new resource.
+ * Zip two resources together with provided function, while allocating and
+ * releasing them in parallel and returning first error that was raised.
+ *
  * @param resa
- * @param resfab
+ * @param resb
+ * @param f
  */
-export declare function ap<S, R, E, A, S2, R2, E2, B>(
+export declare function parZipWith<S, S2, R, R2, E, E2, A, B, C>(
   resa: Managed<S, R, E, A>,
-  resfab: Managed<S2, R2, E2, F.FunctionN<[A], B>>
-): Managed<S | S2, R & R2, E | E2, B>;
+  resb: Managed<S2, R2, E2, B>,
+  f: F.FunctionN<[A, B], C>
+): AsyncRE<R & R2, E | E2, C>;
 /**
+ * Zip two resources together into tuple, while allocating and releasing them
+ * in parallel and returning first error that was raised.
+ *
+ * @param resa
+ * @param resb
+ */
+export declare function parZip<S, S2, R, R2, E, A, B>(
+  resa: Managed<S, R, E, A>,
+  resb: Managed<S2, R2, E, B>
+): AsyncRE<R & R2, E, [A, B]>;
+/**
+ * Parallel form of ap_
+ * @param iof
+ * @param ioa
+ */
+export declare function parAp_<S, S2, R, R2, E, E2, A, B>(
+  iof: Managed<S, R, E, F.FunctionN<[A], B>>,
+  ioa: Managed<S2, R2, E2, A>
+): AsyncRE<R & R2, E | E2, B>;
+/**
  * Map a resource to a static value
@@ -241,3 +251,4 @@ *
 }
-export declare const managed: Monad4E<URI>;
+export declare const managed: Monad4E<URI> & MonadThrow4E<URI>;
+export declare const parManaged: Monad4EP<URI>;
 export declare function getSemigroup<S, R, E, A>(
@@ -290,2 +301,43 @@ Semigroup: Sem.Semigroup<A>
 >;
+export declare const parDo: () => import("./overloadEff").Do4CE<
+  "matechs/Managed",
+  unknown,
+  {},
+  unknown,
+  never
+>;
+export declare const parSequenceS: <NER extends Record<string, Managed<any, any, any, any>>>(
+  r: (keyof NER extends never ? never : NER) & Record<string, Managed<any, any, any, any>>
+) => Managed<
+  unknown,
+  import("./overloadEff").UnionToIntersection<
+    {
+      [K in keyof NER]: unknown extends import("./overloadEff").EffypeOf<NER[K]>
+        ? never
+        : import("./overloadEff").EffypeOf<NER[K]>;
+    }[keyof NER]
+  >,
+  {
+    [K_1 in keyof NER]: [NER[K_1]] extends [Managed<any, any, infer E, any>] ? E : never;
+  }[keyof NER],
+  { [K_2 in keyof NER]: [NER[K_2]] extends [Managed<any, any, any, infer A>] ? A : never }
+>;
+export declare const parSequenceT: <T extends Managed<any, any, any, any>[]>(
+  ...t: T & {
+    0: Managed<any, any, any, any>;
+  }
+) => Managed<
+  unknown,
+  import("./overloadEff").UnionToIntersection<
+    {
+      [K in keyof T]: [T[K]] extends [Managed<any, infer R, any, any>]
+        ? unknown extends R
+          ? never
+          : R
+        : never;
+    }[number]
+  >,
+  { [K_1 in keyof T]: [T[K_1]] extends [Managed<any, any, infer E, any>] ? E : never }[number],
+  { [K_2 in keyof T]: [T[K_2]] extends [Managed<any, any, any, infer A>] ? A : never }
+>;
 export declare const sequenceOption: <S, R, E, A>(
@@ -303,2 +355,14 @@ ta: Op.Option<Managed<S, R, E, A>>
 ) => (ta: Op.Option<A>) => Managed<S, R, E, Op.Option<B>>;
+export declare const parSequenceOption: <S, R, E, A>(
+  ta: Op.Option<Managed<S, R, E, A>>
+) => Managed<unknown, R, E, Op.Option<A>>;
+export declare const parTraverseOption: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, B>
+) => (ta: Op.Option<A>) => Managed<unknown, R, E, Op.Option<B>>;
+export declare const parWiltOption: <S, A, R, E, B, C>(
+  f: (a: A) => Managed<S, R, E, Ei.Either<B, C>>
+) => (wa: Op.Option<A>) => Managed<unknown, R, E, Separated<Op.Option<B>, Op.Option<C>>>;
+export declare const parWitherOption: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, Op.Option<B>>
+) => (ta: Op.Option<A>) => Managed<unknown, R, E, Op.Option<B>>;
 export declare const sequenceEither: <TE, S, R, FE, A>(
@@ -316,2 +380,14 @@ ta: Ei.Either<TE, Managed<S, R, FE, A>>
 ) => (ta: TR.Tree<A>) => Managed<S, R, E, TR.Tree<B>>;
+export declare const parSequenceEither: <TE, S, R, FE, A>(
+  ta: Ei.Either<TE, Managed<S, R, FE, A>>
+) => Managed<unknown, R, FE, Ei.Either<TE, A>>;
+export declare const parTraverseEither: <S, A, R, FE, B>(
+  f: (a: A) => Managed<S, R, FE, B>
+) => <TE>(ta: Ei.Either<TE, A>) => Managed<unknown, R, FE, Ei.Either<TE, B>>;
+export declare const parSequenceTree: <S, R, E, A>(
+  ta: TR.Tree<Managed<S, R, E, A>>
+) => Managed<S, R, E, TR.Tree<A>>;
+export declare const parTraverseTree: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, B>
+) => (ta: TR.Tree<A>) => Managed<unknown, R, E, TR.Tree<B>>;
 export declare const sequenceArray: <S, R, E, A>(
@@ -332,2 +408,17 @@ ta: Managed<S, R, E, A>[]
 ) => (ta: Array<A>) => Managed<S, R, E, Array<B>>;
+export declare const parSequenceArray: <S, R, E, A>(
+  ta: Managed<S, R, E, A>[]
+) => Managed<unknown, R, E, A[]>;
+export declare const parTraverseArray: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, B>
+) => (ta: Array<A>) => Managed<unknown, R, E, Array<B>>;
+export declare const parTraverseArrayWithIndex: <S, A, R, E, B>(
+  f: (i: number, a: A) => Managed<S, R, E, B>
+) => (ta: Array<A>) => Managed<unknown, R, E, Array<B>>;
+export declare const parWiltArray: <S, A, R, E, B, C>(
+  f: (a: A) => Managed<S, R, E, Ei.Either<B, C>>
+) => (wa: Array<A>) => Managed<unknown, R, E, Separated<Array<B>, Array<C>>>;
+export declare const parWitherArray: <S, A, R, E, B>(
+  f: (a: A) => Managed<S, R, E, Op.Option<B>>
+) => (ta: Array<A>) => Managed<unknown, R, E, Array<B>>;
 export declare const sequenceRecord: <S, R, E, A>(
@@ -348,1 +439,64 @@ ta: Record<string, Managed<S, R, E, A>>
 ) => (ta: Record<string, A>) => Managed<S, R, E, Record<string, B>>;
+export declare const parSequenceRecord: <S, R, E, A>(
+  ta: Record<string, Managed<S, R, E, A>>
+) => Managed<unknown, R, E, Record<string, A>>;
+export declare const parTraverseRecord: <A, S, R, E, B>(
+  f: (a: A) => Managed<S, R, E, B>
+) => (ta: Record<string, A>) => Managed<unknown, R, E, Record<string, B>>;
+export declare const parTraverseRecordWithIndex: <A, S, R, E, B>(
+  f: (k: string, a: A) => Managed<S, R, E, B>
+) => (ta: Record<string, A>) => Managed<unknown, R, E, Record<string, B>>;
+export declare const parWiltRecord: <A, S, R, E, B, C>(
+  f: (a: A) => Managed<S, R, E, Ei.Either<B, C>>
+) => (
+  wa: Record<string, A>
+) => Managed<unknown, R, E, Separated<Record<string, B>, Record<string, C>>>;
+export declare const parWitherRecord: <A, S, R, E, B>(
+  f: (a: A) => Managed<S, R, E, Op.Option<B>>
+) => (ta: Record<string, A>) => Managed<unknown, R, E, Record<string, B>>;
+export declare const ap: <S1, R, E, A, E2>(
+    fa: Managed<S1, R, E, A>
+  ) => <S2, R2, B>(fab: Managed<S2, R2, E2, (a: A) => B>) => Managed<S1 | S2, R & R2, E | E2, B>,
+  apFirst: <S1, R, E, B>(
+    fb: Managed<S1, R, E, B>
+  ) => <A, S2, R2, E2>(fa: Managed<S2, R2, E2, A>) => Managed<S1 | S2, R & R2, E | E2, A>,
+  apSecond: <S1, R, E, B>(
+    fb: Managed<S1, R, E, B>
+  ) => <A, S2, R2, E2>(fa: Managed<S2, R2, E2, A>) => Managed<S1 | S2, R & R2, E | E2, B>,
+  chain: <S1, R, E, A, B>(
+    f: (a: A) => Managed<S1, R, E, B>
+  ) => <S2, R2, E2>(ma: Managed<S2, R2, E2, A>) => Managed<S1 | S2, R & R2, E | E2, B>,
+  chainFirst: <S1, R, E, A, B>(
+    f: (a: A) => Managed<S1, R, E, B>
+  ) => <S2, R2, E2>(ma: Managed<S2, R2, E2, A>) => Managed<S1 | S2, R & R2, E | E2, A>,
+  flatten: <S1, S2, R, E, R2, E2, A>(
+    mma: Managed<S1, R, E, Managed<S2, R2, E2, A>>
+  ) => Managed<S1 | S2, R & R2, E | E2, A>,
+  map: <A, B>(f: (a: A) => B) => <S, R, E>(fa: Managed<S, R, E, A>) => Managed<S, R, E, B>,
+  filterOrElse: {
+    <E, A, B extends A>(refinement: F.Refinement<A, B>, onFalse: (a: A) => E): <S, R>(
+      ma: Managed<S, R, E, A>
+    ) => Managed<S, R, E, B>;
+    <E_1, A_1>(predicate: F.Predicate<A_1>, onFalse: (a: A_1) => E_1): <S_1, R_1>(
+      ma: Managed<S_1, R_1, E_1, A_1>
+    ) => Managed<S_1, R_1, E_1, A_1>;
+  },
+  fromEither: <E, A>(ma: Ei.Either<E, A>) => Managed<never, unknown, E, A>,
+  fromOption: <E>(onNone: () => E) => <A>(ma: Op.Option<A>) => Managed<never, unknown, E, A>,
+  fromPredicate: {
+    <E, A, B extends A>(refinement: F.Refinement<A, B>, onFalse: (a: A) => E): (
+      a: A
+    ) => Managed<never, unknown, E, B>;
+    <E_1, A_1>(predicate: F.Predicate<A_1>, onFalse: (a: A_1) => E_1): (
+      a: A_1
+    ) => Managed<never, unknown, E_1, A_1>;
+  };
+export declare const parAp: <S1, R, E, A, E2>(
+    fa: Managed<S1, R, E, A>
+  ) => <S2, R2, B>(fab: Managed<S2, R2, E2, (a: A) => B>) => Managed<unknown, R & R2, E | E2, B>,
+  parApFirst: <S1, R, E, B>(
+    fb: Managed<S1, R, E, B>
+  ) => <A, S2, R2, E2>(fa: Managed<S2, R2, E2, A>) => Managed<unknown, R & R2, E | E2, A>,
+  parApSecond: <S1, R, E, B>(
+    fb: Managed<S1, R, E, B>
+  ) => <A, S2, R2, E2>(fa: Managed<S2, R2, E2, A>) => Managed<unknown, R & R2, E | E2, B>;

lib/managed.js

@@ -20,2 +20,3 @@ "use strict";
 };
+var _a, _b;
 exports.__esModule = true;
@@ -32,2 +33,3 @@ var fp_ts_1 = require("fp-ts");
 var RE = __importStar(require("fp-ts/lib/Record"));
+var pipeable_1 = require("fp-ts/lib/pipeable");
 var ManagedTag;
@@ -117,10 +119,2 @@ (function (ManagedTag) {
 /**
- * Curried form of chain
- * @param bind
- */
-function chain(bind) {
-    return function (left) { return chain_(left, bind); };
-}
-exports.chain = chain;
-/**
  * Map a resource
@@ -134,10 +128,2 @@ * @param res
 /**
- * Curried form of map
- * @param f
- */
-function map(f) {
-    return function (res) { return map_(res, f); };
-}
-exports.map = map;
-/**
  * Zip two resources together with the given function.
@@ -165,12 +151,64 @@ *
 exports.zip = zip;
+function foldExitAndFiber(aExit, bFiber, onBFail, onAFail) {
+    return T.effect.chain(bFiber.wait, function (bExit) {
+        return aExit._tag === "Done"
+            ? bExit._tag === "Done"
+                ? fp_ts_1["function"].unsafeCoerce(T.pure(fp_ts_1["function"].tuple(aExit.value, bExit.value)))
+                : pipeable_1.pipe(onBFail(aExit.value), T.chain(function () { return T.raised(bExit); }), T.chainError(function () { return T.raised(bExit); }))
+            : bExit._tag === "Done"
+                ? pipeable_1.pipe(onAFail(bExit.value), T.chain(function () { return T.raised(aExit); }), T.chainError(function () { return T.raised(aExit); }))
+                : T.raised(aExit);
+    });
+}
 /**
- * Apply the function produced by resfab to the value produced by resa to produce a new resource.
+ * Zip two resources together with provided function, while allocating and
+ * releasing them in parallel and returning first error that was raised.
+ *
  * @param resa
- * @param resfab
+ * @param resb
+ * @param f
  */
-function ap(resa, resfab) {
-    return zipWith(resa, resfab, function (a, f) { return f(a); });
+function parZipWith(resa, resb, f) {
+    var alloc = T.raceFold(allocate(resa), allocate(resb), function (aExit, bFiber) {
+        return foldExitAndFiber(aExit, bFiber, function (aLeak) { return aLeak.release; }, function (bLeak) { return bLeak.release; });
+    }, function (bExit, aFiber) {
+        return T.effect.map(foldExitAndFiber(bExit, aFiber, function (bLeak) { return bLeak.release; }, function (aLeak) { return aLeak.release; }), function (_a) {
+            var b = _a[0], a = _a[1];
+            return fp_ts_1["function"].tuple(a, b);
+        });
+    });
+    return map_(bracket(alloc, function (_a) {
+        var aLeak = _a[0], bLeak = _a[1];
+        return T.raceFold(aLeak.release, bLeak.release, function (aExit, bFiber) {
+            return foldExitAndFiber(aExit, bFiber, function () { return T.unit; }, function () { return T.unit; });
+        }, function (bExit, aFiber) {
+            return foldExitAndFiber(bExit, aFiber, function () { return T.unit; }, function () { return T.unit; });
+        });
+    }), function (_a) {
+        var aLeak = _a[0], bLeak = _a[1];
+        return f(aLeak.a, bLeak.a);
+    });
 }
-exports.ap = ap;
+exports.parZipWith = parZipWith;
 /**
+ * Zip two resources together into tuple, while allocating and releasing them
+ * in parallel and returning first error that was raised.
+ *
+ * @param resa
+ * @param resb
+ */
+function parZip(resa, resb) {
+    return parZipWith(resa, resb, fp_ts_1["function"].tuple);
+}
+exports.parZip = parZip;
+/**
+ * Parallel form of ap_
+ * @param iof
+ * @param ioa
+ */
+function parAp_(iof, ioa) {
+    return parZipWith(iof, ioa, function (f, a) { return f(a); });
+}
+exports.parAp_ = parAp_;
+/**
  * Flipped version of ap
@@ -319,2 +357,11 @@ * @param resfab
     ap: ap_,
+    chain: chain_,
+    throwError: function (e) { return encaseEffect(T.raiseError(e)); }
+};
+exports.parManaged = {
+    URI: exports.URI,
+    _CTX: "async",
+    of: pure,
+    map: map_,
+    ap: parAp_,
     chain: chain_
@@ -342,2 +389,5 @@ };
 exports.sequenceT = Apply_1.sequenceT(exports.managed);
+exports.parDo = function () { return Do_1.Do(exports.parManaged); };
+exports.parSequenceS = Apply_1.sequenceS(exports.parManaged);
+exports.parSequenceT = Apply_1.sequenceT(exports.parManaged);
 exports.sequenceOption = Op.option.sequence(exports.managed);
@@ -353,2 +403,10 @@ exports.traverseOption = function (f) { return function (ta) {
 }; };
+exports.parSequenceOption = Op.option.sequence(exports.parManaged);
+exports.parTraverseOption = function (f) { return function (ta) {
+    return Op.option.traverse(exports.parManaged)(ta, f);
+}; };
+exports.parWiltOption = function (f) { return function (wa) { return Op.option.wilt(exports.parManaged)(wa, f); }; };
+exports.parWitherOption = function (f) { return function (ta) {
+    return Op.option.wither(exports.parManaged)(ta, f);
+}; };
 exports.sequenceEither = Ei.either.sequence(exports.managed);
@@ -362,2 +420,10 @@ exports.traverseEither = function (f) { return function (ta) {
 }; };
+exports.parSequenceEither = Ei.either.sequence(exports.parManaged);
+exports.parTraverseEither = function (f) { return function (ta) {
+    return Ei.either.traverse(exports.parManaged)(ta, f);
+}; };
+exports.parSequenceTree = TR.tree.sequence(exports.managed);
+exports.parTraverseTree = function (f) { return function (ta) {
+    return TR.tree.traverse(exports.parManaged)(ta, f);
+}; };
 exports.sequenceArray = Ar.array.sequence(exports.managed);
@@ -374,2 +440,15 @@ exports.traverseArray = function (f) { return function (ta) {
 exports.witherArray = function (f) { return function (ta) { return Ar.array.wither(exports.managed)(ta, f); }; };
+exports.parSequenceArray = Ar.array.sequence(exports.parManaged);
+exports.parTraverseArray = function (f) { return function (ta) {
+    return Ar.array.traverse(exports.parManaged)(ta, f);
+}; };
+exports.parTraverseArrayWithIndex = function (f) { return function (ta) {
+    return Ar.array.traverseWithIndex(exports.parManaged)(ta, f);
+}; };
+exports.parWiltArray = function (f) { return function (wa) {
+    return Ar.array.wilt(exports.parManaged)(wa, f);
+}; };
+exports.parWitherArray = function (f) { return function (ta) {
+    return Ar.array.wither(exports.parManaged)(ta, f);
+}; };
 exports.sequenceRecord = RE.record.sequence(exports.managed);
@@ -388,1 +467,16 @@ exports.traverseRecord = function (f) { return function (ta) {
 }; };
+exports.parSequenceRecord = RE.record.sequence(exports.parManaged);
+exports.parTraverseRecord = function (f) { return function (ta) {
+    return RE.record.traverse(exports.parManaged)(ta, f);
+}; };
+exports.parTraverseRecordWithIndex = function (f) { return function (ta) {
+    return RE.record.traverseWithIndex(exports.parManaged)(ta, f);
+}; };
+exports.parWiltRecord = function (f) { return function (wa) {
+    return RE.record.wilt(exports.parManaged)(wa, f);
+}; };
+exports.parWitherRecord = function (f) { return function (ta) {
+    return RE.record.wither(exports.parManaged)(ta, f);
+}; };
+exports.ap = (_a = pipeable_1.pipeable(exports.managed), _a.ap), exports.apFirst = _a.apFirst, exports.apSecond = _a.apSecond, exports.chain = _a.chain, exports.chainFirst = _a.chainFirst, exports.flatten = _a.flatten, exports.map = _a.map, exports.filterOrElse = _a.filterOrElse, exports.fromEither = _a.fromEither, exports.fromOption = _a.fromOption, exports.fromPredicate = _a.fromPredicate;
+exports.parAp = (_b = pipeable_1.pipeable(exports.parManaged), _b.ap), exports.parApFirst = _b.apFirst, exports.parApSecond = _b.apSecond;

package.json

 {
   "name": "@matechs/effect",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "license": "MIT",
@@ -43,3 +43,3 @@ "private": false,
   },
-  "gitHead": "505584dc43a051c72aad8a3af619288b0cf1ca4a"
+  "gitHead": "2e499df297e696f98962d4114ebb694f119e4964"
 }

No alert changes

Improved metrics

Total package byte prevSize

683640

increased by3.33%

Lines of code

19786

increased by2.35%

No dependency changes