@fncts/base 0.0.12 → 0.0.13

package/_src/data/Zipped.ts

@@ -0,0 +1,52 @@
+import { assert } from "@fncts/base/util/assert";
+import { isArray } from "@fncts/base/util/predicates";
+
+export const ZippedTypeId = Symbol.for("fncts.Zipped");
+export type ZippedTypeId = typeof ZippedTypeId;
+
+export type Zipped<A extends Array<any>> = Readonly<A> & { readonly [ZippedTypeId]: ZippedTypeId };
+
+export declare namespace Zipped {
+  type Make<A, B> = [A] extends [Zipped<infer X>]
+    ? [B] extends [Zipped<infer Y>]
+      ? Zipped<[...X, ...Y]>
+      : Zipped<[...X, B]>
+    : [B] extends [Zipped<infer Y>]
+    ? Zipped<[A, ...Y]>
+    : Zipped<[A, B]>;
+}
+
+/**
+ * @tsplus type fncts.ZippedOps
+ */
+export interface ZippedOps {}
+
+export const Zipped: ZippedOps = {};
+
+/**
+ * @tsplus static fncts.ZippedOps is
+ */
+export function isZipped(a: unknown): a is Zipped<Array<unknown>> {
+  return isArray(a) && ZippedTypeId in a;
+}
+
+/**
+ * @tsplus static fncts.ZippedOps __call
+ */
+export function make<A, B>(a: A, b: B): Zipped.Make<A, B> {
+  let zipped: Zipped<any>;
+  if (isZipped(a)) {
+    if (isZipped(b)) {
+      zipped = unsafeCoerce([...a, ...b]);
+    } else {
+      zipped = unsafeCoerce([...a, b]);
+    }
+  } else if (isZipped(b)) {
+    zipped = unsafeCoerce([a, ...b]);
+  } else {
+    zipped = unsafeCoerce([a, b]);
+  }
+  // @ts-expect-error
+  zipped[ZippedTypeId] = ZippedTypeId;
+  return unsafeCoerce(zipped);
+}

package/_src/data/function/api.ts

@@ -31,6 +31,14 @@ export function tuple<A extends ReadonlyArray<unknown>>(...as: A): A {
 }
 
 /**
+ * @tsplus getter fncts.Function tupled
+ */
+export function tupled<A, B, C>(f: (a: A, b: B) => C): (_: readonly [A, B]) => C {
+  return ([a, b]) => f(a, b);
+}
+
+/**
+ * @tsplus fluent global unsafeCoerce
  * @tsplus static fncts.FunctionOps unsafeCoerce
  * @tsplus macro identity
  */

package/_src/data/object/instances.ts

@@ -1,7 +1,17 @@
+import type { Check } from "@fncts/typelevel/Check";
+
 import * as P from "@fncts/base/typeclass";
 
 /**
- * @tsplus implicit
  * @tsplus static fncts.globalOps Guard
  */
 export const Guard: P.Guard<{}> = P.Guard(isObject);
+
+/**
+ * @tsplus derive fncts.Guard<_> 10
+ */
+export function deriveGuard<A extends {}>(
+  ..._: Check<Check.IsEqual<A, {}>> extends Check.True ? [] : never
+): P.Guard<A> {
+  return P.Guard((u): u is A => typeof u === "object" && u !== null);
+}

package/_src/optics/Optional/definition.ts

@@ -37,10 +37,10 @@ export function mkPOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptional<
     modifyMaybe_,
     modifyMaybe: (f) => (s) => modifyMaybe_(s, f),
     ...PTraversal<S, T, A, B>({
-      modifyA: (s, f, A) =>
+      modifyA: (A) => (s, f) =>
         F.getOrModify(s).match(
           (t) => A.pure(t),
-          (a) => f(a).map((b) => F.replace_(s, b), A),
+          (a) => A.map(f(a), (b) => F.replace_(s, b)),
         ),
     }),
   };

package/_src/optics/Traversal/api/compose.ts

