@fncts/base 0.0.1 → 0.0.4

package/_src/typeclass/Chain.ts

@@ -1,226 +1,154 @@
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
+import type { Functor } from "@fncts/base/typeclass/Functor";
 
 import { identity } from "@fncts/base/data/function";
-import { Functor } from "@fncts/base/typeclass/Functor";
 
-export interface FlatMap<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-  readonly flatMap_: flatMap_<F, FC>;
-  readonly flatMap: flatMap<F, FC>;
-  readonly flatten: flatten<F, FC>;
-  readonly tap_: tap_<F, FC>;
-  readonly tap: tap<F, FC>;
-}
-
-/**
- * @tsplus type fncts.FlatMapOps
- */
-export interface FlatMapOps {}
-
-export const FlatMap: FlatMapOps = {};
-
-export type ChainMin<F extends HKT, FC = HKT.None> = {
-  readonly flatMap_: flatMap_<F, FC>;
-} & FunctorMin<F, FC>;
-
-/**
- * @tsplus static fncts.FlatMapOps __call
- */
-export function mkFlatMap<F extends HKT, FC = HKT.None>(F: ChainMin<F, FC>): FlatMap<F, FC>;
-export function mkFlatMap<F>(F: ChainMin<HKT.F<F>>): FlatMap<HKT.F<F>> {
-  const tap_: tap_<HKT.F<F>>       = (ma, f) => F.flatMap_(ma, (a) => F.map_(f(a), () => a));
-  const flatten: flatten<HKT.F<F>> = (mma) => F.flatMap_(mma, identity);
-  return HKT.instance<FlatMap<HKT.F<F>>>({
-    ...Functor(F),
-    flatMap_: F.flatMap_,
-    flatMap: (f) => (ma) => F.flatMap_(ma, f),
-    flatten,
-    tap_,
-    tap: (f) => (ma) => tap_(ma, f),
-  });
-}
-
-export interface flatMap_<F extends HKT, FC = HKT.None> {
-  <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-    ma: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+export interface FlatMap<F extends HKT> extends Functor<F> {
+  flatMap<K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+    ma: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
     f: (
       a: A,
     ) => HKT.Kind<
       F,
-      FC,
-      HKT.Intro<F, "K", K1, K2>,
-      HKT.Intro<F, "Q", Q1, Q2>,
-      HKT.Intro<F, "W", W1, W2>,
-      HKT.Intro<F, "X", X1, X2>,
-      HKT.Intro<F, "I", I1, I2>,
-      HKT.Intro<F, "S", S1, S2>,
-      HKT.Intro<F, "R", R1, R2>,
-      HKT.Intro<F, "E", E1, E2>,
+      HKT.Intro<"K", K1, K2>,
+      HKT.Intro<"Q", Q1, Q2>,
+      HKT.Intro<"W", W1, W2>,
+      HKT.Intro<"X", X1, X2>,
+      HKT.Intro<"I", I1, I2>,
+      HKT.Intro<"S", S1, S2>,
+      HKT.Intro<"R", R1, R2>,
+      HKT.Intro<"E", E1, E2>,
       B
     >,
   ): HKT.Kind<
     F,
-    FC,
-    HKT.Mix<F, "K", [K1, K2]>,
-    HKT.Mix<F, "Q", [Q1, Q2]>,
-    HKT.Mix<F, "W", [W1, W2]>,
-    HKT.Mix<F, "X", [X1, X2]>,
-    HKT.Mix<F, "I", [I1, I2]>,
-    HKT.Mix<F, "S", [S1, S2]>,
-    HKT.Mix<F, "R", [R1, R2]>,
-    HKT.Mix<F, "E", [E1, E2]>,
+    HKT.Mix<"K", [K1, K2]>,
+    HKT.Mix<"Q", [Q1, Q2]>,
+    HKT.Mix<"W", [W1, W2]>,
+    HKT.Mix<"X", [X1, X2]>,
+    HKT.Mix<"I", [I1, I2]>,
+    HKT.Mix<"S", [S1, S2]>,
+    HKT.Mix<"R", [R1, R2]>,
+    HKT.Mix<"E", [E1, E2]>,
     B
   >;
 }
 
