@fncts/base 0.0.12 → 0.0.13

package/_src/typeclass/Chain.ts

@@ -1,34 +1,35 @@
-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> 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>,
+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,
-      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>,
+      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<
+  ) => 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]>,
+    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
   >;
 }
@@ -40,47 +41,15 @@ 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,
-    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);
-}
-
 /**
  * @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>(
+export 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,
@@ -91,64 +60,68 @@ export function flatten<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2
     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>,
+      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
     >
   >,
-  /** @tsplus auto */ F: FlatMap<F>,
-): HKT.Kind<
+) => 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]>,
+  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
 > {
-  return mma.flatMap(identity);
+  return (mma) => F.flatMap(mma, identity);
 }
 
 /**
  * @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>,
+export 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,
-    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>,
+    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
   >,
-  /** @tsplus auto */ F: FlatMap<F>,
-): HKT.Kind<
+) => 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]>,
+  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
 > {
-  return ma.flatMap((a) => f(a).as(a, F));
+  return (ma, f) => F.flatMap(ma, (a) => Functor.as(F)(f(a), a));
 }

package/_src/typeclass/Fail.ts

@@ -1,41 +1,23 @@
 /**
  * @tsplus type fncts.Fail
  */
-export interface Fail<F extends HKT> extends HKT.Typeclass<F> {
-  fail<
+export interface Fail<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+  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">,
+    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, K, Q, W, X, I, S, R, E, A>;
+  ) => 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
- */
-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);
-}

package/_src/typeclass/Filterable.ts

@@ -3,31 +3,31 @@ import type { Functor } from "@fncts/base/typeclass/Functor";
 /**
  * @tsplus type fncts.Filterable
  */
-export interface Filterable<F extends HKT> extends Functor<F> {
+export interface Filterable<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
   filter<K, Q, W, X, I, S, R, E, A, B extends A>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     refinement: Refinement<A, B>,
-  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
   filter<K, Q, W, X, I, S, R, E, A>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     predicate: Predicate<A>,
-  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;
+  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
   filterMap<K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     f: (a: A) => Maybe<B>,
-  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
   partition<K, Q, W, X, I, S, R, E, A, B extends A>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     refinement: Refinement<A, B>,
-  ): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B>];
+  ): readonly [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>];
   partition<K, Q, W, X, I, S, R, E, A>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     predicate: Predicate<A>,
-  ): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, A>];
+  ): readonly [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, A>];
   partitionMap<K, Q, W, X, I, S, R, E, A, B, B1>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     f: (a: A) => Either<B, B1>,
-  ): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B1>];
+  ): readonly [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, B1>];
 }
 
 /**
@@ -36,57 +36,3 @@ export interface Filterable<F extends HKT> extends Functor<F> {
 export interface FilterableOps {}
 
 export const Filterable: FilterableOps = {};
-
-/**
- * @tsplus fluent fncts.Kind filter
- */
-export function filter<F extends HKT, K, Q, W, X, I, S, R, E, A, B extends A>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  refinement: Refinement<A, B>,
-  /** @tsplus auto */ F: Filterable<F>,
-): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
-export function filter<F extends HKT, K, Q, W, X, I, S, R, E, A>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  predicate: Predicate<A>,
-  /** @tsplus auto */ F: Filterable<F>,
-): HKT.Kind<F, K, Q, W, X, I, S, R, E, A> {
-  return F.filter(fa, predicate);
-}
-
-/**
- * @tsplus fluent fncts.Kind filterMap
- */
-export function filterMap<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  f: (a: A) => Maybe<B>,
-  /** @tsplus auto */ F: Filterable<F>,
-): HKT.Kind<F, K, Q, W, X, I, S, R, E, B> {
-  return F.filterMap(fa, f);
-}
-
-/**
- * @tsplus fluent fncts.Kind partition
- */
-export function partition<F extends HKT, K, Q, W, X, I, S, R, E, A, B extends A>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  refinement: Refinement<A, B>,
-  /** @tsplus auto */ F: Filterable<F>,
-): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B>];
-export function partition<F extends HKT, K, Q, W, X, I, S, R, E, A>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  predicate: Predicate<A>,
-  /** @tsplus auto */ F: Filterable<F>,
-): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, A>] {
-  return F.partition(fa, predicate);
-}
-
-/**
- * @tsplus fluent fncts.Kind partitionMap
- */
-export function partitionMap<F extends HKT, K, Q, W, X, I, S, R, E, A, B, B1>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  f: (a: A) => Either<B, B1>,
-  /** @tsplus auto */ F: Filterable<F>,
-): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B1>] {
-  return F.partitionMap(fa, f);
-}

package/_src/typeclass/FilterableWithIndex.ts

