@fncts/base 0.0.19 → 0.0.21

package/_src/data/EitherT/api.ts

@@ -36,7 +36,7 @@ export function rightF<F extends HKT, FC>(
 ): <K, Q, W, X, I, S, R, FE, E = never, A = never>(
   self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, A>,
 ) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
-  return (self) => F.map(self, Either.right);
+  return F.map(Either.right);
 }
 
 /**
@@ -47,52 +47,48 @@ export function leftF<F extends HKT, FC>(
 ): <K, Q, W, X, I, S, R, FE, E = never, A = never>(
   self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, E>,
 ) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
-  return (self) => F.map(self, Either.left);
+  return F.map(Either.left);
 }
 
 /**
  * @tsplus static fncts.EitherTOps map
  */
-export function map<F extends HKT, FC>(
-  F: P.Functor<F, FC>,
-): <K, Q, W, X, I, S, R, FE, E, A, B>(
-  self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>,
-  f: (a: A) => B,
-) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B> {
-  return (self, f) => F.map(self, (either) => either.map(f));
+export function map<F extends HKT, FC>(F: P.Functor<F, FC>) {
+  return <A, B>(
+    f: (a: A) => B,
+  ): (<K, Q, W, X, I, S, R, FE, E>(
+    self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>,
+  ) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>) => F.map((either) => either.map(f));
 }
 
 /**
  * @tsplus static fncts.EitherTOps mapLeft
  */
-export function mapLeft<F extends HKT, FC = HKT.None>(
-  F: P.Functor<F, FC>,
-): <K, Q, W, X, I, S, R, FE, E, A, E1>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>,
-  f: (e: E) => E1,
-) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, A>> {
-  return (self, f) => F.map(self, (either) => either.mapLeft(f));
+export function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>) {
+  return <E, E1>(
+    f: (e: E) => E1,
+  ): (<K, Q, W, X, I, S, R, FE, A>(
+    self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, A>>) => F.map((either) => either.mapLeft(f));
 }
 
 /**
  * @tsplus static fncts.EitherTOps bimap
  */
-export function bimap<F extends HKT, FC = HKT.None>(
-  F: P.Functor<F, FC>,
-): <K, Q, W, X, I, S, R, FE, E, A, E1, B>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>,
-  f: (e: E) => E1,
-  g: (a: A) => B,
-) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, B>> {
-  return (self, f, g) => F.map(self, (either) => either.bimap(f, g));
+export function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>) {
+  return <E, A, E1, B>(
+    f: (e: E) => E1,
+    g: (a: A) => B,
+  ): (<K, Q, W, X, I, S, R, FE>(
+    self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, B>>) => F.map((either) => either.bimap(f, g));
 }
 
 /**
  * @tsplus static fncts.EitherTOps flatMap
  */
 export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
-  return <K, Q, W, X, I, S, R, FE, E, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(
-    self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>,
+  return <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(
     f: (
       a: A,
     ) => HKT.Kind<
@@ -108,7 +104,9 @@ export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
       HKT.Intro<F, "E", FE, FE1>,
       Either<E1, B>
     >,
-  ): EitherT<
+  ): (<E>(
+    self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>,
+  ) => EitherT<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -121,9 +119,8 @@ export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
     HKT.Mix<F, "E", [FE, FE1]>,
     E | E1,
     B
-  > =>
+  >) =>
     F.flatMap(
-      self,
       (either) =>
         either.match(
           (e) => F.pure(Either.left(e)),
@@ -149,8 +146,7 @@ export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
  */
 export function zipWith<F extends HKT, FC = HKT.None>(
   F: P.Apply<F, FC>,
-): <K, Q, W, X, I, S, R, EF, E, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B, C>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>,
+): <K, Q, W, X, I, S, R, EF, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B, C>(
   that: HKT.Kind<
     F,
     FC,
@@ -165,6 +161,8 @@ export function zipWith<F extends HKT, FC = HKT.None>(
     Either<E1, B>
   >,
   f: (a: A, b: B) => C,
+) => <E>(
+  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>,
 ) => HKT.Kind<
   F,
   FC,
@@ -178,14 +176,12 @@ export function zipWith<F extends HKT, FC = HKT.None>(
   HKT.Intro<F, "E", EF, EF1>,
   Either<E | E1, C>
 >;
-export function zipWith<F extends HKT>(
-  F: P.Apply<HKT.F<F>>,
-): <E, A, E1, B, C>(
-  self: HKT.FK1<F, Either<E, A>>,
-  that: HKT.FK1<F, Either<E1, B>>,
-  f: (a: A, b: B) => C,
-) => HKT.FK1<F, Either<E | E1, C>> {
-  return (self, that, f) => F.zipWith(self, that, (a, b) => a.zipWith(b, f));
+export function zipWith<F extends HKT>(F: P.Apply<HKT.F<F>>) {
+  return <A, E1, B, C>(
+    that: HKT.FK1<F, Either<E1, B>>,
+    f: (a: A, b: B) => C,
+  ): (<E>(self: HKT.FK1<F, Either<E, A>>) => HKT.FK1<F, Either<E | E1, C>>) =>
+    F.zipWith(that, (a, b) => a.zipWith(b, f));
 }
 
 /**
@@ -193,8 +189,7 @@ export function zipWith<F extends HKT>(
  */
 export function orElse<F extends HKT, FC = HKT.None>(
   F: P.Monad<F, FC>,
-): <K, Q, W, X, I, S, R, EF, E, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>,
+): <K, Q, W, X, I, S, R, EF, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B>(
   that: Lazy<
     HKT.Kind<
       F,
@@ -210,6 +205,8 @@ export function orElse<F extends HKT, FC = HKT.None>(
       Either<E1, B>
     >
   >,
+) => <E, A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>,
 ) => HKT.Kind<
   F,
   FC,
@@ -223,14 +220,11 @@ export function orElse<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [EF, EF1]>,
   Either<E | E1, A | B>
 >;
-export function orElse<F>(
-  F: P.Monad<HKT.F1<F>>,
-): <E, A, E1, B>(
-  self: HKT.FK1<F, Either<E, A>>,
-  that: Lazy<HKT.FK1<F, Either<E1, B>>>,
-) => HKT.FK1<F, Either<E | E1, A | B>> {
-  return (self, that) =>
-    F.flatMap(self, (either) =>
+export function orElse<F>(F: P.Monad<HKT.F1<F>>) {
+  return <E, A, E1, B>(
+    that: Lazy<HKT.FK1<F, Either<E1, B>>>,
+  ): ((self: HKT.FK1<F, Either<E, A>>) => HKT.FK1<F, Either<E | E1, A | B>>) =>
+    F.flatMap((either) =>
       either.match(
         () => that(),
         () => F.pure(either),

package/_src/data/Encoder/api.ts

@@ -0,0 +1,123 @@
+import type { Brand } from "../Branded.js";
+import type { Check } from "@fncts/typelevel";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+
+import { Encoder } from "./definition.js";
+
+/**
+ * @tsplus static fncts.EncoderOps __call
+ */
+export function makeEncoder<A>(encode: (inp: A) => unknown): Encoder<A> {
+  return new Encoder(encode);
+}
+
+/**
+ * @tsplus implicit
+ */
+export const boolean: Encoder<boolean> = Encoder(Function.identity);
+
+/**
+ * @tsplus implicit
+ */
+export const number: Encoder<number> = Encoder(Function.identity);
+
+/**
+ * @tsplus implicit
+ */
+export const string: Encoder<number> = Encoder(Function.identity);
+
+/**
+ * @tsplus implicit
+ */
+export const _null: Encoder<null> = Encoder(Function.identity);
+
+/**
+ * @tsplus implicit
+ */
+export const date: Encoder<Date> = Encoder((d) => d.toISOString());
+
+/**
+ * @tsplus derive fncts.Encoder<_> 10
+ */
+export function deriveValidation<A extends Brand.Valid<any, any>>(
+  ...[base]: Check<Brand.IsValidated<A>> extends Check.True ? [base: Encoder<Brand.Unbranded<A>>] : never
+): Encoder<A> {
+  return Encoder((a) => base.encode(a as Brand.Unbranded<A>));
+}
+
+/**
+ * @tsplus derive fncts.Encoder lazy
+ */
+export function deriveLazy<A>(fn: (_: Encoder<A>) => Encoder<A>): Encoder<A> {
+  let cached: Encoder<A> | undefined;
+  const encoder: Encoder<A> = Encoder((a) => {
+    if (!cached) {
+      cached = fn(encoder);
+    }
+    return cached.encode(a);
+  });
+  return encoder;
+}
+
+/**
+ * @tsplus derive fncts.Encoder<_> 20
+ */
+export function deriveStruct<A extends Record<string, any>>(
+  ...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True
+    ? [
+        ...[
+          requiredFields: {
+            [K in RequiredKeys<A>]: Encoder<A[K]>;
+          },
+        ],
+        ...([OptionalKeys<A>] extends [never]
+          ? []
+          : [
+              optionalFields: {
+                [K in OptionalKeys<A>]: Encoder<NonNullable<A[K]>>;
+              },
+            ]),
+      ]
+    : never
+): Encoder<A> {
+  return Encoder((inp) => {
+    const encoded = {};
+    for (const field of Object.keys(requiredFields)) {
+      encoded[field] = (requiredFields[field] as Encoder<unknown>).encode(inp[field]);
+    }
+    if (optionalFields) {
+      for (const field of Object.keys(optionalFields)) {
+        if (field in inp && typeof inp[field] !== undefined) {
+          encoded[field] = (optionalFields[field] as Encoder<unknown>).encode(inp[field]);
+        }
+      }
+    }
+    return encoded;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Encoder<|> 30
+ */
+export function deriveUnion<A extends Array<unknown>>(
+  ...elements: {
+    [K in keyof A]: [Guard<A[K]>, Encoder<A[K]>];
+  }
+): Encoder<A[number]> {
+  return Encoder((inp) => {
+    for (const [guard, encoder] of elements) {
+      if (guard.is(inp)) {
+        return encoder.encode(inp);
+      }
+    }
+  });
+}
+
+/**
+ * @tsplus derive fncts.Encoder<_> 10
+ */
+export function deriveEmptyRecord<A extends {}>(
+  ..._: Check<Check.IsEqual<A, {}>> extends Check.True ? [] : never
+): Encoder<A> {
+  return Encoder(Function.identity);
+}

package/_src/data/Encoder/definition.ts

@@ -0,0 +1,12 @@
+export const EncoderTypeId = Symbol.for("fncts.Encoder");
+export type EncoderTypeId = typeof EncoderTypeId;
+
+/**
+ * @tsplus type fncts.Encoder
+ * @tsplus companion fncts.EncoderOps
+ * @tsplus derive nominal
+ */
+export class Encoder<in out A> {
+  readonly _typeId: EncoderTypeId = EncoderTypeId;
+  constructor(readonly encode: (inp: A) => unknown) {}
+}

package/_src/data/Encoder.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Encoder/*.ts }
+export * from "./Encoder/api.js";
+export * from "./Encoder/definition.js";
+// codegen:end

package/_src/data/Environment/api.ts

@@ -1,8 +1,10 @@
 /**
- * @tsplus fluent fncts.Environment add
+ * @tsplus pipeable fncts.Environment add
  */
-export function add<R, H extends S, S = H>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R | S> {
-  return new Environment(self.map.set(tag, service));
+export function add<H extends S, S = H>(service: H, tag: Tag<S>) {
+  return <R>(self: Environment<R>): Environment<R | S> => {
+    return new Environment(self.map.set(tag, service));
+  };
 }
 
 /**
@@ -13,17 +15,21 @@ export const empty = Environment();
 type Tags<R> = R extends infer S ? Tag<S> : never;
 
 /**
- * @tsplus fluent fncts.Environment get
+ * @tsplus pipeable fncts.Environment get
  */
-export function get<R, T extends Tags<R>>(self: Environment<R>, tag: T): T extends Tag<infer S> ? S : never {
-  return unsafeCoerce(self.unsafeGet(tag));
+export function get<R, T extends Tags<R>>(tag: T) {
+  return (self: Environment<R>): T extends Tag<infer S> ? S : never => {
+    return unsafeCoerce(self.unsafeGet(tag));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Environment getMaybe
+ * @tsplus pipeable fncts.Environment getMaybe
  */
-export function getMaybe<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>): Maybe<S> {
-  return self.cache.get(tag) as Maybe<S>;
+export function getMaybe<S>(tag: Tag<S>) {
+  return <R extends Has<S>>(self: Environment<R>): Maybe<S> => {
+    return self.cache.get(tag) as Maybe<S>;
+  };
 }
 
 /**
@@ -34,56 +40,58 @@ export function make(): Environment<never> {
 }
 
 /**
- * @tsplus operator fncts.Environment +
- * @tsplus fluent fncts.Environment union
+ * @tsplus pipeable-operator fncts.Environment +
+ * @tsplus pipeable fncts.Environment union
  */
-export function union<R, R1>(self: Environment<R>, that: Environment<R1>): Environment<R & R1> {
-  return new Environment(
-    self.map.union(that.map),
-  );
+export function union<R1>(that: Environment<R1>) {
+  return <R>(self: Environment<R>): Environment<R & R1> => {
+    return new Environment(self.map.union(that.map));
+  };
 }
 
 /**
  * @tsplus getter fncts.Environment clean
  */
 export function clean<R>(self: Environment<R>): Environment<R> {
-  const [map, index] = self.map.toList
-    .foldLeft(
-      [HashMap.makeDefault<Tag<unknown>, readonly [unknown, number]>(), 0],
-      ([map, index], [tag, service]) => [map.set(tag, [service, index] as const), index + 1],
-    );
-
+  const [map, index] = self.map.toList.foldLeft(
+    [HashMap.makeDefault<Tag<unknown>, readonly [unknown, number]>(), 0],
+    ([map, index], [tag, service]) => [map.set(tag, [service, index] as const), index + 1],
+  );
   return new Environment(map);
 }
 
 /**
- * @tsplus fluent fncts.Environment unsafeGet
+ * @tsplus pipeable fncts.Environment unsafeGet
  */
-export function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S {
-  return self.cache.get(tag).match(
-    () => {
-      const iterator = self.map[Symbol.iterator]();
-      let service: S = null!;
-      let r: IteratorResult<readonly [Tag<unknown>, unknown]>;
-      while (!(r = iterator.next()).done) {
-        const [curTag, curService] = r.value;
-        if (curTag == tag) {
-          service = curService as S;
+export function unsafeGet<S>(tag: Tag<S>) {
+  return <R>(self: Environment<R>): S => {
+    return self.cache.get(tag).match(
+      () => {
+        const iterator = self.map[Symbol.iterator]();
+        let service: S = null!;
+        let r: IteratorResult<readonly [Tag<unknown>, unknown]>;
+        while (!(r = iterator.next()).done) {
+          const [curTag, curService] = r.value;
+          if (curTag == tag) {
+            service = curService as S;
+          }
         }
-      }
-      if (service === null) throw new Error("Defect in Environment: Could not find tag in map");
-      else {
-        self.cache = self.cache.set(tag, service);
-        return service;
-      }
-    },
-    (a) => a as S,
-  );
+        if (service === null) throw new Error("Defect in Environment: Could not find tag in map");
+        else {
+          self.cache = self.cache.set(tag, service);
+          return service;
+        }
+      },
+      (a) => a as S,
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.Environment update
+ * @tsplus pipeable fncts.Environment update
  */
-export function update<R, S extends R>(self: Environment<R>, f: (s: S) => S, tag: Tag<S>): Environment<R> {
-  return self.add(f(self.unsafeGet(tag)), tag);
+export function update<R, S extends R>(f: (s: S) => S, tag: Tag<S>) {
+  return (self: Environment<R>): Environment<R> => {
+    return self.add(f(self.unsafeGet(tag)), tag);
+  };
 }

package/_src/data/Environment/definition.ts

@@ -1,3 +1,5 @@
+import type { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
+
 /**
  * @tsplus static fncts.prelude.builtin.SymbolOps env
  */
@@ -26,6 +28,10 @@ export class Environment<R> implements Hashable, Equatable {
   }
 }
 
+export declare namespace Environment {
+  type Patch<In, Out> = EnvironmentPatch<In, Out>;
+}
+
 export function isEnvironment(u: unknown): u is Environment<unknown> {
   return hasTypeId(u, EnvSymbol);
 }

package/_src/data/EnvironmentPatch.ts

@@ -0,0 +1,137 @@
+export const enum EnvironmentPatchTag {
+  AddService,
+  RemoveService,
+  UpdateService,
+  Combine,
+  Empty,
+}
+
+export const EnvironmentPatchTypeId = Symbol.for("fncts.Environment.Patch");
+export type EnvironmentPatchTypeId = typeof EnvironmentPatchTypeId;
+
+/**
+ * @tsplus type fncts.Environment.Patch
+ * @tsplus companion fncts.Environment.PatchOps
+ */
+export abstract class EnvironmentPatch<In, Out> {
+  readonly _typeId: EnvironmentPatchTypeId = EnvironmentPatchTypeId;
+  readonly _R!: (_: In) => void;
+  readonly _A!: () => Out;
+}
+
+export class AddService<Env, Service> extends EnvironmentPatch<Env, Env & Has<Service>> {
+  readonly _tag = EnvironmentPatchTag.AddService;
+  constructor(readonly service: Service, readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export class Combine<In, Out, Out2> extends EnvironmentPatch<In, Out2> {
+  readonly _tag = EnvironmentPatchTag.Combine;
+  constructor(readonly first: EnvironmentPatch<In, Out>, readonly second: EnvironmentPatch<Out, Out2>) {
+    super();
+  }
+}
+
+export class Empty<Env> extends EnvironmentPatch<Env, Env> {
+  readonly _tag = EnvironmentPatchTag.Empty;
+}
+
+export class RemoveService<Env, Service> extends EnvironmentPatch<Env & Has<Service>, Env> {
+  readonly _tag = EnvironmentPatchTag.RemoveService;
+  constructor(readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export class UpdateService<Env, Service> extends EnvironmentPatch<Env & Has<Service>, Env & Has<Service>> {
+  readonly _tag = EnvironmentPatchTag.UpdateService;
+  constructor(readonly update: (_: Service) => Service, readonly tag: Tag<Service>) {
+    super();
+  }
+}
+
+export type Concrete =
+  | AddService<any, any>
+  | Combine<any, any, any>
+  | Empty<any>
+  | RemoveService<any, any>
+  | UpdateService<any, any>;
+
+/**
+ * @tsplus macro remove
+ */
+export function concrete(_: EnvironmentPatch<any, any>): asserts _ is Concrete {
+  //
+}
+
+/**
+ * @tsplus tailRec
+ */
+function applyLoop(environment: Environment<any>, patches: List<EnvironmentPatch<any, any>>): Environment<any> {
+  if (patches.isEmpty()) {
+    return environment;
+  }
+  const head = patches.head;
+  const tail = patches.tail;
+  concrete(head);
+  switch (head._tag) {
+    case EnvironmentPatchTag.AddService:
+      return applyLoop(environment.add(head.service, head.tag), tail);
+    case EnvironmentPatchTag.Combine:
+      return applyLoop(environment, Cons(head.first, Cons(head.second, tail)));
+    case EnvironmentPatchTag.Empty:
+      return applyLoop(environment, tail);
+    case EnvironmentPatchTag.RemoveService:
+      return applyLoop(environment, tail);
+    case EnvironmentPatchTag.UpdateService:
+      return applyLoop(environment.update(head.update, head.tag), tail);
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.Environment.Patch __call
+ */
+export function apply<In>(environment: Environment<In>) {
+  return <Out>(patch: EnvironmentPatch<In, Out>): Environment<Out> => {
+    return applyLoop(environment, Cons(patch));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Environment.Patch combine
+ */
+export function combine<Out, Out2>(that: EnvironmentPatch<Out, Out2>) {
+  return <In>(self: EnvironmentPatch<In, Out>): EnvironmentPatch<In, Out2> => {
+    return new Combine(self, that);
+  };
+}
+
+/**
+ * @tsplus static fncts.Environment.PatchOps diff
+ */
+export function diff<In, Out>(oldValue: Environment<In>, newValue: Environment<Out>): EnvironmentPatch<In, Out> {
+  const sorted                   = newValue.map.toArray;
+  const [missingServices, patch] = sorted.foldLeft(
+    [oldValue.map.beginMutation, EnvironmentPatch.empty() as EnvironmentPatch<any, any>],
+    ([map, patch], [tag, newService]) =>
+      map.get(tag).match(
+        () => [map.remove(tag), patch.combine(new AddService(newService, tag))],
+        (oldService) => {
+          if (oldService === newService) {
+            return [map.remove(tag), patch];
+          } else {
+            return [map.remove(tag), patch.combine(new UpdateService((_: any) => newService, tag))];
+          }
+        },
+      ),
+  );
+  return missingServices.foldLeftWithIndex(patch, (tag, patch) => patch.combine(new RemoveService(tag)));
+}
+
+/**
+ * @tsplus static fncts.Environment.PatchOps empty
+ */
+export function empty<A>(): EnvironmentPatch<A, A> {
+  return new Empty();
+}

package/_src/data/ExecutionStrategy.ts

@@ -48,34 +48,24 @@ export interface ExecutionStrategyOps {}
 export const ExecutionStrategy: ExecutionStrategyOps = {};
 
 /**
- * @tsplus fluent fncts.ExecutionStrategy match
+ * @tsplus pipeable fncts.ExecutionStrategy match
  */
 export function match_<A, B, C>(
-  strategy: ExecutionStrategy,
   sequential: () => A,
   concurrent: () => B,
   concurrentBounded: (fiberBound: number) => C,
-): A | B | C {
-  switch (strategy._tag) {
-    case "Sequential": {
-      return sequential();
-    }
-    case "Concurrent": {
-      return concurrent();
-    }
-    case "ConcurrentBounded": {
-      return concurrentBounded(strategy.fiberBound);
+) {
+  return (strategy: ExecutionStrategy): A | B | C => {
+    switch (strategy._tag) {
+      case "Sequential": {
+        return sequential();
+      }
+      case "Concurrent": {
+        return concurrent();
+      }
+      case "ConcurrentBounded": {
+        return concurrentBounded(strategy.fiberBound);
+      }
     }
-  }
-}
-
-/**
- * @tsplus pipeable fncts.ExecutionStrategy match
- */
-export function match<A, B, C>(
-  sequential: () => A,
-  concurrent: () => B,
-  concurrentBounded: (fiberBound: number) => C,
-): (strategy: ExecutionStrategy) => A | B | C {
-  return (strategy) => match_(strategy, sequential, concurrent, concurrentBounded);
+  };
 }