@fncts/base 0.0.12 → 0.0.15

package/_src/data/These/definition.ts

@@ -4,7 +4,7 @@ export const enum TheseTag {
   Both = "Both",
 }
 
-export const TheseTypeId = Symbol.for("fncts.base.data.These");
+export const TheseTypeId = Symbol.for("fncts.data.These");
 export type TheseTypeId = typeof TheseTypeId;
 
 /**

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/data/string/api.ts

@@ -175,7 +175,7 @@ export const under = Pipeable(under_);
 /**
  * Join newline-separated strings together.
  *
- * @tsplus getter fncts.base.ImmutableArray unlines
+ * @tsplus getter fncts.ImmutableArray unlines
  */
 export function unlines(as: ReadonlyArray<string>): string {
   return as.join("\n");

package/_src/data.ts

@@ -0,0 +1,35 @@
+// codegen:start { preset: type-barrel, include: ./data/*.ts }
+export type {} from "./data/bigint.js";
+export type {} from "./data/boolean.js";
+export type {} from "./data/Branded.js";
+export type {} from "./data/Byte.js";
+export type {} from "./data/CaseClass.js";
+export type {} from "./data/Cause.js";
+export type {} from "./data/Const.js";
+export type {} from "./data/DecodeError.js";
+export type {} from "./data/Decoder.js";
+export type {} from "./data/Duration.js";
+export type {} from "./data/Either.js";
+export type {} from "./data/Environment.js";
+export type {} from "./data/exceptions.js";
+export type {} from "./data/ExecutionStrategy.js";
+export type {} from "./data/Exit.js";
+export type {} from "./data/FiberId.js";
+export type {} from "./data/function.js";
+export type {} from "./data/Identity.js";
+export type {} from "./data/Interval.js";
+export type {} from "./data/Intervals.js";
+export type {} from "./data/Maybe.js";
+export type {} from "./data/Newtype.js";
+export type {} from "./data/number.js";
+export type {} from "./data/object.js";
+export type {} from "./data/Patch.js";
+export type {} from "./data/Predicate.js";
+export type {} from "./data/Refinement.js";
+export type {} from "./data/string.js";
+export type {} from "./data/Tag.js";
+export type {} from "./data/These.js";
+export type {} from "./data/Trace.js";
+export type {} from "./data/TraceElement.js";
+export type {} from "./data/Zipped.js";
+// codegen:end

package/_src/global.ts

@@ -0,0 +1,252 @@
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/base";
+
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/collection/compat/Array";
+/**
+ * @tsplus global
+ */
+import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus global
+ */
+import { Dictionary } from "@fncts/base/collection/immutable/Dictionary/definition";
+/**
+ * @tsplus global
+ */
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+/**
+ * @tsplus global
+ */
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+/**
+ * @tsplus global
+ */
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+/**
+ * @tsplus global
+ */
+import {
+  ImmutableNonEmptyArray,
+  NonEmptyArray,
+  ReadonlyNonEmptyArray,
+} from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+/**
+ * @tsplus global
+ */
+import { Cons, List, Nil } from "@fncts/base/collection/immutable/List/definition";
+/**
+ * @tsplus global
+ */
+import { Queue as ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
+/**
+ * @tsplus global
+ */
+import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+/**
+ * @tsplus global
+ */
+import { SortedMap } from "@fncts/base/collection/immutable/SortedMap/definition";
+/**
+ * @tsplus global
+ */
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+/**
+ * @tsplus global
+ */
+import { Iterable } from "@fncts/base/collection/Iterable/definition";
+/**
+ * @tsplus global
+ */
+import { HashMap as MutableHashMap } from "@fncts/base/collection/mutable/HashMap";
+/**
+ * @tsplus global
+ */
+import { HashSet as MutableHashSet } from "@fncts/base/collection/mutable/HashSet";
+/**
+ * @tsplus global
+ */
+import { ListBuffer } from "@fncts/base/collection/mutable/ListBuffer";
+/**
+ * @tsplus global
+ */
+import { Eval } from "@fncts/base/control/Eval/definition";
+/**
+ * @tsplus global
+ */
+import { LazyValue } from "@fncts/base/control/LazyValue";
+/**
+ * @tsplus global
+ */
+import { Z } from "@fncts/base/control/Z/definition";
+/**
+ * @tsplus global
+ */
+import { Byte } from "@fncts/base/data/Byte";
+/**
+ * @tsplus global
+ */
+import { CaseClass } from "@fncts/base/data/CaseClass";
+/**
+ * @tsplus global
+ */
+import { Cause } from "@fncts/base/data/Cause/definition";
+/**
+ * @tsplus global
+ */
+import { Const } from "@fncts/base/data/Const/definition";
+/**
+ * @tsplus global
+ */
+import { Datum } from "@fncts/base/data/Datum/definition";
+/**
+ * @tsplus global
+ */
+import { DatumEither } from "@fncts/base/data/DatumEither/definition";
+/**
+ * @tsplus global
+ */
+import { Decoder } from "@fncts/base/data/Decoder";
+/**
+ * @tsplus global
+ */
+import { Duration } from "@fncts/base/data/Duration/definition";
+/**
+ * @tsplus global
+ */
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus global
+ */
+import { Environment } from "@fncts/base/data/Environment/definition";
+/**
+ * @tsplus global
+ */
+import {
+  ArrayIndexOutOfBoundsError,
+  IllegalArgumentError,
+  IllegalStateError,
+  IndexOutOfBoundsError,
+  InterruptedException,
+  InvalidCapacityError,
+  isInterruptedException,
+  isInvalidCapacityError,
+  NoSuchElementError,
+} from "@fncts/base/data/exceptions";
+/**
+ * @tsplus global
+ */
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+/**
+ * @tsplus global
+ */
+import { Exit } from "@fncts/base/data/Exit/definition";
+/**
+ * @tsplus global
+ */
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+/**
+ * @tsplus global
+ */
+import { unsafeCoerce } from "@fncts/base/data/function/api";
+/**
+ * @tsplus global
+ */
+import { Lazy } from "@fncts/base/data/function/definition";
+/**
+ * @tsplus global
+ */
+import { Identity } from "@fncts/base/data/Identity/definition";
+/**
+ * @tsplus global
+ */
+import { Interval } from "@fncts/base/data/Interval";
+/**
+ * @tsplus global
+ */
+import { Intervals } from "@fncts/base/data/Intervals";
+/**
+ * @tsplus global
+ */
+import { Just, Maybe, MaybeTag, Nothing } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus global
+ */
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/number/definition";
+import {} from "@fncts/base/data/object/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/object/definition";
+/**
+ * @tsplus global
+ */
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
+/**
+ * @tsplus global
+ */
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/string/definition";
+/**
+ * @tsplus global
+ */
+import { Struct } from "@fncts/base/data/Struct/definition";
+/**
+ * @tsplus global
+ */
+import { Tag } from "@fncts/base/data/Tag/definition";
+/**
+ * @tsplus global
+ */
+import { These } from "@fncts/base/data/These";
+/**
+ * @tsplus global
+ */
+import { Trace } from "@fncts/base/data/Trace/definition";
+/**
+ * @tsplus global
+ */
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+/**
+ * @tsplus global
+ */
+import { Zipped } from "@fncts/base/data/Zipped";
+/**
+ * @tsplus global
+ */
+import { Stack } from "@fncts/base/internal/Stack";
+/**
+ * @tsplus global
+ */
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+/**
+ * @tsplus global
+ */
+import { Guard } from "@fncts/base/typeclass/Guard";
+/**
+ * @tsplus global
+ */
+import { Has } from "@fncts/base/typeclass/Has";
+/**
+ * @tsplus global
+ */
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+/**
+ * @tsplus global
+ */
+import { hasTypeId, isByte, isObject } from "@fncts/base/util/predicates";
+/**
+ * @tsplus global
+ */
+import { HKT } from "@fncts/typelevel/HKT";

package/_src/index.ts

@@ -0,0 +1,8 @@
+export type {} from "./collection.js";
+export type {} from "./control.js";
+export type {} from "./data.js";
+export type {} from "./json.js";
+export type {} from "./optics.js";
+export type {} from "./typeclass.js";
+export type {} from "./types.js";
+export type {} from "./util.js";

package/_src/json.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: type-barrel, include: ./json/*.ts }
+export type {} from "./json/EitherJson.js";
+export type {} from "./json/MaybeJson.js";
+export type {} from "./json/TheseJson.js";
+// codegen:end

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/optics.ts

@@ -0,0 +1,12 @@
+// codegen:start { preset: type-barrel, include: ./optics/*.ts }
+export type {} from "./optics/At.js";
+export type {} from "./optics/Fold.js";
+export type {} from "./optics/Getter.js";
+export type {} from "./optics/Index.js";
+export type {} from "./optics/Iso.js";
+export type {} from "./optics/Lens.js";
+export type {} from "./optics/Optional.js";
+export type {} from "./optics/Prism.js";
+export type {} from "./optics/Setter.js";
+export type {} from "./optics/Traversal.js";
+// codegen:end

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]);