@@ -4,31 +4,31 @@ import type { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
 /**
  * @tsplus type fncts.FilterableWithIndex
  */
-export interface FilterableWithIndex<F extends HKT> extends FunctorWithIndex<F>, Filterable<F> {
+export interface FilterableWithIndex<F extends HKT, FC = HKT.None> extends FunctorWithIndex<F, FC>, Filterable<F, FC> {
   filterWithIndex<K, Q, W, X, I, S, R, E, A, B extends A>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     refinement: RefinementWithIndex<HKT.IndexFor<F, K>, A, B>,
-  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
   filterWithIndex<K, Q, W, X, I, S, R, E, A>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     predicate: PredicateWithIndex<HKT.IndexFor<F, K>, A>,
-  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;
+  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
   filterMapWithIndex<K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     f: (i: HKT.IndexFor<F, K>, a: A) => Maybe<B>,
-  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
   partitionWithIndex<K, Q, W, X, I, S, R, E, A, B extends A>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     refinement: RefinementWithIndex<HKT.IndexFor<F, K>, A, B>,
-  ): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B>];
+  ): readonly [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>];
   partitionWithIndex<K, Q, W, X, I, S, R, E, A>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     predicate: PredicateWithIndex<HKT.IndexFor<F, K>, A>,
-  ): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, A>];
+  ): readonly [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, A>];
   partitionMapWithIndex<K, Q, W, X, I, S, R, E, A, B, B1>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     f: (i: HKT.IndexFor<F, K>, a: A) => Either<B, B1>,
-  ): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B1>];
+  ): readonly [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, B1>];
 }
 
 /**

package/_src/typeclass/Foldable.ts

@@ -3,13 +3,17 @@ import type { Monoid } from "@fncts/base/typeclass/Monoid";
 /**
  * @tsplus type fncts.Foldable
  */
-export interface Foldable<F extends HKT> extends HKT.Typeclass<F> {
-  foldLeft<K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, b: B, f: (b: B, a: A) => B): B;
-  foldRight<K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export interface Foldable<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+  foldLeft: <K, Q, W, X, I, S, R, E, A, B>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+    b: B,
+    f: (b: B, a: A) => B,
+  ) => B;
+  foldRight: <K, Q, W, X, I, S, R, E, A, B>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     b: Eval<B>,
     f: (a: A, b: Eval<B>) => Eval<B>,
-  ): Eval<B>;
+  ) => Eval<B>;
 }
 
 /**
@@ -20,37 +24,14 @@ export interface FoldableOps {}
 export const Foldable: FoldableOps = {};
 
 /**
- * @tsplus fluent fncts.Kind foldLeft
+ * @tsplus static fncts.FoldableOps foldMap
  */
-export function foldLeft<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  b: B,
-  f: (b: B, a: A) => B,
-  /** @tsplus auto */ F: Foldable<F>,
-): B {
-  return F.foldLeft(fa, b, f);
-}
-
-/**
- * @tsplus fluent fncts.Kind foldRight
- */
-export function foldRight<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  b: Eval<B>,
-  f: (a: A, b: Eval<B>) => Eval<B>,
-  /** @tsplus auto */ F: Foldable<F>,
-): Eval<B> {
-  return F.foldRight(fa, b, f);
-}
-
-/**
- * @tsplus fluent fncts.Kind foldMap
- */
-export function foldMap<F extends HKT, K, Q, W, X, I, S, R, E, A, M>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export function foldMap<F extends HKT, FC = HKT.None>(
+  F: Foldable<F, FC>,
+): <K, Q, W, X, I, S, R, E, A, M>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   f: (a: A) => M,
-  /** @tsplus auto */ F: Foldable<F>,
   /** @tsplus auto */ M: Monoid<M>,
-): M {
-  return fa.foldLeft(M.nat, (b, a) => M.combine(b, f(a)));
+) => M {
+  return (fa, f, M) => F.foldLeft(fa, M.nat, (b, a) => M.combine(b, f(a)));
 }

package/_src/typeclass/FoldableWithIndex.ts

@@ -4,17 +4,17 @@ import type { Monoid } from "@fncts/base/typeclass/Monoid";
 /**
  * @tsplus type fncts.FoldableWithIndex
  */
-export interface FoldableWithIndex<F extends HKT> extends Foldable<F> {
-  foldLeftWithIndex<K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export interface FoldableWithIndex<F extends HKT, FC = HKT.None> extends Foldable<F, FC> {
+  foldLeftWithIndex: <K, Q, W, X, I, S, R, E, A, B>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     b: B,
     f: (i: HKT.IndexFor<F, K>, b: B, a: A) => B,
-  ): B;
-  foldRightWithIndex<K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+  ) => B;
+  foldRightWithIndex: <K, Q, W, X, I, S, R, E, A, B>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     b: Eval<B>,
     f: (i: HKT.IndexFor<F, K>, a: A, b: Eval<B>) => Eval<B>,
