@fncts/base 0.0.12 → 0.0.15

package/global.d.ts

@@ -0,0 +1,237 @@
+/**
+ * @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";
+/**
+ * @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";
+export {};

package/index.d.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/json.d.ts

@@ -0,0 +1,3 @@
+export type {} from "./json/EitherJson.js";
+export type {} from "./json/MaybeJson.js";
+export type {} from "./json/TheseJson.js";

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

@@ -5,4 +5,4 @@ import { PTraversal } from "@fncts/base/optics/Traversal/definition";
  * @tsplus static fncts.optics.PTraversalOps fromTraversable
  * @tsplus location "@fncts/base/optics/Traversal/api/fromTraversable"
  */
-export declare function fromTraversable<T extends HKT>(T: P.Traversable<T>): <A, B, K = any, Q = unknown, W = never, X = never, I = any, S = any, R = unknown, E = never>() => PTraversal<import("@fncts/typelevel/HKT").HKT.Kind<T, K, Q, W, X, I, S, R, E, A>, import("@fncts/typelevel/HKT").HKT.Kind<T, K, Q, W, X, I, S, R, E, B>, A, B>;
+export declare function fromTraversable<F extends HKT, FC = HKT.None>(T: P.Traversable<F, FC>): <A, B, K = import("@fncts/typelevel/HKT").HKT.Low<F, "K">, Q = import("@fncts/typelevel/HKT").HKT.Low<F, "Q">, W = import("@fncts/typelevel/HKT").HKT.Low<F, "W">, X = import("@fncts/typelevel/HKT").HKT.Low<F, "X">, I = import("@fncts/typelevel/HKT").HKT.Low<F, "I">, S = import("@fncts/typelevel/HKT").HKT.Low<F, "S">, R = import("@fncts/typelevel/HKT").HKT.Low<F, "R">, E = import("@fncts/typelevel/HKT").HKT.Low<F, "E">>() => PTraversal<import("@fncts/typelevel/HKT").HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, import("@fncts/typelevel/HKT").HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, A, B>;

package/optics/Traversal/definition.d.ts

