@fncts/base 0.0.3 → 0.0.6

package/_src/typeclass/Semigroup/api.ts

@@ -7,7 +7,7 @@ import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
  */
 export function min<A>(O: Ord<A>): Semigroup<A> {
   return Semigroup({
-    combine_: O.min,
+    combine: O.min,
   });
 }
 
@@ -16,6 +16,6 @@ export function min<A>(O: Ord<A>): Semigroup<A> {
  */
 export function max<A>(O: Ord<A>): Semigroup<A> {
   return Semigroup({
-    combine_: O.max,
+    combine: O.max,
   });
 }

package/_src/typeclass/Semigroup/definition.ts

@@ -1,4 +1,4 @@
-import type { Closure, combine_ } from "@fncts/base/typeclass/Closure";
+import type { Closure } from "@fncts/base/typeclass/Closure";
 
 import { mkClosure } from "@fncts/base/typeclass/Closure";
 
@@ -14,11 +14,7 @@ export interface SemigroupOps {}
 
 export const Semigroup: SemigroupOps = {};
 
-export type SemigroupMin<A> = {
-  combine_: combine_<A>;
-};
-
 /**
  * @tsplus static fncts.SemigroupOps __call
  */
-export const mkSemigroup: <A>(F: SemigroupMin<A>) => Semigroup<A> = mkClosure;
+export const mkSemigroup = mkClosure;

package/_src/typeclass/Semigroup/derivations.ts

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

package/_src/typeclass/Semigroup.ts

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

package/_src/typeclass/Semimonoidal.ts

@@ -1,12 +1,32 @@
-export interface Semimonoidal<F extends HKT, C = HKT.None> extends HKT.Typeclass<F, C> {
-  readonly zip_: zip_<F, C>;
-  readonly zip: zip<F, C>;
+export interface Semimonoidal<F extends HKT> extends HKT.Typeclass<F> {
+  zip<K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+    fa: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+    fb: HKT.Kind<
+      F,
+      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,
+    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]>,
+    readonly [A, B]
+  >;
 }
 
-export type SemimonoidalMin<F extends HKT, C = HKT.None> = {
-  readonly zip_: zip_<F, C>;
-};
-
 /**
  * @tsplus type fncts.SemimonoidalOps
  */
@@ -15,83 +35,34 @@ export interface SemimonoidalOps {}
 export const Semimonoidal: SemimonoidalOps = {};
 
 /**
- * @tsplus static fncts.SemimonoidalOps __call
+ * @tsplus fluent fncts.Kind zip
  */
-export function mkSemimonoidal<F extends HKT, C = HKT.None>(F: SemimonoidalMin<F, C>): Semimonoidal<F, C>;
-export function mkSemimonoidal<F>(F: SemimonoidalMin<HKT.F<F>>): Semimonoidal<HKT.F<F>> {
-  return HKT.instance<Semimonoidal<HKT.F<F>>>({
-    zip_: F.zip_,
-    zip: (fb) => (fa) => F.zip_(fa, fb),
-  });
-}
-
-export interface zip_<F extends HKT, C = HKT.None> {
-  <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-    fa: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
-    fb: HKT.Kind<
-      F,
-      C,
-      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,
-    C,
-    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]>,
-    readonly [A, B]
-  >;
-}
-
-export interface zip<F extends HKT, C = HKT.None> {
-  <K1, Q1, W1, X1, I1, S1, R1, E1, B>(fb: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>): <
-    K2,
-    Q2,
-    W2,
-    X2,
-    I2,
-    S2,
-    R2,
-    E2,
-    A,
-  >(
-    fa: HKT.Kind<
-      F,
-      C,
-      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>,
-      A
-    >,
-  ) => HKT.Kind<
+export function zip<F extends HKT, C, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+  fa: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+  fb: HKT.Kind<
     F,
-    C,
-    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]>,
-    readonly [A, B]
-  >;
+    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: Semimonoidal<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]>,
+  readonly [A, B]
+> {
+  return F.zip(fa, fb);
 }

