@matechs/effect - npm Package Compare versions

Comparing version 0.0.21 to 0.0.22

lib/deferred.d.ts

 import { Exit, Cause } from "waveguide/lib/exit";
 import * as T from "./";
-export interface Deferred<E, A> {
+export interface Deferred<R, E, A> {
     /**
@@ -9,3 +9,3 @@ * Wait for this deferred to complete.
      */
-    readonly wait: T.Effect<T.NoEnv, E, A>;
+    readonly wait: T.Effect<R, E, A>;
     /**
@@ -50,4 +50,4 @@ * Interrupt any waitersa on this Deferred
      */
-    from(source: T.Effect<T.NoEnv, E, A>): T.Effect<T.NoEnv, T.NoErr, void>;
+    from(source: T.Effect<R, E, A>): T.Effect<T.NoEnv, T.NoErr, void>;
 }
-export declare function makeDeferred<E, A, E2 = never>(): T.Effect<T.NoEnv, E2, Deferred<E, A>>;
+export declare function makeDeferred<R, E, A, E2 = never>(): T.Effect<R, E2, Deferred<R, E, A>>;

lib/deferred.js

@@ -21,47 +21,50 @@ "use strict";
 function makeDeferred() {
-    return T.fromIO(function () {
-        var c = completable_1.completable();
-        var wait = T.flatten(T.fromAsync(function (callback) { return c.listen(callback); }));
-        var interrupt = T.fromIO(function () {
-            c.complete(T.fromWave(io.raiseInterrupt));
+    return T.accessM(function (r) {
+        return T.fromIO(function () {
+            var c = completable_1.completable();
+            var wait = T.flatten(T.fromAsync(function (callback) { return c.listen(callback); }) // TODO: this is fine, typedoc thinks differently
+            );
+            var interrupt = T.fromIO(function () {
+                c.complete(T.fromWave(io.raiseInterrupt));
+            });
+            var done = function (a) {
+                return T.fromIO(function () {
+                    c.complete(T.right(a));
+                });
+            };
+            var error = function (e) {
+                return T.fromIO(function () {
+                    c.complete(T.left(e));
+                });
+            };
+            var abort = function (e) {
+                return T.fromIO(function () {
+                    c.complete(T.raiseAbort(e));
+                });
+            };
+            var cause = function (e) {
+                return T.fromIO(function () {
+                    c.complete(T.raised(e));
+                });
+            };
+            var complete = function (exit) {
+                return T.fromIO(function () {
+                    c.complete(T.completed(exit));
+                });
+            };
+            var from = function (source) {
+                var completed = T.effectMonad.chain(T.effectMonad.result(source), complete);
+                return T.effectMonad.onInterrupted(T.provide(r)(completed), interrupt);
+            };
+            return {
+                wait: wait,
+                interrupt: interrupt,
+                done: done,
+                error: error,
+                abort: abort,
+                cause: cause,
+                complete: complete,
+                from: from
+            };
         });
-        var done = function (a) {
-            return T.fromIO(function () {
-                c.complete(T.right(a));
-            });
-        };
-        var error = function (e) {
-            return T.fromIO(function () {
-                c.complete(T.left(e));
-            });
-        };
-        var abort = function (e) {
-            return T.fromIO(function () {
-                c.complete(T.raiseAbort(e));
-            });
-        };
-        var cause = function (e) {
-            return T.fromIO(function () {
-                c.complete(T.raised(e));
-            });
-        };
-        var complete = function (exit) {
-            return T.fromIO(function () {
-                c.complete(T.completed(exit));
-            });
-        };
-        var from = function (source) {
-            var completed = T.effectMonad.chain(T.effectMonad.result(source), complete);
-            return T.effectMonad.onInterrupted(completed, interrupt);
-        };
-        return {
-            wait: wait,
-            interrupt: interrupt,
-            done: done,
-            error: error,
-            abort: abort,
-            cause: cause,
-            complete: complete,
-            from: from
-        };
     });
@@ -68,0 +71,0 @@ }

lib/index.d.ts

@@ -14,2 +14,3 @@ import * as Ei from "fp-ts/lib/Either";
 export { done, abort, raise, ExitTag, Exit, Cause, Abort, Done, Interrupt, interrupt, Raise } from "waveguide/lib/exit";
+export { isDone, isAbort, isRaise, isInterrupt, fold, exit } from "./exit";
 export declare const URI = "matechs/Effect";
@@ -49,2 +50,10 @@ export declare type URI = typeof URI;
     bracket<R, E, A, B>(acquire: Kind3<T, R, E, A>, release: FunctionN<[A], Kind3<T, R, E, unknown>>, use: FunctionN<[A], Kind3<T, R, E, B>>): Kind3<T, R, E, B>;
+    as<R, E, A, B>(io: Kind3<T, R, E, A>, b: B): Kind3<T, R, E, B>;
+    shiftAfter<R, E, A>(io: Kind3<T, R, E, A>): Kind3<T, R, E, A>;
+    delay<R, E, A>(inner: Kind3<T, R, E, A>, ms: number): Kind3<T, R, E, A>;
+    never: Kind3<T, NoEnv, NoErr, never>;
+    foldExitWith<R, E1, E2, A1, A2>(failure: FunctionN<[Cause<E1>], Kind3<T, R, E2, A2>>, success: FunctionN<[A1], Kind3<T, R, E2, A2>>): FunctionN<[Kind3<T, R, E1, A1>], Kind3<T, R, E2, A2>>;
+    chainTapWith<R, E, A>(bind: FunctionN<[A], Kind3<T, R, E, unknown>>): (inner: Kind3<T, R, E, A>) => Kind3<T, R, E, A>;
+    raceFirst<R, E, A, R2, E2>(io1: Kind3<URI, R, E, A>, io2: Kind3<URI, R2, E2, A>): Kind3<URI, R & R2, E | E2, A>;
+    zipWith<R, E, A, R2, E2, B, C>(first: Kind3<T, R, E, A>, second: Kind3<T, R2, E2, B>, f: FunctionN<[A, B], C>): Kind3<T, R & R2, E | E2, C>;
 }
@@ -63,3 +72,8 @@ export declare const effectMonad: MonadEffect<URI>;
 export declare const unit: Effect<NoEnv, NoErr, void>;
+export declare const never: Effect<NoEnv, NoErr, never>;
 export declare const raiseInterrupt: Effect<NoEnv, NoErr, void>;
+export declare function as<R, E, A, B>(io: Effect<R, E, A>, b: B): Effect<R, E, B>;
+export declare function shiftAfter<R, E, A>(io: Effect<R, E, A>): Effect<R, E, A>;
+export declare function foldExitWith<R, E1, E2, A1, A2>(failure: FunctionN<[Cause<E1>], Kind3<URI, R, E2, A2>>, success: FunctionN<[A1], Kind3<URI, R, E2, A2>>): FunctionN<[Effect<R, E1, A1>], Effect<R, E2, A2>>;
+export declare function chainTapWith<R, E, A>(bind: FunctionN<[A], Effect<R, E, unknown>>): (inner: Effect<R, E, A>) => Effect<R, E, A>;
 export declare function fromAsync<A>(op: FunctionN<[FunctionN<[A], void>], Lazy<void>>): Effect<NoEnv, NoErr, A>;
@@ -80,2 +94,5 @@ export declare function fromWave<E, A>(w: W.Wave<E, A>): Effect<NoEnv, E, A>;
 export declare function chainLeft<E, E2, A, R2>(onLeft: (e: E) => Effect<R2, E2, A>): <R>(ma: Effect<R, E, A>) => Effect<R & R2, E2, A>;
+export declare function delay<R, E, A>(inner: Effect<R, E, A>, ms: number): Effect<R, E, A>;
+export declare function raceFirst<R, E, A, R2, E2>(io1: Effect<R, E, A>, io2: Effect<R2, E | E2, A>): Kind3<URI, R & R2, E | E2, A>;
+export declare function zipWith<R, E, A, R2, E2, B, C>(first: Effect<R, E, A>, second: Effect<R2, E2, B>, f: FunctionN<[A, B], C>): Effect<R & R2, E | E2, C>;
 export declare function when(predicate: boolean): <R, E, A>(ma: Effect<R, E, A>) => Effect<R, E, Op.Option<A>>;
@@ -82,0 +99,0 @@ export declare function or_(predicate: boolean): <R, E, A>(ma: Effect<R, E, A>) => <R2, E2, B>(mb: Effect<R2, E2, B>) => Effect<R & R2, E | E2, Ei.Either<A, B>>;

lib/index.js

@@ -37,2 +37,9 @@ "use strict";
 exports.interrupt = exit_1.interrupt;
+var exit_2 = require("./exit");
+exports.isDone = exit_2.isDone;
+exports.isAbort = exit_2.isAbort;
+exports.isRaise = exit_2.isRaise;
+exports.isInterrupt = exit_2.isInterrupt;
+exports.fold = exit_2.fold;
+exports.exit = exit_2.exit;
 exports.URI = "matechs/Effect";
@@ -137,3 +144,28 @@ exports.effectMonad = {
     },
-    raiseInterrupt: function (_) { return W.raiseInterrupt; }
+    raiseInterrupt: function (_) { return W.raiseInterrupt; },
+    as: function (io, b) { return function (r) { return W.as(io(r), b); }; },
+    shiftAfter: function (io) {
+        return function (r) { return W.shiftAfter(io(r)); };
+    },
+    delay: function (inner, ms) {
+        return function (r) { return W.delay(inner(r), ms); };
+    },
+    /* istanbul ignore next */
+    never: function (_) { return W.never; },
+    foldExitWith: function (failure, success) {
+        return function (ma) { return function (r) {
+            return pipeable_1.pipe(ma(r), W.foldExitWith(function (c) { return failure(c)(r); }, function (a) { return success(a)(r); }));
+        }; };
+    },
+    chainTapWith: function (bind) {
+        return function (inner) { return function (r) {
+            return pipeable_1.pipe(inner(r), W.chainTapWith(function (a) { return bind(a)(r); }));
+        }; };
+    },
+    raceFirst: function (io1, io2) {
+        return function (r) { return W.raceFirst(io1(r), io2(r)); };
+    },
+    zipWith: function (first, second, f) {
+        return function (r) { return W.zipWith(first(r), second(r), f); };
+    }
 };
@@ -149,3 +181,20 @@ exports.concurrentEffectMonad = __assign(__assign({}, exports.effectMonad), { ap: function (fab, fa) { return function (r) { return W.parWave.ap(fab(r), fa(r)); }; } });
 exports.unit = exports.effectMonad.unit;
+exports.never = exports.effectMonad.never;
 exports.raiseInterrupt = exports.effectMonad.raiseInterrupt;
+function as(io, b) {
+    return exports.effectMonad.as(io, b);
+}
+exports.as = as;
+function shiftAfter(io) {
+    return exports.effectMonad.shiftAfter(io);
+}
+exports.shiftAfter = shiftAfter;
+function foldExitWith(failure, success) {
+    return exports.effectMonad.foldExitWith(failure, success);
+}
+exports.foldExitWith = foldExitWith;
+function chainTapWith(bind) {
+    return exports.effectMonad.chainTapWith(bind);
+}
+exports.chainTapWith = chainTapWith;
 /* lift functions */
@@ -212,2 +261,14 @@ function fromAsync(op) {
 exports.chainLeft = chainLeft;
+function delay(inner, ms) {
+    return exports.effectMonad.delay(inner, ms);
+}
+exports.delay = delay;
+function raceFirst(io1, io2) {
+    return exports.effectMonad.raceFirst(io1, io2);
+}
+exports.raceFirst = raceFirst;
+function zipWith(first, second, f) {
+    return exports.effectMonad.zipWith(first, second, f);
+}
+exports.zipWith = zipWith;
 /* conditionals */
@@ -214,0 +275,0 @@ function when(predicate) {

lib/managed.d.ts

@@ -7,5 +7,6 @@ import * as T from "./";
 import { Monad3E } from "./overload";
+import { Fiber } from "waveguide/lib/wave";
 export declare type Managed<R, E, A> = (r: R) => M.Managed<E, A>;
 export declare function encaseManaged<E, A>(m: M.Managed<E, A>): Managed<{}, E, A>;
-export declare function pure<A>(value: A): Managed<{}, never, A>;
+export declare function pure<E = never, A = unknown>(value: A): Managed<{}, E, A>;
 export declare function encaseEffect<R, E, A>(effect: T.Effect<R, E, A>): Managed<R, E, A>;
@@ -18,4 +19,4 @@ export declare function bracket<R, E, A>(acquire: T.Effect<R, E, A>, release: FunctionN<[A], T.Effect<R, E, unknown>>): Managed<R, E, A>;
 export declare function mapWith<L, A>(f: FunctionN<[L], A>): <R, E>(res: Managed<R, E, L>) => Managed<R, E, A>;
-export declare function zipWith<R, E, A, B, C>(ma: Managed<R, E, A>, mb: Managed<R, E, B>, f: FunctionN<[A, B], C>): Managed<R, E, C>;
-export declare function zip<R, E, A, B>(ma: Managed<R, E, A>, mb: Managed<R, E, B>): Managed<R, E, readonly [A, B]>;
+export declare function zipWith<R, E, A, R2, E2, B, C>(ma: Managed<R, E, A>, mb: Managed<R2, E2, B>, f: FunctionN<[A, B], C>): Managed<R & R2, E | E2, C>;
+export declare function zip<R, E, A, R2, E2, B>(ma: Managed<R, E, A>, mb: Managed<R2, E2, B>): Managed<R & R2, E | E2, readonly [A, B]>;
 export declare function ap<R, E, A, B>(ma: Managed<R, E, A>, mfab: Managed<R, E, FunctionN<[A], B>>): Managed<R, E, B>;
@@ -35,2 +36,3 @@ export declare function ap_<R, E, A, B>(mfab: Managed<R, E, FunctionN<[A], B>>, ma: Managed<R, E, A>): Managed<R, E, B>;
 export declare function provideTo<R, E, A, B>(ma: Managed<R, E, A>, effect: T.Effect<A, E, B>): T.Effect<R, E, B>;
+export declare function fiber<R, E, A>(rio: T.Effect<R, E, A>): Managed<R, never, Fiber<E, A>>;
 export declare const URI = "matechs/Managed";
@@ -37,0 +39,0 @@ export declare type URI = typeof URI;

lib/managed.js

@@ -118,2 +118,6 @@ "use strict";
 exports.provideTo = provideTo;
+function fiber(rio) {
+    return function (r) { return M.fiber(rio(r)); };
+}
+exports.fiber = fiber;
 exports.URI = "matechs/Managed";
@@ -120,0 +124,0 @@ exports.managed = {

package.json

 {
   "name": "@matechs/effect",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "license": "MIT",
@@ -23,5 +23,7 @@ "private": false,
     "@babel/preset-typescript": "^7.7.2",
+    "@types/chai": "^4.2.5",
     "@types/jest": "^24.0.23",
     "@types/node": "^12.12.11",
     "babel-jest": "^24.9.0",
+    "chai": "^4.2.0",
     "jest": "^24.9.0",
@@ -39,3 +41,3 @@ "rimraf": "^3.0.0",
   },
-  "gitHead": "a1d27abf96f57012bd8cb524f16c7c0507974156"
+  "gitHead": "f25f40ed4d5c4d169cbf95e3f2099783dac495bd"
 }

No alert changes

Improved metrics

Total package byte prevSize

193876

139.89%

Number of package files

42

40%

Lines of code

2910

159.82%

Worsened metrics

Dev dependency count

13

18.18%

No dependency changes