@fncts/base 0.0.20 → 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/EnvironmentPatch.ts

@@ -90,20 +90,21 @@ function applyLoop(environment: Environment<any>, patches: List<EnvironmentPatch
 }
 
 /**
- * @tsplus fluent fncts.Environment.Patch __call
+ * @tsplus pipeable fncts.Environment.Patch __call
  */
-export function apply<In, Out>(patch: EnvironmentPatch<In, Out>, environment: Environment<In>): Environment<Out> {
-  return applyLoop(environment, Cons(patch));
+export function apply<In>(environment: Environment<In>) {
+  return <Out>(patch: EnvironmentPatch<In, Out>): Environment<Out> => {
+    return applyLoop(environment, Cons(patch));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Environment.Patch combine
+ * @tsplus pipeable fncts.Environment.Patch combine
  */
-export function combine<In, Out, Out2>(
-  self: EnvironmentPatch<In, Out>,
-  that: EnvironmentPatch<Out, Out2>,
-): EnvironmentPatch<In, Out2> {
-  return new Combine(self, that);
+export function combine<Out, Out2>(that: EnvironmentPatch<Out, Out2>) {
+  return <In>(self: EnvironmentPatch<In, Out>): EnvironmentPatch<In, Out2> => {
+    return new Combine(self, that);
+  };
 }
 
 /**

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);
+  };
 }