package/_src/typeclass/Showable/show.ts

@@ -400,9 +400,9 @@ function showRaw(value: object, typedArray?: string): ShowComputation {
               case "InspectionInfo": {
                 base = Z.succeedNow(info.base);
                 keys = Conc.from(info.keys)
-                  .traverse(Z.Applicative)((key) => showProperty(value, key, info.extrasType))
+                  .traverse((key) => showProperty(value, key, info.extrasType))
                   .crossWith(
-                    info.protoProps.traverse(Z.Applicative)((key) => showProperty(value, key, PROTO_TYPE)),
+                    info.protoProps.traverse((key) => showProperty(value, key, PROTO_TYPE)),
                     (k1, k2) => k1.concat(k2),
                   );
                 indices    = info.formatter(value);
@@ -537,14 +537,14 @@ function removeColors(str: string): string {
 
 function showSet(value: Set<unknown>): ShowComputationChunk {
   return Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel + 2 }))
-    .apSecond((value as Iterable<unknown>).traverseToConc(Z.Applicative)(_show))
+    .apSecond((value as Iterable<unknown>).traverseToConc(_show, Z.Applicative))
     .apFirst(Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel - 2 })));
 }
 
 function showMap(value: Map<unknown, unknown>): ShowComputationChunk {
   return Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel + 2 }))
     .apSecond(
-      (value as Iterable<[unknown, unknown]>).traverseToConc(Z.Applicative)(([k, v]) =>
+      (value as Iterable<[unknown, unknown]>).traverseToConc(([k, v]) =>
         _show(k).crossWith(_show(v), (k, v) => `${k} => ${v}`),
       ),
     )
@@ -577,9 +577,7 @@ function showTypedArray(value: TypedArray): ShowComputationChunk {
           .apSecond(
             Z.succeedNow(output).flatMap((output) =>
               Conc("BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset", "buffer")
-                .traverse(Z.Applicative)((key) =>
-                  _show(value[key as keyof TypedArray]).map((shown) => `[${key}]: ${shown}`),
-                )
+                .traverse((key) => _show(value[key as keyof TypedArray]).map((shown) => `[${key}]: ${shown}`))
                 .map((shownKeys) => output.concat(shownKeys)),
             ),
           )
@@ -697,7 +695,7 @@ function showChunk(value: Conc<unknown>): ShowComputationChunk {
     return tuple(remaining, chunk);
   }).flatMap(([remaining, chunk]) =>
     chunk
-      .traverse(Z.Applicative)(_show)
+      .traverse(_show, Z.Applicative)
       .map((chunk) => (remaining > 0 ? chunk.append(`... ${remaining} more item${pluralize(remaining)}`) : chunk)),
   );
 }

package/_src/typeclass/Traversable.ts

@@ -1,18 +1,18 @@
-import type { Applicative, CompatibleApplicative } from "@fncts/base/typeclass/Applicative";
-import type { FoldableMin } from "@fncts/base/typeclass/Foldable";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Foldable } from "@fncts/base/typeclass/Foldable";
+import type { Functor } from "@fncts/base/typeclass/Functor";
 
 import { identity } from "@fncts/base/data/function";
-import { Foldable } from "@fncts/base/typeclass/Foldable";
-import { Functor } from "@fncts/base/typeclass/Functor";
 
 /**
  * @tsplus type fncts.Traversable
  */
-export interface Traversable<F extends HKT, FC = HKT.None> extends Functor<F, FC>, Foldable<F, FC> {
-  readonly traverse_: traverse_<F, FC>;
-  readonly traverse: traverse<F, FC>;
-  readonly sequence: sequence<F, FC>;
+export interface Traversable<F extends HKT> extends Functor<F>, Foldable<F> {
+  traverse<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
+    ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>,
+    /** @tsplus auto */ G: Applicative<G>,
+  ): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
 }
 
 /**
@@ -22,156 +22,66 @@ export interface TraversableOps {}
 
 export const Traversable: TraversableOps = {};
 
-export type TraversableMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> &
-  FoldableMin<F, FC> & {
-    readonly traverse_: traverse_<F, FC>;
-  };
-
 /**
- * @tsplus static fncts.TraversableOps __call
+ * @tsplus fluent fncts.Kind traverse
  */