-export interface flatMap<F extends HKT, TC = HKT.None> {
-  <K2, Q2, W2, X2, I2, S2, R2, E2, B, A>(f: (a: A) => HKT.Kind<F, TC, K2, Q2, W2, X2, I2, S2, R2, E2, B>): <
-    K1,
-    Q1,
-    W1,
-    X1,
-    I1,
-    S1,
-    R1,
-    E1,
-  >(
-    ma: HKT.Kind<
-      F,
-      TC,
-      HKT.Intro<F, "K", K2, K1>,
-      HKT.Intro<F, "Q", Q2, Q1>,
-      HKT.Intro<F, "W", W2, W1>,
-      HKT.Intro<F, "X", X2, X1>,
-      HKT.Intro<F, "I", I2, I1>,
-      HKT.Intro<F, "S", S2, S1>,
-      HKT.Intro<F, "R", R2, R1>,
-      HKT.Intro<F, "E", E2, E1>,
-      A
-    >,
+/**
+ * @tsplus type fncts.FlatMapOps
+ */
+export interface FlatMapOps {}
+
+export const FlatMap: FlatMapOps = {};
+
+/**
+ * @tsplus fluent fncts.Kind flatMap
+ */
+export function flatMap<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+  ma: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+  f: (
+    a: A,
   ) => HKT.Kind<
     F,
-    TC,
-    HKT.Mix<F, "K", [K2, K1]>,
-    HKT.Mix<F, "Q", [Q2, Q1]>,
-    HKT.Mix<F, "W", [W2, W1]>,
-    HKT.Mix<F, "X", [X2, X1]>,
-    HKT.Mix<F, "I", [I2, I1]>,
-    HKT.Mix<F, "S", [S2, S1]>,
-    HKT.Mix<F, "R", [R2, R1]>,
-    HKT.Mix<F, "E", [E2, E1]>,
+    HKT.Intro<"K", K1, K2>,
+    HKT.Intro<"Q", Q1, Q2>,
+    HKT.Intro<"W", W1, W2>,
+    HKT.Intro<"X", X1, X2>,
+    HKT.Intro<"I", I1, I2>,
+    HKT.Intro<"S", S1, S2>,
+    HKT.Intro<"R", R1, R2>,
+    HKT.Intro<"E", E1, E2>,
     B
-  >;
+  >,
+  /** @tsplus auto */ F: FlatMap<F>,
+): HKT.Kind<
+  F,
+  HKT.Mix<"K", [K1, K2]>,
+  HKT.Mix<"Q", [Q1, Q2]>,
+  HKT.Mix<"W", [W1, W2]>,
+  HKT.Mix<"X", [X1, X2]>,
+  HKT.Mix<"I", [I1, I2]>,
+  HKT.Mix<"S", [S1, S2]>,
+  HKT.Mix<"R", [R1, R2]>,
+  HKT.Mix<"E", [E1, E2]>,
+  B
+> {
+  return F.flatMap(ma, f);
 }
 
-export interface flatten<F extends HKT, FC = HKT.None> {
-  <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2>(
-    mma: HKT.Kind<
-      F,
-      FC,
-      K2,
-      Q2,
-      W2,
-      X2,
-      I2,
-      S2,
-      R2,
-      E2,
-      HKT.Kind<
-        F,
-        FC,
-        HKT.Intro<F, "K", K2, K1>,
-        HKT.Intro<F, "Q", Q2, Q1>,
-        HKT.Intro<F, "W", W2, W1>,
-        HKT.Intro<F, "X", X2, X1>,
-        HKT.Intro<F, "I", I2, I1>,
-        HKT.Intro<F, "S", S2, S1>,
-        HKT.Intro<F, "R", R2, R1>,
-        HKT.Intro<F, "E", E2, E1>,
-        A
-      >
-    >,
-  ): HKT.Kind<
+/**
+ * @tsplus fluent fncts.Kind flatten
+ */
+export function flatten<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2>(
+  mma: HKT.Kind<
     F,
-    FC,
-    HKT.Mix<F, "K", [K2, K1]>,
-    HKT.Mix<F, "Q", [Q2, Q1]>,
-    HKT.Mix<F, "W", [W2, W1]>,
-    HKT.Mix<F, "X", [X2, X1]>,
-    HKT.Mix<F, "I", [I2, I1]>,
-    HKT.Mix<F, "S", [S2, S1]>,
-    HKT.Mix<F, "R", [R2, R1]>,
-    HKT.Mix<F, "E", [E2, E1]>,
-    A
-  >;
-}
-
-export interface tap_<F extends HKT, FC = HKT.None> {
-  <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-    ma: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
-    f: (
-      a: A,
-    ) => HKT.Kind<
+    K2,
+    Q2,
+    W2,
+    X2,
+    I2,
+    S2,
+    R2,
+    E2,
+    HKT.Kind<
       F,
-      FC,
-      HKT.Intro<F, "K", K1, K2>,
-      HKT.Intro<F, "Q", Q1, Q2>,
-      HKT.Intro<F, "W", W1, W2>,
-      HKT.Intro<F, "X", X1, X2>,
-      HKT.Intro<F, "I", I1, I2>,
-      HKT.Intro<F, "S", S1, S2>,
-      HKT.Intro<F, "R", R1, R2>,
-      HKT.Intro<F, "E", E1, E2>,
-      B
-    >,
-  ): HKT.Kind<
-    F,
-    FC,
-    HKT.Mix<F, "K", [K1, K2]>,
-    HKT.Mix<F, "Q", [Q1, Q2]>,
-    HKT.Mix<F, "W", [W1, W2]>,
-    HKT.Mix<F, "X", [X1, X2]>,
-    HKT.Mix<F, "I", [I1, I2]>,
-    HKT.Mix<F, "S", [S1, S2]>,
-    HKT.Mix<F, "R", [R1, R2]>,
-    HKT.Mix<F, "E", [E1, E2]>,
-    A
-  >;
+      HKT.Intro<"K", K2, K1>,
+      HKT.Intro<"Q", Q2, Q1>,
+      HKT.Intro<"W", W2, W1>,
+      HKT.Intro<"X", X2, X1>,
+      HKT.Intro<"I", I2, I1>,
+      HKT.Intro<"S", S2, S1>,
+      HKT.Intro<"R", R2, R1>,
+      HKT.Intro<"E", E2, E1>,
+      A
+    >
+  >,
+  /** @tsplus auto */ F: FlatMap<F>,
+): HKT.Kind<
+  F,
+  HKT.Mix<"K", [K2, K1]>,
+  HKT.Mix<"Q", [Q2, Q1]>,
+  HKT.Mix<"W", [W2, W1]>,
+  HKT.Mix<"X", [X2, X1]>,
+  HKT.Mix<"I", [I2, I1]>,
+  HKT.Mix<"S", [S2, S1]>,
+  HKT.Mix<"R", [R2, R1]>,
+  HKT.Mix<"E", [E2, E1]>,
+  A
+> {
+  return mma.flatMap(identity);
 }
 
-export interface tap<F extends HKT, TC = HKT.None> {
-  <K2, Q2, W2, X2, I2, S2, R2, E2, B, A>(f: (a: A) => HKT.Kind<F, TC, K2, Q2, W2, X2, I2, S2, R2, E2, B>): <
-    K1,
-    Q1,
-    W1,
-    X1,
-    I1,
-    S1,
-    R1,
-    E1,
-  >(
-    ma: HKT.Kind<
-      F,
-      TC,
-      HKT.Intro<F, "K", K2, K1>,
-      HKT.Intro<F, "Q", Q2, Q1>,
-      HKT.Intro<F, "W", W2, W1>,
-      HKT.Intro<F, "X", X2, X1>,
-      HKT.Intro<F, "I", I2, I1>,
-      HKT.Intro<F, "S", S2, S1>,
-      HKT.Intro<F, "R", R2, R1>,
-      HKT.Intro<F, "E", E2, E1>,
-      A
-    >,
+/**
+ * @tsplus fluent fncts.Kind tap
+ */
+export function tap<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+  ma: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+  f: (
+    a: A,
   ) => HKT.Kind<
     F,
-    TC,
-    HKT.Mix<F, "K", [K2, K1]>,
-    HKT.Mix<F, "Q", [Q2, Q1]>,
-    HKT.Mix<F, "W", [W2, W1]>,
-    HKT.Mix<F, "X", [X2, X1]>,
-    HKT.Mix<F, "I", [I2, I1]>,
-    HKT.Mix<F, "S", [S2, S1]>,
-    HKT.Mix<F, "R", [R2, R1]>,
-    HKT.Mix<F, "E", [E2, E1]>,
-    A
-  >;
+    HKT.Intro<"K", K1, K2>,
+    HKT.Intro<"Q", Q1, Q2>,
+    HKT.Intro<"W", W1, W2>,
+    HKT.Intro<"X", X1, X2>,
+    HKT.Intro<"I", I1, I2>,
+    HKT.Intro<"S", S1, S2>,
+    HKT.Intro<"R", R1, R2>,
+    HKT.Intro<"E", E1, E2>,
+    B
+  >,
+  /** @tsplus auto */ F: FlatMap<F>,
+): HKT.Kind<
+  F,
+  HKT.Mix<"K", [K1, K2]>,
+  HKT.Mix<"Q", [Q1, Q2]>,
+  HKT.Mix<"W", [W1, W2]>,
+  HKT.Mix<"X", [X1, X2]>,
+  HKT.Mix<"I", [I1, I2]>,
+  HKT.Mix<"S", [S1, S2]>,
+  HKT.Mix<"R", [R1, R2]>,
+  HKT.Mix<"E", [E1, E2]>,
+  A
+> {
+  return ma.flatMap((a) => f(a).as(a, F));
 }

package/_src/typeclass/Closure.ts

@@ -2,8 +2,7 @@
  * @tsplus type fncts.Closure
  */
 export interface Closure<A> {
-  readonly combine_: (x: A, y: A) => A;
-  readonly combine: (y: A) => (x: A) => A;
+  readonly combine: (x: A, y: A) => A;
 }
 
 /**
@@ -13,24 +12,9 @@ export interface ClosureOps {}
 
 export const Closure: ClosureOps = {};
 
-export type ClosureMin<A> = {
-  combine_: combine_<A>;
-};
-
 /**
  * @tsplus static fncts.ClosureOps __call
  */
-export function mkClosure<A>(F: ClosureMin<A>): Closure<A> {
-  return {
-    combine_: F.combine_,
-    combine: (y) => (x) => F.combine_(x, y),
-  };
-}
-
-export interface combine_<A> {
-  (x: A, y: A): A;
-}
-
-export interface combine<A> {
-  (y: A): (x: A) => A;
-}
+export function mkClosure<A>(F: Closure<A>): Closure<A> {
+  return F;
+}

package/_src/typeclass/Eq/definition.ts

@@ -0,0 +1,20 @@
+/**
+ * @tsplus type fncts.Eq
+ */
+export interface Eq<A> {
+  readonly equals: (x: A, y: A) => boolean
+}
+
+/**
+ * @tsplus type fncts.EqOps
+ */
+export interface EqOps {}
+
+export const Eq: EqOps = {};
+
+/**
+ * @tsplus static fncts.EqOps __call
+ */
+export function mkEq<A>(E: Eq<A>): Eq<A> {
+  return E;
+}

package/_src/typeclass/Eq/derivations.ts

@@ -0,0 +1,61 @@
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+
+import { Eq } from "@fncts/base/typeclass/Eq/definition";
+
+/**
+ * @tsplus derive fncts.Eq lazy
+ */
+export function deriveLazy<A>(fn: (_: Eq<A>) => Eq<A>): Eq<A> {
+  let cached: Eq<A> | undefined;
+  const eq: Eq<A> = Eq({
+    equals: (x, y) => {
+      if (!cached) {
+        cached = fn(eq);
+      }
+      return cached.equals(x, y);
+    },
+  });
+  return eq;
+}
+
+/**
+ * @tsplus derive fncts.Eq<_> 20
+ */
+export function deriveStruct<A extends Record<string, any>>(
+  ...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True
+    ? [
+        ...[
+          requiredFields: {
+            [K in RequiredKeys<A>]: Eq<A[K]>;
+          },
+        ],
+        ...([OptionalKeys<A>] extends [never]
+          ? []
+          : [
+              optionalFields: {
+                [K in OptionalKeys<A>]: Eq<NonNullable<A[K]>>;
+              },
+            ]),
+      ]
+    : never
+): Eq<A> {
+  return Eq({
+    equals: (x, y) => {
+      for (const field in requiredFields) {
+        if (!(requiredFields[field] as Eq<any>).equals(x[field], y[field])) {
+          return false;
+        }
+      }
+      for (const field in optionalFields) {
+        if ((field in x && !(field in y)) || (field in y && !(field in x))) {
+          return false;
+        }
+        if (!(optionalFields[field] as Eq<any>).equals(x[field], y[field])) {
+          return false;
+        }
+      }
+      return true;
+    },
+  });
+}

package/_src/typeclass/Eq.ts

@@ -1,36 +1,2 @@
-/**
- * @tsplus type fncts.Eq
- */
-export interface Eq<A> {
-  readonly equals_: equals_<A>;
-  readonly equals: equals<A>;
-}
-
-/**
- * @tsplus type fncts.EqOps
- */
-export interface EqOps {}
-
-export const Eq: EqOps = {};
-
-export type EqMin<A> = {
-  readonly equals_: equals_<A>;
-};
-
-/**
- * @tsplus static fncts.EqOps __call
- */
-export function mkEq<A>(F: EqMin<A>): Eq<A> {
-  return {
-    equals_: F.equals_,
-    equals: (y) => (x) => F.equals_(x, y),
-  };
-}
-
-export interface equals_<A> {
-  (x: A, y: A): boolean;
-}
-
-export interface equals<A> {
-  (y: A): (x: A) => boolean;
-}
+export * from "./Eq/definition.js";
+export {} from "./Eq/derivations.js";

package/_src/typeclass/Fail.ts

@@ -1,8 +1,20 @@
 /**
  * @tsplus type fncts.Fail
  */
-export interface Fail<F extends HKT, TC = HKT.None> extends HKT.Typeclass<F, TC> {
-  readonly fail: fail<F, TC>;
+export interface Fail<F extends HKT> extends HKT.Typeclass<F> {
+  fail<
+    E,
+    K = HKT.Low<"K">,
+    Q = HKT.Low<"Q">,
+    W = HKT.Low<"W">,
+    X = HKT.Low<"X">,
+    I = HKT.Low<"I">,
+    S = HKT.Low<"S">,
+    R = HKT.Low<"R">,
+    A = never,
+  >(
+    e: E,
+  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;
 }
 
 /**
@@ -10,31 +22,20 @@ export interface Fail<F extends HKT, TC = HKT.None> extends HKT.Typeclass<F, TC>
  */
 export interface FailOps {}
 
-export type FailMin<F extends HKT, C = HKT.None> = {
-  readonly fail: fail<F, C>;
-};
-
 /**
- * @tsplus static fncts.FailOps __call
+ * @tsplus static fncts.FailOps fail
  */
-export function mkFail<F extends HKT, C = HKT.None>(F: FailMin<F, C>): Fail<F, C> {
-  return HKT.instance({
-    fail: F.fail,
-  });
-}
-
-export interface fail<F extends HKT, C = HKT.None> {
-  <
-    E,
-    K = HKT.Low<F, "K">,
-    Q = HKT.Low<F, "Q">,
-    W = HKT.Low<F, "W">,
-    X = HKT.Low<F, "X">,
-    I = HKT.Low<F, "I">,
-    S = HKT.Low<F, "S">,
-    R = HKT.Low<F, "R">,
-    A = never,
-  >(
-    e: HKT.OrFix<C, "E", E>,
-  ): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>;
+export function fail<
+  F extends HKT,
+  E,
+  K = HKT.Low<"K">,
+  Q = HKT.Low<"Q">,
+  W = HKT.Low<"W">,
+  X = HKT.Low<"X">,
+  I = HKT.Low<"I">,
+  S = HKT.Low<"S">,
+  R = HKT.Low<"R">,
+  A = never,
+>(e: E, /** @tsplus auto */ F: Fail<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, A> {
+  return F.fail(e);
 }