@@ -8,6 +8,6 @@ export function compose_<S, T, A, B, C, D>(
   that: PTraversal<A, B, C, D>,
 ): PTraversal<S, T, C, D> {
   return PTraversal<S, T, C, D>({
-    modifyA: (s, f, F) => self.modifyA(s, (a) => that.modifyA(a, f, F), F),
+    modifyA: (F) => (s, f) => self.modifyA(F)(s, (a) => that.modifyA(F)(a, f)),
   });
 }

package/_src/optics/Traversal/api/fromTraversable.ts

@@ -5,20 +5,20 @@ import { PTraversal } from "@fncts/base/optics/Traversal/definition";
 /**
  * @tsplus static fncts.optics.PTraversalOps fromTraversable
  */
-export function fromTraversable<T extends HKT>(T: P.Traversable<T>) {
+export function fromTraversable<F extends HKT, FC = HKT.None>(T: P.Traversable<F, FC>) {
   return <
     A,
     B,
-    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">,
-    E = HKT.Low<"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">,
+    E = HKT.Low<F, "E">,
   >() =>
-    PTraversal<HKT.Kind<T, K, Q, W, X, I, S, R, E, A>, HKT.Kind<T, K, Q, W, X, I, S, R, E, B>, A, B>({
-      modifyA: (s, f, F) => T.traverse(s, f, F),
+    PTraversal<HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, A, B>({
+      modifyA: (F) => (s, f) => T.traverse(s)(F)(f),
     });
 }

package/_src/optics/Traversal/definition.ts

@@ -7,19 +7,21 @@ import { PSetter } from "@fncts/base/optics/Setter";
  * @tsplus type fncts.optics.PTraversal
  */
 export interface PTraversal<S, T, A, B> extends PSetter<S, T, A, B>, Fold<S, A> {
-  modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(
+  modifyA: <F extends HKT, FC = HKT.None>(
+    F: Applicative<F, FC>,
+  ) => <K, Q, W, X, I, _S, R, E>(
     s: S,
-    f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>,
-    /** @tsplus auto */ F: Applicative<F>,
-  ): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
+    f: (a: A) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, B>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 
 export interface PTraversalMin<S, T, A, B> {
-  modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(
+  modifyA: <F extends HKT, FC = HKT.None>(
+    F: Applicative<F, FC>,
+  ) => <K, Q, W, X, I, _S, R, E>(
     s: S,
-    f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>,
-    /** @tsplus auto */ F: Applicative<F>,
-  ): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
+    f: (a: A) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, B>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 
 /**
@@ -37,18 +39,17 @@ export function mkPTraversal<S, T, A, B>(F: PTraversalMin<S, T, A, B>): PTravers
     modifyA: F.modifyA,
     ...PSetter<S, T, A, B>({
       modify_: (s, f) =>
-        F.modifyA(
+        F.modifyA(Identity.Applicative)(
           s,
           f.compose((b) => Identity.get(b)),
-          Identity.Applicative,
         ).getIdentity,
-      set_: (s, b) => F.modifyA(s, () => Identity.get(b), Identity.Applicative).getIdentity,
+      set_: (s, b) => F.modifyA(Identity.Applicative)(s, () => Identity.get(b)).getIdentity,
     }),
     ...Fold<S, A>({
       foldMap_:
         <M>(M: Monoid<M>) =>
         (s: S, f: (a: A) => M) =>
-          F.modifyA(s, (a) => Const(f(a)), Const.getApplicative(M)).getConst,
+          F.modifyA(Const.getApplicative(M))(s, (a) => Const(f(a))).getConst,
     }),
   };
 }

package/_src/typeclass/Align.ts

@@ -4,7 +4,7 @@ import type { Semialign } from "@fncts/base/typeclass/Semialign";
 /**
  * @tsplus type fncts.Align
  */
-export interface Align<F extends HKT> extends Semialign<F>, Nil<F> {}
+export interface Align<F extends HKT, FC = HKT.None> extends Semialign<F, FC>, Nil<F, FC> {}
 
 /**
  * @tsplus type fncts.AlignOps

package/_src/typeclass/Alt.ts

@@ -3,34 +3,36 @@ import type { Functor } from "@fncts/base/typeclass/Functor";
 /**
  * @tsplus type fncts.Alt
  */
-export interface Alt<F extends HKT> extends Functor<F> {
-  alt<K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
+  alt: <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     that: Lazy<
       HKT.Kind<
         F,
-        HKT.Intro<"K", K, K1>,
-        HKT.Intro<"Q", Q, Q1>,
-        HKT.Intro<"W", W, W1>,
-        HKT.Intro<"X", X, X1>,
-        HKT.Intro<"I", I, I1>,
-        HKT.Intro<"S", S, S1>,
-        HKT.Intro<"R", R, R1>,
-        HKT.Intro<"E", E, E1>,
-        HKT.Intro<"A", A, B>
+        FC,
+        HKT.Intro<F, "K", K, K1>,
+        HKT.Intro<F, "Q", Q, Q1>,
+        HKT.Intro<F, "W", W, W1>,
+        HKT.Intro<F, "X", X, X1>,
+        HKT.Intro<F, "I", I, I1>,
+        HKT.Intro<F, "S", S, S1>,
+        HKT.Intro<F, "R", R, R1>,
+        HKT.Intro<F, "E", E, E1>,
+        HKT.Intro<F, "A", A, B>
       >
     >,
-  ): HKT.Kind<
+  ) => HKT.Kind<
     F,
-    HKT.Mix<"K", [K, K1]>,
-    HKT.Mix<"Q", [Q, Q1]>,
-    HKT.Mix<"W", [W, W1]>,
-    HKT.Mix<"X", [X, X1]>,
-    HKT.Mix<"I", [I, I1]>,
-    HKT.Mix<"S", [S, S1]>,
-    HKT.Mix<"R", [R, R1]>,
-    HKT.Mix<"E", [E, E1]>,
-    HKT.Mix<"A", [A, B]>
+    FC,
+    HKT.Mix<F, "K", [K, K1]>,
+    HKT.Mix<F, "Q", [Q, Q1]>,
+    HKT.Mix<F, "W", [W, W1]>,
+    HKT.Mix<F, "X", [X, X1]>,
+    HKT.Mix<F, "I", [I, I1]>,
+    HKT.Mix<F, "S", [S, S1]>,
+    HKT.Mix<F, "R", [R, R1]>,
+    HKT.Mix<F, "E", [E, E1]>,
+    HKT.Mix<F, "A", [A, B]>
   >;
 }
 
@@ -40,35 +42,3 @@ export interface Alt<F extends HKT> extends Functor<F> {
 export interface AltOps {}
 
 export const Alt: AltOps = {};
-
-export function alt<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-  self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  that: Lazy<
-    HKT.Kind<
-      F,
-      HKT.Intro<"K", K, K1>,
-      HKT.Intro<"Q", Q, Q1>,
-      HKT.Intro<"W", W, W1>,
-      HKT.Intro<"X", X, X1>,
-      HKT.Intro<"I", I, I1>,
-      HKT.Intro<"S", S, S1>,
-      HKT.Intro<"R", R, R1>,
-      HKT.Intro<"E", E, E1>,
-      HKT.Intro<"A", A, B>
-    >
-  >,
-  /** @tsplus auto */ F: Alt<F>,
-): HKT.Kind<
-  F,
-  HKT.Mix<"K", [K, K1]>,
-  HKT.Mix<"Q", [Q, Q1]>,
-  HKT.Mix<"W", [W, W1]>,
-  HKT.Mix<"X", [X, X1]>,
-  HKT.Mix<"I", [I, I1]>,
-  HKT.Mix<"S", [S, S1]>,
-  HKT.Mix<"R", [R, R1]>,
-  HKT.Mix<"E", [E, E1]>,
-  HKT.Mix<"A", [A, B]>
-> {
-  return F.alt(self, that);
-}

package/_src/typeclass/Alternative.ts

@@ -5,7 +5,7 @@ import type { Nil } from "@fncts/base/typeclass/Nil";
 /**
  * @tsplus type fncts.Alternative
  */
-export interface Alternative<F extends HKT> extends Applicative<F>, Nil<F>, Alt<F> {}
+export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Nil<F, FC>, Alt<F, FC> {}
 
 /**
  * @tsplus type fncts.AlternativeOps

package/_src/typeclass/Applicative.ts

@@ -1,7 +1,7 @@
 import type { Apply } from "@fncts/base/typeclass/Apply";
 import type { Pointed } from "@fncts/base/typeclass/Pointed";
 
-export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {}
+export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>, Pointed<F, FC> {}
 
 /**
  * @tsplus type fncts.ApplicativeOps
@@ -9,3 +9,8 @@ export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {}
 export interface ApplicativeOps {}
 
 export const Applicative: ApplicativeOps = {};
+
+export type CompatibleApplicative<F extends HKT, FC, A> = Applicative<F, FC> &
+  ([A] extends [HKT.Kind<F, any, any, any, any, any, any, any, any, any, any>]
+    ? unknown
+    : ["invalid Applicative instance for", A]);

package/_src/typeclass/ApplicativeExcept.ts

@@ -6,32 +6,34 @@ import { identity } from "@fncts/base/data/function";
 /**
  * @tsplus type fncts.ApplicativeExcept
  */
-export interface ApplicativeExcept<F extends HKT> extends Applicative<F>, Fail<F> {
-  catchAll<K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export interface ApplicativeExcept<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Fail<F, FC> {
+  catchAll: <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     f: (
       e: E,
     ) => HKT.Kind<
       F,
-      HKT.Intro<"K", K, K1>,
-      HKT.Intro<"Q", Q, Q1>,
-      HKT.Intro<"W", W, W1>,
-      HKT.Intro<"X", X, X1>,
-      HKT.Intro<"I", I, I1>,
-      HKT.Intro<"S", S, S1>,
-      HKT.Intro<"R", R, R1>,
-      HKT.Intro<"E", E, E1>,
+      FC,
+      HKT.Intro<F, "K", K, K1>,
+      HKT.Intro<F, "Q", Q, Q1>,
+      HKT.Intro<F, "W", W, W1>,
+      HKT.Intro<F, "X", X, X1>,
+      HKT.Intro<F, "I", I, I1>,
+      HKT.Intro<F, "S", S, S1>,
+      HKT.Intro<F, "R", R, R1>,
+      HKT.Intro<F, "E", E, E1>,
       A1
     >,
-  ): HKT.Kind<
+  ) => HKT.Kind<
     F,
-    HKT.Mix<"K", [K, K1]>,
-    HKT.Mix<"Q", [Q, Q1]>,
-    HKT.Mix<"W", [W, W1]>,
-    HKT.Mix<"X", [X, X1]>,
-    HKT.Mix<"I", [I, I1]>,
-    HKT.Mix<"S", [S, S1]>,
-    HKT.Mix<"R", [R, R1]>,
+    FC,
+    HKT.Mix<F, "K", [K, K1]>,
+    HKT.Mix<F, "Q", [Q, Q1]>,
+    HKT.Mix<F, "W", [W, W1]>,
+    HKT.Mix<F, "X", [X, X1]>,
+    HKT.Mix<F, "I", [I, I1]>,
+    HKT.Mix<F, "S", [S, S1]>,
+    HKT.Mix<F, "R", [R, R1]>,
     E1,
     A | A1
   >;
@@ -44,84 +46,56 @@ export interface ApplicativeExceptOps {}
 
 export const ApplicativeExcept: ApplicativeExceptOps = {};
 
-/**
- * @tsplus fluent fncts.Kind catchAll
- */
-export function catchAll<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  f: (
-    e: E,
-  ) => HKT.Kind<
-    F,
-    HKT.Intro<"K", K, K1>,
-    HKT.Intro<"Q", Q, Q1>,
-    HKT.Intro<"W", W, W1>,
-    HKT.Intro<"X", X, X1>,
-    HKT.Intro<"I", I, I1>,
-    HKT.Intro<"S", S, S1>,
-    HKT.Intro<"R", R, R1>,
-    HKT.Intro<"E", E, E1>,
-    A1
-  >,
-  /** @tsplus auto */ F: ApplicativeExcept<F>,
-): HKT.Kind<
-  F,
-  HKT.Mix<"K", [K, K1]>,
-  HKT.Mix<"Q", [Q, Q1]>,
-  HKT.Mix<"W", [W, W1]>,
-  HKT.Mix<"X", [X, X1]>,
-  HKT.Mix<"I", [I, I1]>,
-  HKT.Mix<"S", [S, S1]>,
-  HKT.Mix<"R", [R, R1]>,
-  E1,
-  A | A1
-> {
-  return F.catchAll(fa, f);
-}
-
 /**
  * @tsplus fluent fncts.Kind catchJust
  */
-export function catchJust<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export function catchJust<F extends HKT, FC = HKT.None>(
+  F: ApplicativeExcept<F, FC>,
+): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   f: (
     e: E,
   ) => Maybe<
     HKT.Kind<
       F,
-      HKT.Intro<"K", K, K1>,
-      HKT.Intro<"Q", Q, Q1>,
-      HKT.Intro<"W", W, W1>,
-      HKT.Intro<"X", X, X1>,
-      HKT.Intro<"I", I, I1>,
-      HKT.Intro<"S", S, S1>,
-      HKT.Intro<"R", R, R1>,
-      HKT.Intro<"E", E, E1>,
+      FC,
+      HKT.Intro<F, "K", K, K1>,
+      HKT.Intro<F, "Q", Q, Q1>,
+      HKT.Intro<F, "W", W, W1>,
+      HKT.Intro<F, "X", X, X1>,
+      HKT.Intro<F, "I", I, I1>,
+      HKT.Intro<F, "S", S, S1>,
+      HKT.Intro<F, "R", R, R1>,
+      HKT.Intro<F, "E", E, E1>,
       A1
     >
   >,
-  /** @tsplus auto */ F: ApplicativeExcept<F>,
-): HKT.Kind<
+) => HKT.Kind<
   F,
-  HKT.Mix<"K", [K, K1]>,
-  HKT.Mix<"Q", [Q, Q1]>,
-  HKT.Mix<"W", [W, W1]>,
-  HKT.Mix<"X", [X, X1]>,
-  HKT.Mix<"I", [I, I1]>,
-  HKT.Mix<"S", [S, S1]>,
-  HKT.Mix<"R", [R, R1]>,
-  HKT.Mix<"E", [E, E1]>,
+  FC,
+  HKT.Mix<F, "K", [K, K1]>,
+  HKT.Mix<F, "Q", [Q, Q1]>,
+  HKT.Mix<F, "W", [W, W1]>,
+  HKT.Mix<F, "X", [X, X1]>,
+  HKT.Mix<F, "I", [I, I1]>,
+  HKT.Mix<F, "S", [S, S1]>,
+  HKT.Mix<F, "R", [R, R1]>,
+  HKT.Mix<F, "E", [E, E1]>,
   A | A1
 > {
-  return fa.catchAll((e) => f(e).match(() => F.fail(e), identity) as HKT.Kind<F, K, Q1, W1, X1, I, S, R1, E1, A1>);
+  return (fa, f) => F.catchAll(fa, (e) => unsafeCoerce(f(e).match(() => F.fail(e), identity)));
 }
 
 /**
- * @tsplus fluent fncts.Kind either
+ * @tsplus static fncts.ApplicativeExceptOps either
  */
-export function either<F extends HKT, K, Q, W, X, I, S, R, E, A>(
-  self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  /** @tsplus auto */ F: ApplicativeExcept<F>,
-): HKT.Kind<F, K, Q, W, X, I, S, R, never, Either<E, A>> {
-  return self.map(Either.right, F).catchAll((e) => F.pure(Either.left(e)));
+export function either<F extends HKT, FC = HKT.None>(
+  F: ApplicativeExcept<F, FC>,
+): <K, Q, W, X, I, S, R, E, A>(
+  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, never, Either<E, A>>;
+export function either<F>(
+  F: ApplicativeExcept<HKT.FCoE<F>>,
+): <E, A>(self: HKT.FK2<F, E, A>) => HKT.FK2<F, never, Either<E, A>> {
+  return (self) => F.catchAll(F.map(self, Either.right), (e) => F.pure(Either.left(e)));
 }