-export function mkTraversable<F extends HKT, FC = HKT.None>(F: TraversableMin<F, FC>): Traversable<F, FC> {
-  const sequence: sequence<F, FC> = (A) => {
-    const traverse_ = F.traverse_(A);
-    return (ta) => traverse_(ta, identity);
-  };
-  return HKT.instance<Traversable<F, FC>>({
-    ...Functor(F),
-    ...Foldable(F),
-    traverse_: F.traverse_,
-    traverse: (A) => {
-      const traverse_ = F.traverse_(A);
-      return (f) => (ta) => traverse_(ta, f);
-    },
-    sequence,
-  });
-}
-
-export interface traverse_<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    A,
-    B,
-  >(
-    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-    f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export interface traverseSelf<F extends HKT, FC = HKT.None> {
-  <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
-    G extends HKT,
-    GC = HKT.None,
-  >(
-    A: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
-    f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export interface traverse<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
-    f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>,
-  ) => <KF, QF, WF, XF, IF, SF, RF, EF>(
-    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+export function traverse<
+  F extends HKT,
+  G extends HKT,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  A,
+  B,
+>(
+  ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>,
+  /** @tsplus auto */ F: Traversable<F>,
+  /** @tsplus auto */ G: Applicative<G>,
+): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>> {
+  return F.traverse(ta, f, G);
 }
 
-export function mkTraverse_<F extends HKT, FC = HKT.None>(): (
-  i: <K, Q, W, X, I, S, R, E, A, B, G>(_: {
-    A: A;
-    B: B;
-    G: G;
-    K: K;
-    Q: Q;
-    W: W;
-    X: X;
-    I: I;
-    S: S;
-    R: R;
-    E: E;
-  }) => (
-    G: Applicative<HKT.F<G>>,
-  ) => (
-    ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
-    f: (a: A) => HKT.FK1<G, B>,
-  ) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
-) => traverse_<F, FC>;
-export function mkTraverse_() {
-  return (i: any) => i();
-}
-
-export function mkTraverse<F extends HKT, FC = HKT.None>(): (
-  i: <K, Q, W, X, I, S, R, E, A, B, G>(_: {
-    A: A;
-    B: B;
-    G: G;
-    K: K;
-    Q: Q;
-    W: W;
-    X: X;
-    I: I;
-    S: S;
-    R: R;
-    E: E;
-  }) => (
-    G: Applicative<HKT.F<G>>,
-  ) => (
-    f: (a: A) => HKT.FK1<G, B>,
-  ) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
-) => traverse<F, FC>;
-export function mkTraverse() {
-  return (i: any) => i();
-}
-
-export interface sequence<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    A,
-  >(
-    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, A>>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>>;
-}
-
-export interface sequenceSelf<F extends HKT, FC = HKT.None> {
-  <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
-    G extends HKT,
-    GC = HKT.None,
-  >(
-    A: CompatibleApplicative<G, GC, A>,
-  ) => [A] extends [
-    HKT.Kind<G, GC, infer KG, infer QG, infer WG, infer XG, infer IG, infer SG, infer RG, infer EG, infer B>,
-  ]
-    ? HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>
-    : never;
+/**
+ * @tsplus fluent fncts.Kind sequence
+ */
+export function sequence<
+  F extends HKT,
+  G extends HKT,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  A,
+>(
+  ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, A>>,
+  /** @tsplus auto */ F: Traversable<F>,
+  /** @tsplus auto */ G: Applicative<G>,
+): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>> {
+  return ta.traverse(identity);
 }