@matechs/effect - npm Package Compare versions

Comparing version 6.3.1 to 6.4.0

es6/deferred.d.ts

@@ -52,2 +52,10 @@ import { Exit, Cause } from "./original/exit";
 }
+export declare type Async<A> = Deferred<unknown, unknown, never, A>;
+export declare type AsyncE<E, A> = Deferred<unknown, unknown, E, A>;
+export declare type AsyncR<R, A> = Deferred<unknown, R, never, A>;
+export declare type AsyncRE<R, E, A> = Deferred<unknown, R, E, A>;
+export declare type Sync<A> = Deferred<never, unknown, never, A>;
+export declare type SyncE<E, A> = Deferred<never, unknown, E, A>;
+export declare type SyncR<R, A> = Deferred<never, R, never, A>;
+export declare type SyncRE<R, E, A> = Deferred<never, R, E, A>;
 export declare class DeferredImpl<S, R, E, A> implements Deferred<S, R, E, A> {
@@ -54,0 +62,0 @@ readonly r: R;

es6/effect.d.ts

@@ -1133,1 +1133,16 @@ import {
 ) => (ta: Record<string, A>) => AsyncRE<R, E, Record<string, B>>;
+export declare const handle: <
+  E,
+  K extends string & keyof E,
+  KK extends string & E[K],
+  S2,
+  R2,
+  E2,
+  A2
+>(
+  k: K,
+  kk: KK,
+  f: (_: Extract<E, { [k in K]: KK }>) => Effect<S2, R2, E2, A2>
+) => <S, R, A>(
+  _: Effect<S, R, E, A>
+) => Effect<S2 | S, R & R2, E2 | Exclude<E, { [k_1 in K]: KK }>, A2 | A>;

es6/effect.js

@@ -1192,1 +1192,9 @@ import { either as Ei, function as F, option as Op, array as Ar, tree as TR, record as RE } from "fp-ts";
 export const witherRecordPar = (f) => (ta) => RE.record.wither(parEffect)(ta, f);
+export const handle = (k, kk, f) => (_) => pipe(_, chainError((e) => {
+    if (k in e) {
+        if (e[k] === kk) {
+            return f(e);
+        }
+    }
+    return raiseError(e);
+}));

es6/freeEnv.d.ts

@@ -5,2 +5,3 @@ import * as T from "./effect";
 import { FunctionN } from "fp-ts/es6/function";
+import { Managed } from "./managed";
 export declare type Patched<A, B> = B extends F.FunctionN<
@@ -172,2 +173,35 @@ infer ARG,
 >;
+export declare function implementWithM<SW, RW, EW, AW>(
+  w: Managed<SW, RW, EW, AW>
+): <S extends ModuleSpec<any>>(
+  s: S,
+  inverted?: "regular" | "inverted"
+) => <I extends Implementation<TypeOf<S>>>(
+  i: (r: AW) => I
+) => T.Provider<
+  UnionToIntersection<
+    {
+      [k in keyof OnlyNew<TypeOf<S>, I>]: {
+        [h in keyof OnlyNew<TypeOf<S>, I>[k]]: OnlyNew<TypeOf<S>, I>[k][h] extends F.FunctionN<
+          any,
+          infer K
+        >
+          ? K extends T.Effect<any, infer R, any, any>
+            ? unknown extends R
+              ? never
+              : R
+            : never
+          : OnlyNew<TypeOf<S>, I>[k][h] extends T.Effect<any, infer R_1, any, any>
+          ? unknown extends R_1
+            ? never
+            : R_1
+          : never;
+      }[keyof OnlyNew<TypeOf<S>, I>[k]];
+    }[keyof I & keyof TypeOf<S>]
+  > &
+    RW,
+  TypeOf<S>,
+  EW,
+  SW
+>;
 export declare function instance<M extends ModuleShape<M>, S extends ModuleSpec<M>>(
@@ -174,0 +208,0 @@ _: S

es6/freeEnv.js

 import * as T from "./effect";
 import { pipeable as P } from "fp-ts";
+import { use } from "./managed";
 export function access(sp) {
@@ -51,2 +52,5 @@ const derived = {};
 }
+export function implementWithM(w) {
+    return (s, inverted = "regular") => (i) => (eff) => use(w, (r) => T.accessM((e) => P.pipe(eff, T.provide(providing(s, i(r), e), inverted))));
+}
 export function instance(_) {
@@ -53,0 +57,0 @@ return (m) => m;

es6/rec/ana.d.ts

 import { Kind, URIS } from "fp-ts/es6/HKT";
 import * as EF from "../effect";
 import { Fix } from "./Fix";
-import { TMap } from "./TMap";
+import { FunctorM } from "./functor";
 export interface Coalgebra<F extends URIS, S, R, E, A> {
@@ -9,5 +9,5 @@ (_: A): EF.Effect<S, R, E, Kind<F, A>>;
 export declare function ana<S, R, E, F extends URIS>(
-  F: TMap<F, S, R, E>
+  F: FunctorM<F, S, R, E>
 ): <S2, R2, E2, A>(
   coalg: Coalgebra<F, S2, R2, E2, A>
 ) => (_: A) => EF.Effect<S | S2, R & R2, E | E2, Fix<F>>;

es6/rec/cata.d.ts

 import { Kind, URIS } from "fp-ts/es6/HKT";
 import * as EF from "../effect";
 import { Fix } from "./Fix";
-import { TMap } from "./TMap";
+import { FunctorM } from "./functor";
 export interface Algebra<F extends URIS, S, R, E, A> {
@@ -9,5 +9,5 @@ (_: Kind<F, A>): EF.Effect<S, R, E, A>;
 export declare function cata<S, R, E, F extends URIS>(
-  F: TMap<F, S, R, E>
+  F: FunctorM<F, S, R, E>
 ): <S2, R2, E2, A>(
   alg: Algebra<F, S2, R2, E2, A>
 ) => (_: Fix<F>) => EF.Effect<S | S2, R & R2, E | E2, A>;

es6/rec/hylo.d.ts

@@ -5,5 +5,5 @@ import { URIS } from "fp-ts/es6/HKT";
 import { Algebra } from "./cata";
-import { TMap } from "./TMap";
+import { FunctorM } from "./functor";
 export declare function hylo<S, R, E, F extends URIS>(
-  F: TMap<F, S, R, E>
+  F: FunctorM<F, S, R, E>
 ): <S1, S2, R1, R2, E1, E2, A, B>(
@@ -10,0 +10,0 @@ alg: Algebra<F, S1, R1, E1, B>,

es6/rec/index.d.ts

@@ -7,3 +7,3 @@ /**
 export { ana, Coalgebra } from "./ana";
-export { TMap } from "./TMap";
+export { FunctorM } from "./functor";
 export { hylo } from "./hylo";

lib/deferred.d.ts

@@ -52,2 +52,10 @@ import { Exit, Cause } from "./original/exit";
 }
+export declare type Async<A> = Deferred<unknown, unknown, never, A>;
+export declare type AsyncE<E, A> = Deferred<unknown, unknown, E, A>;
+export declare type AsyncR<R, A> = Deferred<unknown, R, never, A>;
+export declare type AsyncRE<R, E, A> = Deferred<unknown, R, E, A>;
+export declare type Sync<A> = Deferred<never, unknown, never, A>;
+export declare type SyncE<E, A> = Deferred<never, unknown, E, A>;
+export declare type SyncR<R, A> = Deferred<never, R, never, A>;
+export declare type SyncRE<R, E, A> = Deferred<never, R, E, A>;
 export declare class DeferredImpl<S, R, E, A> implements Deferred<S, R, E, A> {
@@ -54,0 +62,0 @@ readonly r: R;

lib/effect.d.ts

@@ -1133,1 +1133,16 @@ import {
 ) => (ta: Record<string, A>) => AsyncRE<R, E, Record<string, B>>;
+export declare const handle: <
+  E,
+  K extends string & keyof E,
+  KK extends string & E[K],
+  S2,
+  R2,
+  E2,
+  A2
+>(
+  k: K,
+  kk: KK,
+  f: (_: Extract<E, { [k in K]: KK }>) => Effect<S2, R2, E2, A2>
+) => <S, R, A>(
+  _: Effect<S, R, E, A>
+) => Effect<S2 | S, R & R2, E2 | Exclude<E, { [k_1 in K]: KK }>, A2 | A>;

lib/effect.js

@@ -1467,1 +1467,11 @@ "use strict";
 }; };
+exports.handle = function (k, kk, f) { return function (_) {
+    return pipeable_1.pipe(_, chainError(function (e) {
+        if (k in e) {
+            if (e[k] === kk) {
+                return f(e);
+            }
+        }
+        return raiseError(e);
+    }));
+}; };

lib/freeEnv.d.ts

@@ -5,2 +5,3 @@ import * as T from "./effect";
 import { FunctionN } from "fp-ts/lib/function";
+import { Managed } from "./managed";
 export declare type Patched<A, B> = B extends F.FunctionN<
@@ -172,2 +173,35 @@ infer ARG,
 >;
+export declare function implementWithM<SW, RW, EW, AW>(
+  w: Managed<SW, RW, EW, AW>
+): <S extends ModuleSpec<any>>(
+  s: S,
+  inverted?: "regular" | "inverted"
+) => <I extends Implementation<TypeOf<S>>>(
+  i: (r: AW) => I
+) => T.Provider<
+  UnionToIntersection<
+    {
+      [k in keyof OnlyNew<TypeOf<S>, I>]: {
+        [h in keyof OnlyNew<TypeOf<S>, I>[k]]: OnlyNew<TypeOf<S>, I>[k][h] extends F.FunctionN<
+          any,
+          infer K
+        >
+          ? K extends T.Effect<any, infer R, any, any>
+            ? unknown extends R
+              ? never
+              : R
+            : never
+          : OnlyNew<TypeOf<S>, I>[k][h] extends T.Effect<any, infer R_1, any, any>
+          ? unknown extends R_1
+            ? never
+            : R_1
+          : never;
+      }[keyof OnlyNew<TypeOf<S>, I>[k]];
+    }[keyof I & keyof TypeOf<S>]
+  > &
+    RW,
+  TypeOf<S>,
+  EW,
+  SW
+>;
 export declare function instance<M extends ModuleShape<M>, S extends ModuleSpec<M>>(
@@ -174,0 +208,0 @@ _: S

lib/freeEnv.js

@@ -12,2 +12,3 @@ "use strict";
 var fp_ts_1 = require("fp-ts");
+var managed_1 = require("./managed");
 function access(sp) {
@@ -115,2 +116,15 @@ var derived = {};
 exports.implementWith = implementWith;
+function implementWithM(w) {
+    return function (s, inverted) {
+        if (inverted === void 0) { inverted = "regular"; }
+        return function (i) { return function (eff) {
+            return managed_1.use(w, function (r) {
+                return T.accessM(function (e) {
+                    return fp_ts_1.pipeable.pipe(eff, T.provide(providing(s, i(r), e), inverted));
+                });
+            });
+        }; };
+    };
+}
+exports.implementWithM = implementWithM;
 function instance(_) {
@@ -117,0 +131,0 @@ return function (m) { return m; };

lib/rec/ana.d.ts

 import { Kind, URIS } from "fp-ts/lib/HKT";
 import * as EF from "../effect";
 import { Fix } from "./Fix";
-import { TMap } from "./TMap";
+import { FunctorM } from "./functor";
 export interface Coalgebra<F extends URIS, S, R, E, A> {
@@ -9,5 +9,5 @@ (_: A): EF.Effect<S, R, E, Kind<F, A>>;
 export declare function ana<S, R, E, F extends URIS>(
-  F: TMap<F, S, R, E>
+  F: FunctorM<F, S, R, E>
 ): <S2, R2, E2, A>(
   coalg: Coalgebra<F, S2, R2, E2, A>
 ) => (_: A) => EF.Effect<S | S2, R & R2, E | E2, Fix<F>>;

lib/rec/cata.d.ts

 import { Kind, URIS } from "fp-ts/lib/HKT";
 import * as EF from "../effect";
 import { Fix } from "./Fix";
-import { TMap } from "./TMap";
+import { FunctorM } from "./functor";
 export interface Algebra<F extends URIS, S, R, E, A> {
@@ -9,5 +9,5 @@ (_: Kind<F, A>): EF.Effect<S, R, E, A>;
 export declare function cata<S, R, E, F extends URIS>(
-  F: TMap<F, S, R, E>
+  F: FunctorM<F, S, R, E>
 ): <S2, R2, E2, A>(
   alg: Algebra<F, S2, R2, E2, A>
 ) => (_: Fix<F>) => EF.Effect<S | S2, R & R2, E | E2, A>;

lib/rec/hylo.d.ts

@@ -5,5 +5,5 @@ import { URIS } from "fp-ts/lib/HKT";
 import { Algebra } from "./cata";
-import { TMap } from "./TMap";
+import { FunctorM } from "./functor";
 export declare function hylo<S, R, E, F extends URIS>(
-  F: TMap<F, S, R, E>
+  F: FunctorM<F, S, R, E>
 ): <S1, S2, R1, R2, E1, E2, A, B>(
@@ -10,0 +10,0 @@ alg: Algebra<F, S1, R1, E1, B>,

lib/rec/index.d.ts

@@ -7,3 +7,3 @@ /**
 export { ana, Coalgebra } from "./ana";
-export { TMap } from "./TMap";
+export { FunctorM } from "./functor";
 export { hylo } from "./hylo";

package.json

 {
   "name": "@matechs/effect",
-  "version": "6.3.1",
+  "version": "6.4.0",
   "license": "MIT",
@@ -43,3 +43,3 @@ "private": false,
   },
-  "gitHead": "d2797c67f3a362e85925d51be5826cb36135681a"
+  "gitHead": "c6589396b3e9f74aaa591ae9394175c5713f5197"
 }

No alert changes

Improved metrics

Total package byte prevSize

688435

increased by0.7%

Lines of code

19936

increased by0.76%

No dependency changes