-  ): Eval<B>;
+  ) => Eval<B>;
 }
 
 /**
@@ -25,37 +25,14 @@ export interface FoldableWithIndexOps {}
 export const FoldableWithIndex: FoldableWithIndexOps = {};
 
 /**
- * @tsplus fluent fncts.Kind foldLeftWithIndex
+ * @tsplus static fncts.FoldableWithIndexOps foldMapWithIndex
  */
-export function foldLeftWithIndex<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  b: B,
-  f: (i: HKT.IndexFor<F, K>, b: B, a: A) => B,
-  /** @tsplus auto */ F: FoldableWithIndex<F>,
-): B {
-  return F.foldLeftWithIndex(fa, b, f);
-}
-
-/**
- * @tsplus fluent fncts.Kind foldRightWithIndex
- */
-export function foldRightWithIndex<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  b: Eval<B>,
-  f: (i: HKT.IndexFor<F, K>, a: A, b: Eval<B>) => Eval<B>,
-  /** @tsplus auto */ F: FoldableWithIndex<F>,
-): Eval<B> {
-  return F.foldRightWithIndex(fa, b, f);
-}
-
-/**
- * @tsplus fluent fncts.Kind foldMapWithIndex
- */
-export function foldMapWithIndex<F extends HKT, K, Q, W, X, I, S, R, E, A, M>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export function foldMapWithIndex<F extends HKT, FC = HKT.None>(
+  F: FoldableWithIndex<F, FC>,
+): <K, Q, W, X, I, S, R, E, A, M>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   f: (k: HKT.IndexFor<F, K>, a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
-  /** @tsplus auto */ F: FoldableWithIndex<F>,
-): M {
-  return fa.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
+) => M {
+  return (fa, f, M) => F.foldLeftWithIndex(fa, M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }

package/_src/typeclass/Functor.ts

@@ -1,11 +1,11 @@
 /**
  * @tsplus type fncts.Functor
  */
-export interface Functor<F extends HKT> extends HKT.Typeclass<F> {
-  map<K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export interface Functor<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+  readonly map: <K, Q, W, X, I, S, R, E, A, B>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     f: (a: A) => B,
-  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
 }
 
 /**
@@ -16,23 +16,13 @@ export interface FunctorOps {}
 export const Functor: FunctorOps = {};
 
 /**
- * @tsplus fluent fncts.Kind map
+ * @tsplus static fncts.FunctorOps as
  */
-export function map<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
-  f: (a: A) => B,
-  /** @tsplus auto */ F: Functor<F>,
-): HKT.Kind<F, K, Q, W, X, I, S, R, E, B> {
-  return F.map(fa, f);
-}
-
-/**
- * @tsplus fluent fncts.Kind as
- */
-export function as<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+export function as<F extends HKT, FC = HKT.None>(
+  F: Functor<F, FC>,
+): <K, Q, W, X, I, S, R, E, A, B>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   b: Lazy<B>,
-  /** @tsplus auto */ F: Functor<F>,
-): HKT.Kind<F, K, Q, W, X, I, S, R, E, B> {
-  return fa.map(() => b(), F);
+) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B> {
+  return F.map;
 }

package/_src/typeclass/FunctorWithIndex.ts

@@ -1,10 +1,10 @@
 import type { Functor } from "@fncts/base/typeclass/Functor";
 
-export interface FunctorWithIndex<F extends HKT> extends Functor<F> {
-  mapWithIndex<K, W, Q, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, K, W, Q, X, I, S, R, E, A>,
+export interface FunctorWithIndex<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
+  readonly mapWithIndex: <K, W, Q, X, I, S, R, E, A, B>(
+    fa: HKT.Kind<F, FC, K, W, Q, X, I, S, R, E, A>,
     f: (i: HKT.IndexFor<F, K>, a: A) => B,
-  ): HKT.Kind<F, K, W, Q, X, I, S, R, E, B>;
+  ) => HKT.Kind<F, FC, K, W, Q, X, I, S, R, E, B>;
 }
 
 /**

package/_src/typeclass/Guard/definition.ts

@@ -9,9 +9,7 @@ export type GuardTypeId = typeof GuardTypeId;
  */
 export class Guard<A> {
   readonly _typeId: GuardTypeId = GuardTypeId;
-  readonly [HKT.F]!: GuardF;
-  readonly [HKT.A]!: () => A;
-  readonly [HKT.T]!: Guard<HKT._A<this>>;
+  declare _A: () => A;
   constructor(readonly is: Refinement<unknown, A>) {}
 }
 

package/_src/typeclass/Monad.ts

@@ -1,7 +1,7 @@
 import type { Applicative } from "@fncts/base/typeclass/Applicative";
 import type { FlatMap } from "@fncts/base/typeclass/Chain";
 
-export interface Monad<F extends HKT> extends Applicative<F>, FlatMap<F> {}
+export interface Monad<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, FlatMap<F, FC> {}
 
 /**
  * @tsplus type fncts.MonadOps