@@ -6,12 +6,10 @@ 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>(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>;
+    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, 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>(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>;
+    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, FC, K, Q, W, X, I, _S, R, E, B>) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 /**
  * @tsplus type fncts.optics.PTraversalOps

package/optics.d.ts

@@ -0,0 +1,10 @@
+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";

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.12",
+  "version": "0.0.15",
   "dependencies": {
-    "@fncts/typelevel": "0.0.10"
+    "@fncts/typelevel": "0.0.12"
   },
   "exports": {
     "./*": {
       "import": "./_mjs/*.mjs",
       "require": "./_cjs/*.cjs"
+    },
+    ".": {
+      "import": "./_mjs/index.mjs",
+      "require": "./_cjs/index.cjs"
     }
   },
   "publishConfig": {

package/typeclass/Align.d.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/typeclass/Alt.d.ts

@@ -4,8 +4,8 @@ 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>, 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>>>): 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]>>;
+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, 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<F, 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]>>;
 }
 /**
  * @tsplus type fncts.AltOps
@@ -13,5 +13,3 @@ export interface Alt<F extends HKT> extends Functor<F> {
 export interface AltOps {
 }
 export declare const Alt: AltOps;
-export declare 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]>>;

package/typeclass/Alternative.d.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/typeclass/Applicative.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 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,4 @@ export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {
 export interface ApplicativeOps {
 }
 export declare const Applicative: ApplicativeOps;
+export declare 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/typeclass/ApplicativeExcept.d.ts

@@ -6,8 +6,8 @@ import type { Fail } from "@fncts/base/typeclass/Fail";
 /**
  * @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>, 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>): 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>;
+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, 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<F, 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>;
 }
 /**
  * @tsplus type fncts.ApplicativeExceptOps
@@ -15,21 +15,13 @@ export interface ApplicativeExcept<F extends HKT> extends Applicative<F>, Fail<F
 export interface ApplicativeExceptOps {
 }
 export declare const ApplicativeExcept: ApplicativeExceptOps;
-/**
- * @tsplus fluent fncts.Kind catchAll
- * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
- */
-export declare 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>;
 /**
  * @tsplus fluent fncts.Kind catchJust
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare 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>, 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>, 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]>, HKT.Mix<"E", [E, E1]>, A | A1>;
+export declare 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, 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<F, 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>;
 /**
- * @tsplus fluent fncts.Kind either
+ * @tsplus static fncts.ApplicativeExceptOps either
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare 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>>;
+export declare 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>>;

package/typeclass/Apply.d.ts

@@ -5,8 +5,8 @@ import type { Object } from "@fncts/typelevel";
 /**
  * @tsplus type fncts.Apply
  */
-export interface Apply<F extends HKT> extends Semimonoidal<F>, Functor<F> {
-    zipWith<K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, D>(self: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>, that: 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>, f: (a: A, b: B) => D): 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]>, D>;
+export interface Apply<F extends HKT, FC = HKT.None> extends Semimonoidal<F, FC>, Functor<F, FC> {
+    zipWith: <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, D>(self: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>, that: 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>, f: (a: A, b: B) => D) => 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]>, D>;
 }
 /**
  * @tsplus type fncts.ApplyOps
@@ -15,58 +15,46 @@ export interface ApplyOps {
 }
 export declare const Apply: ApplyOps;
 /**
- * @tsplus fluent fncts.Kind zipWith
+ * @tsplus static fncts.ApplyOps ap
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare function zipWith<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, D>(self: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>, that: 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>, f: (a: A, b: B) => D, 
-/** @tsplus auto */ F: Apply<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]>, D>;
+export declare function ap<F extends HKT, FC = HKT.None>(F: Apply<F, FC>): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fab: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, (a: A) => B>, fa: 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>, A>) => 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]>, B>;
 /**
- * @tsplus fluent fncts.Kind ap
+ * @tsplus static fncts.ApplyOps apFirst
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare function ap<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fab: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, (a: A) => B>, fa: 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>, A>, 
-/** @tsplus auto */ F: Apply<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>;
+export declare function apFirst<F extends HKT, FC = HKT.None>(F: Apply<F, FC>): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>, fb: 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>;
 /**
- * @tsplus fluent fncts.Kind apFirst
+ * @tsplus static fncts.ApplyOps apSecond
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare function apFirst<F extends HKT, 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>, 
-/** @tsplus auto */ F: Apply<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>;
-/**
- * @tsplus fluent fncts.Kind apSecond
- * @tsplus location "@fncts/base/typeclass/Apply"
- */
-export declare function apSecond<F extends HKT, 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>, 
-/** @tsplus auto */ F: Apply<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>;
-export declare function apS<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, BN extends string, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fa: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>, name: Exclude<BN, keyof 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>, 
-/** @tsplus auto */ F: Apply<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]>, {
+export declare function apSecond<F extends HKT, FC = HKT.None>(F: Apply<F, FC>): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>, fb: 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]>, B>;
+export declare function apS<F extends HKT, FC = HKT.None>(F: Apply<F, FC>): <K1, Q1, W1, X1, I1, S1, R1, E1, A, BN extends string, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>, name: Exclude<BN, keyof A>, fb: 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]>, {
     [K in keyof A | BN]: K extends keyof A ? A[K] : B;
 }>;
 /**
  * @tsplus static fncts.ApplyOps sequenceS
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare function sequenceS<F extends HKT, KS extends Readonly<Record<string, HKT.Kind<F, HKT.Intro<"K", K, any>, HKT.Intro<"Q", Q, any>, HKT.Intro<"W", W, any>, HKT.Intro<"Q", Q, any>, HKT.Intro<"I", I, any>, HKT.Intro<"S", S, any>, HKT.Intro<"R", R, any>, HKT.Intro<"E", E, any>, A>>>, A, K = HKT.Low<"K">, Q = HKT.Low<"Q">, W = HKT.Low<"W">, I = HKT.Low<"I">, S = HKT.Low<"S">, R = HKT.Low<"R">, E = HKT.Low<"E">>(r: Object.EnforceNonEmpty<KS> & Readonly<Record<string, HKT.Kind<F, HKT.Intro<"K", K, any>, HKT.Intro<"Q", Q, any>, HKT.Intro<"W", W, any>, HKT.Intro<"Q", Q, any>, HKT.Intro<"I", I, any>, HKT.Intro<"S", S, any>, HKT.Intro<"R", R, any>, HKT.Intro<"E", E, any>, A>>>, 
-/** @tsplus auto */ F: Apply<F>): HKT.Kind<F, InferMixStruct<F, "K", K, KS>, InferMixStruct<F, "Q", Q, KS>, InferMixStruct<F, "W", W, KS>, InferMixStruct<F, "Q", Q, KS>, InferMixStruct<F, "I", I, KS>, InferMixStruct<F, "S", S, KS>, InferMixStruct<F, "R", R, KS>, InferMixStruct<F, "E", E, KS>, {
-    [K in keyof KS]: HKT.Infer<F, "A", KS[K]>;
+export declare function sequenceS<F extends HKT, FC = HKT.None>(F: Apply<F, FC>): <KS extends Readonly<Record<string, HKT.Kind<F, FC, HKT.Intro<F, "K", K, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "W", W, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "I", I, any>, HKT.Intro<F, "S", S, any>, HKT.Intro<F, "R", R, any>, HKT.Intro<F, "E", E, any>, A>>>, A, K = HKT.Low<F, "K">, Q = HKT.Low<F, "Q">, W = HKT.Low<F, "W">, I = HKT.Low<F, "I">, S = HKT.Low<F, "S">, R = HKT.Low<F, "R">, E = HKT.Low<F, "E">>(r: Object.EnforceNonEmpty<KS> & Readonly<Record<string, HKT.Kind<F, FC, HKT.Intro<F, "K", K, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "W", W, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "I", I, any>, HKT.Intro<F, "S", S, any>, HKT.Intro<F, "R", R, any>, HKT.Intro<F, "E", E, any>, A>>>) => HKT.Kind<F, FC, InferMixStruct<F, FC, "K", K, KS>, InferMixStruct<F, FC, "Q", Q, KS>, InferMixStruct<F, FC, "W", W, KS>, InferMixStruct<F, FC, "Q", Q, KS>, InferMixStruct<F, FC, "I", I, KS>, InferMixStruct<F, FC, "S", S, KS>, InferMixStruct<F, FC, "R", R, KS>, InferMixStruct<F, FC, "E", E, KS>, {
+    [K in keyof KS]: HKT.Infer<F, FC, "A", KS[K]>;
 }>;
-export declare function sequenceT<F extends HKT, KT extends readonly [
-    HKT.Kind<F, HKT.Intro<"K", K, any>, HKT.Intro<"Q", Q, any>, HKT.Intro<"W", W, any>, HKT.Intro<"Q", Q, any>, HKT.Intro<"I", I, any>, HKT.Intro<"S", S, any>, HKT.Intro<"R", R, any>, HKT.Intro<"E", E, any>, unknown>,
-    ...ReadonlyArray<HKT.Kind<F, HKT.Intro<"K", K, any>, HKT.Intro<"Q", Q, any>, HKT.Intro<"W", W, any>, HKT.Intro<"Q", Q, any>, HKT.Intro<"I", I, any>, HKT.Intro<"S", S, any>, HKT.Intro<"R", R, any>, HKT.Intro<"E", E, any>, unknown>>
-], K = HKT.Low<"K">, Q = HKT.Low<"Q">, W = HKT.Low<"W">, I = HKT.Low<"I">, S = HKT.Low<"S">, R = HKT.Low<"R">, E = HKT.Low<"E">>(t: [...KT], 
-/** @tsplus auto */ F: Apply<F>): HKT.Kind<F, InferMixTuple<F, "K", K, KT>, InferMixTuple<F, "Q", Q, KT>, InferMixTuple<F, "W", W, KT>, InferMixTuple<F, "Q", Q, KT>, InferMixTuple<F, "I", I, KT>, InferMixTuple<F, "S", S, KT>, InferMixTuple<F, "R", R, KT>, InferMixTuple<F, "E", E, KT>, {
-    [K in keyof KT]: HKT.Infer<F, "A", KT[K]>;
+export declare function sequenceT<F extends HKT, FC = HKT.None>(F: Apply<F, FC>): <KT extends readonly [
+    HKT.Kind<F, FC, HKT.Intro<F, "K", K, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "W", W, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "I", I, any>, HKT.Intro<F, "S", S, any>, HKT.Intro<F, "R", R, any>, HKT.Intro<F, "E", E, any>, unknown>,
+    ...ReadonlyArray<HKT.Kind<F, FC, HKT.Intro<F, "K", K, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "W", W, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "I", I, any>, HKT.Intro<F, "S", S, any>, HKT.Intro<F, "R", R, any>, HKT.Intro<F, "E", E, any>, unknown>>
+], K = HKT.Low<F, "K">, Q = HKT.Low<F, "Q">, W = HKT.Low<F, "W">, I = HKT.Low<F, "I">, S = HKT.Low<F, "S">, R = HKT.Low<F, "R">, E = HKT.Low<F, "E">>(t: [...KT]) => HKT.Kind<F, FC, InferMixTuple<F, FC, "K", K, KT>, InferMixTuple<F, FC, "Q", Q, KT>, InferMixTuple<F, FC, "W", W, KT>, InferMixTuple<F, FC, "Q", Q, KT>, InferMixTuple<F, FC, "I", I, KT>, InferMixTuple<F, FC, "S", S, KT>, InferMixTuple<F, FC, "R", R, KT>, InferMixTuple<F, FC, "E", E, KT>, {
+    [K in keyof KT]: HKT.Infer<F, FC, "A", KT[K]>;
 }>;
 /**
  * @internal
  */
-declare type InferMixStruct<F extends HKT, P extends HKT.ParamName, T, KS> = HKT.MixStruct<P, T, {
-    [K in keyof KS]: HKT.Infer<F, P, KS[K]>;
+declare type InferMixStruct<F extends HKT, FC, P extends HKT.ParamName, T, KS> = HKT.MixStruct<F, P, T, {
+    [K in keyof KS]: HKT.Infer<F, FC, P, KS[K]>;
 }>;
 /**
  * @internal
  */
-declare type InferMixTuple<F extends HKT, P extends HKT.ParamName, T, KT> = HKT.MixStruct<P, T, {
-    [K in keyof KT & number]: HKT.Infer<F, P, KT[K]>;
+declare type InferMixTuple<F extends HKT, FC, P extends HKT.ParamName, T, KT> = HKT.MixStruct<F, P, T, {
+    [K in keyof KT & number]: HKT.Infer<F, FC, P, KT[K]>;
 }>;
 export {};

package/typeclass/Chain.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { Functor } from "@fncts/base/typeclass/Functor";
-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, 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]>, B>;
+import { Functor } from "@fncts/base/typeclass/Functor";
+export interface FlatMap<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
+    flatMap: <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<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]>, B>;
 }
 /**
  * @tsplus type fncts.FlatMapOps
@@ -9,21 +9,13 @@ export interface FlatMap<F extends HKT> extends Functor<F> {
 export interface FlatMapOps {
 }
 export declare const FlatMap: FlatMapOps;
-/**
- * @tsplus fluent fncts.Kind flatMap
- * @tsplus location "@fncts/base/typeclass/Chain"
- */
-export declare 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, 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>;
 /**
  * @tsplus fluent fncts.Kind flatten
  * @tsplus location "@fncts/base/typeclass/Chain"
  */
-export declare 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, K2, Q2, W2, X2, I2, S2, R2, E2, HKT.Kind<F, 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>;
+export declare function flatten<F extends HKT, FC = HKT.None>(F: FlatMap<F, FC>): <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<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>;
 /**
  * @tsplus fluent fncts.Kind tap
  * @tsplus location "@fncts/base/typeclass/Chain"
  */
-export declare 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, 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>;
+export declare function tap<F extends HKT, FC = HKT.None>(F: FlatMap<F, FC>): <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<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>;

package/typeclass/Fail.d.ts

@@ -2,16 +2,11 @@ import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.Fail
  */
-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>;
+export interface Fail<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+    fail: <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: E) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
 }
 /**
  * @tsplus type fncts.FailOps
  */
 export interface FailOps {
 }
-/**
- * @tsplus static fncts.FailOps fail
- * @tsplus location "@fncts/base/typeclass/Fail"
- */
-export declare 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>;