@fncts/base 0.0.12 → 0.0.15

package/typeclass/Filterable.d.ts

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

package/typeclass/FilterableWithIndex.d.ts

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

package/typeclass/Foldable.d.ts

@@ -4,9 +4,9 @@ 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>, b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): Eval<B>;
+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>;
 }
 /**
  * @tsplus type fncts.FoldableOps
@@ -15,21 +15,8 @@ export interface FoldableOps {
 }
 export declare const Foldable: FoldableOps;
 /**
- * @tsplus fluent fncts.Kind foldLeft
+ * @tsplus static fncts.FoldableOps foldMap
  * @tsplus location "@fncts/base/typeclass/Foldable"
  */
-export declare 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;
-/**
- * @tsplus fluent fncts.Kind foldRight
- * @tsplus location "@fncts/base/typeclass/Foldable"
- */
-export declare 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>;
-/**
- * @tsplus fluent fncts.Kind foldMap
- * @tsplus location "@fncts/base/typeclass/Foldable"
- */
-export declare 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>, f: (a: A) => M, 
-/** @tsplus auto */ F: Foldable<F>, 
-/** @tsplus auto */ M: Monoid<M>): M;
+export declare 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 */ M: Monoid<M>) => M;

package/typeclass/FoldableWithIndex.d.ts

@@ -5,9 +5,9 @@ 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>, 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: Eval<B>, f: (i: HKT.IndexFor<F, K>, a: A, b: Eval<B>) => Eval<B>): Eval<B>;
+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, 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>;
 }
 /**
  * @tsplus type fncts.FoldableWithIndexOps
@@ -16,21 +16,8 @@ export interface FoldableWithIndexOps {
 }
 export declare const FoldableWithIndex: FoldableWithIndexOps;
 /**
- * @tsplus fluent fncts.Kind foldLeftWithIndex
+ * @tsplus static fncts.FoldableWithIndexOps foldMapWithIndex
  * @tsplus location "@fncts/base/typeclass/FoldableWithIndex"
  */
-export declare 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;
-/**
- * @tsplus fluent fncts.Kind foldRightWithIndex
- * @tsplus location "@fncts/base/typeclass/FoldableWithIndex"
- */
-export declare 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>;
-/**
- * @tsplus fluent fncts.Kind foldMapWithIndex
- * @tsplus location "@fncts/base/typeclass/FoldableWithIndex"
- */
-export declare 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>, f: (k: HKT.IndexFor<F, K>, a: A) => M, 
-/** @tsplus auto */ M: Monoid<M>, 
-/** @tsplus auto */ F: FoldableWithIndex<F>): M;
+export declare 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>) => M;

package/typeclass/Functor.d.ts

@@ -3,8 +3,8 @@ import { Lazy } from "@fncts/base/data/function/definition";
 /**
  * @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>, f: (a: A) => B): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+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, FC, K, Q, W, X, I, S, R, E, B>;
 }
 /**
  * @tsplus type fncts.FunctorOps
@@ -13,14 +13,7 @@ export interface FunctorOps {
 }
 export declare const Functor: FunctorOps;
 /**
- * @tsplus fluent fncts.Kind map
+ * @tsplus static fncts.FunctorOps as
  * @tsplus location "@fncts/base/typeclass/Functor"
  */
-export declare 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>;
-/**
- * @tsplus fluent fncts.Kind as
- * @tsplus location "@fncts/base/typeclass/Functor"
- */
-export declare 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>, b: Lazy<B>, 
-/** @tsplus auto */ F: Functor<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+export declare 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>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;

package/typeclass/FunctorWithIndex.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 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>, f: (i: HKT.IndexFor<F, K>, a: A) => B): HKT.Kind<F, K, W, Q, X, I, S, R, E, B>;
+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, FC, K, W, Q, X, I, S, R, E, B>;
 }
 /**
  * @tsplus type fncts.FunctorWithIndexOps

package/typeclass/Guard/definition.d.ts

@@ -1,4 +1,3 @@
-import { HKT } from "@fncts/typelevel/HKT";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 export interface GuardF extends Guard<any> {
 }
@@ -11,9 +10,7 @@ export declare type GuardTypeId = typeof GuardTypeId;
 export declare class Guard<A> {
     readonly is: Refinement<unknown, A>;
     readonly _typeId: GuardTypeId;
-    readonly [HKT.F]: GuardF;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Guard<HKT._A<this>>;
+    _A: () => A;
     constructor(is: Refinement<unknown, A>);
 }
 /**

package/typeclass/Monad.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 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

package/typeclass/MonadExcept.d.ts

@@ -5,7 +5,7 @@ import type { Monad } from "@fncts/base/typeclass/Monad";
 /**
  * @tsplus type fncts.MonadExcept
  */
-export interface MonadExcept<F extends HKT> extends Monad<F>, ApplicativeExcept<F> {
+export interface MonadExcept<F extends HKT, FC = HKT.None> extends Monad<F, FC>, ApplicativeExcept<F, FC> {
 }
 /**
  * @tsplus type fncts.MonadExceptOps
@@ -14,8 +14,7 @@ export interface MonadExceptOps {
 }
 export declare const MonadExcept: MonadExceptOps;
 /**
- * @tsplus fluent fncts.Kind absolve
+ * @tsplus static fncts.MonadExceptOps absolve
  * @tsplus location "@fncts/base/typeclass/MonadExcept"
  */
-export declare function absolve<F extends HKT, K, Q, W, X, I, S, R, E, E1, A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, Either<E1, A>>, 
-/** @tsplus auto */ F: MonadExcept<F>): HKT.Kind<F, K, Q, W, X, I, S, R, HKT.Mix<"E", [E, E1]>, A>;
+export declare function absolve<F extends HKT, FC = HKT.None>(F: MonadExcept<F, FC>): <K, Q, W, X, I, S, R, E, E1, A>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, Either<E1, A>>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, HKT.Mix<F, "E", [E, E1]>, A>;

package/typeclass/Nil.d.ts

@@ -2,11 +2,6 @@ import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.Nil
  */
-export interface Nil<F extends HKT> extends HKT.Typeclass<F> {
-    nil<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">>(): HKT.Kind<F, K, Q, W, X, I, S, R, E, never>;
+export interface Nil<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+    nil<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">>(): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, never>;
 }
-/**
- * @tsplus fluent fncts.Kind nil
- * @tsplus location "@fncts/base/typeclass/Nil"
- */
-export declare function nil<F extends HKT, 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">>(/** @tsplus auto */ F: Nil<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, never>;

package/typeclass/Pointed.d.ts

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-export interface Pointed<F extends HKT> extends HKT.Typeclass<F> {
-    pure<A, 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">>(a: A): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;
+export interface Pointed<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+    pure: <A, 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">>(a: A) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
 }
 /**
  * @tsplus type fncts.PointedOps
@@ -8,8 +8,3 @@ export interface Pointed<F extends HKT> extends HKT.Typeclass<F> {
 export interface PointedOps {
 }
 export declare const Pointed: PointedOps;
-/**
- * @tsplus static fncts.PointedOps pure
- * @tsplus location "@fncts/base/typeclass/Pointed"
- */
-export declare function pure<F extends HKT, C, A, 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">>(a: A, /** @tsplus auto */ F: Pointed<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;

package/typeclass/Semialign.d.ts

@@ -6,8 +6,8 @@ import type { Semigroup } from "@fncts/base/typeclass/Semigroup";
 /**
  * @tsplus type fncts.Semialign
  */
-export interface Semialign<F extends HKT> extends Functor<F> {
-    readonly alignWith: alignWith<F>;
+export interface Semialign<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
+    readonly alignWith: alignWith<F, FC>;
 }
 /**
  * @tsplus type fncts.SemialignOps
@@ -15,58 +15,52 @@ export interface Semialign<F extends HKT> extends Functor<F> {
 export interface SemialignOps {
 }
 export declare const Semialign: SemialignOps;
-export interface align<F extends HKT> {
-    <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>, fb: 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>, 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]>, These<A, B>>;
+export interface align<F extends HKT, FC = HKT.None> {
+    <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>, fb: 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>, 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]>, These<A, B>>;
 }
 /**
- * @tsplus fluent fncts.Kind align
+ * @tsplus static fncts.SemialignOps align
  * @tsplus location "@fncts/base/typeclass/Semialign"
  */
-export declare function align<F extends HKT, 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>, fb: 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>, B>, 
-/** @tsplus auto */ F: Semialign<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]>, These<A, B>>;
-export interface alignWith<F extends HKT> {
-    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, fb: 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>, B>, f: (th: These<A, B>) => C): 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]>, C>;
+export declare function align<F extends HKT, FC = HKT.None>(F: Semialign<F, FC>): <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>, fb: 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>, 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]>, These<A, B>>;
+export interface alignWith<F extends HKT, FC = HKT.None> {
+    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, fb: 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>, B>, f: (th: These<A, B>) => C): 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]>, C>;
 }
 /**
- * @tsplus fluent fncts.Kind alignWith
+ * @tsplus static fncts.SemialignOps alignWith
  * @tsplus location "@fncts/base/typeclass/Semialign"
  */
-export declare function alignWith<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, fb: 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>, B>, f: (th: These<A, B>) => C, 
-/** @tsplus auto */ F: Semialign<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]>, C>;
-export interface alignCombine<F extends HKT> {
-    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1>(self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, that: 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>, A>, S: Semigroup<A>): 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>;
+export declare function alignWith<F extends HKT, FC = HKT.None>(F: Semialign<F, FC>): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, fb: 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>, B>, f: (th: These<A, B>) => C) => 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]>, C>;
+export interface alignCombine<F extends HKT, FC = HKT.None> {
+    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, that: 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>, A>, S: Semigroup<A>): 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>;
 }
 /**
- * @tsplus fluent fncts.Kind alignCombine
+ * @tsplus static fncts.SemialignOps alignCombine
  * @tsplus location "@fncts/base/typeclass/Semialign"
  */
-export declare function alignCombine<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1>(self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, that: 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>, A>, 
-/** @tsplus auto */ F: Semialign<F>, 
-/** @tsplus auto */ S: Semigroup<A>): 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>;
-export interface padZip<F extends HKT> {
-    <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>, fb: 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>, 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]>, readonly [Maybe<A>, Maybe<B>]>;
+export declare function alignCombine<F extends HKT, FC = HKT.None>(F: Semialign<F, FC>): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, that: 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>, A>, 
+/** @tsplus auto */ S: Semigroup<A>) => 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>;
+export interface padZip<F extends HKT, FC = HKT.None> {
+    <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>, fb: 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>, 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]>, readonly [Maybe<A>, Maybe<B>]>;
 }
 /**
  * @tsplus fluent fncts.Kind padZip
  * @tsplus location "@fncts/base/typeclass/Semialign"
  */
-export declare function padZip<F extends HKT, 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>, fb: 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>, B>, 
-/** @tsplus auto */ F: Semialign<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]>, readonly [Maybe<A>, Maybe<B>]>;
-export interface padZipWith<F extends HKT> {
-    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, D>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, fb: 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>, B>, f: (_: readonly [Maybe<A>, Maybe<B>]) => D): 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]>, D>;
+export declare function padZip<F extends HKT, FC = HKT.None>(F: Semialign<F, FC>): <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>, fb: 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>, 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]>, readonly [Maybe<A>, Maybe<B>]>;
+export interface padZipWith<F extends HKT, FC = HKT.None> {
+    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, D>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, fb: 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>, B>, f: (_: readonly [Maybe<A>, Maybe<B>]) => D): 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]>, D>;
 }
 /**
- * @tsplus fluent fncts.Kind padZipWith
+ * @tsplus static fncts.SemialignOps padZipWith
  * @tsplus location "@fncts/base/typeclass/Semialign"
  */
-export declare function padZipWith<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, D>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, fb: 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>, B>, f: (_: readonly [Maybe<A>, Maybe<B>]) => D, 
-/** @tsplus auto */ F: Semialign<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]>, D>;
-export interface zipAll<F extends HKT> {
-    <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>, fb: 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>, B>, a: A, b: 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]>, readonly [A, B]>;
+export declare function padZipWith<F extends HKT, FC = HKT.None>(F: Semialign<F, FC>): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, D>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, fb: 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>, B>, f: (_: readonly [Maybe<A>, Maybe<B>]) => D) => 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]>, D>;
+export interface zipAll<F extends HKT, FC = HKT.None> {
+    <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>, fb: 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>, B>, a: A, b: 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]>, readonly [A, B]>;
 }
 /**
- * @tsplus fluent fncts.Kind zipAll
+ * @tsplus static fncts.SemialignOps zipAll
  * @tsplus location "@fncts/base/typeclass/Semialign"
  */
-export declare function zipAll<F extends HKT, 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>, fb: 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>, B>, a: A, b: B, 
-/** @tsplus auto */ F: Semialign<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]>, readonly [A, B]>;
+export declare function zipAll<F extends HKT, FC = HKT.None>(F: Semialign<F, FC>): <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>, fb: 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>, B>, a: A, b: 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]>, readonly [A, B]>;

package/typeclass/Semimonoidal.d.ts

@@ -1,6 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
-export interface Semimonoidal<F extends HKT> extends HKT.Typeclass<F> {
-    zip<K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fa: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>, fb: HKT.Kind<F, HKT.Intro<"K", K1, K2>, HKT.Intro<"Q", Q1, Q2>, HKT.Intro<"W", W1, W2>, HKT.Intro<"X", X1, X2>, HKT.Intro<"I", I1, I2>, HKT.Intro<"S", S1, S2>, HKT.Intro<"R", R1, R2>, HKT.Intro<"E", E1, E2>, B>): HKT.Kind<F, HKT.Mix<"K", [K1, K2]>, HKT.Mix<"Q", [Q1, Q2]>, HKT.Mix<"W", [W1, W2]>, HKT.Mix<"X", [X1, X2]>, HKT.Mix<"I", [I1, I2]>, HKT.Mix<"S", [S1, S2]>, HKT.Mix<"R", [R1, R2]>, HKT.Mix<"E", [E1, E2]>, readonly [A, B]>;
+import { Zipped } from "@fncts/base/data/Zipped";
+export interface Semimonoidal<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+    zip: <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]>, Zipped.Make<A, B>>;
 }
 /**
  * @tsplus type fncts.SemimonoidalOps
@@ -8,9 +9,3 @@ export interface Semimonoidal<F extends HKT> extends HKT.Typeclass<F> {
 export interface SemimonoidalOps {
 }
 export declare const Semimonoidal: SemimonoidalOps;
-/**
- * @tsplus fluent fncts.Kind zip
- * @tsplus location "@fncts/base/typeclass/Semimonoidal"
- */
-export declare function zip<F extends HKT, C, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fa: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>, fb: HKT.Kind<F, HKT.Intro<"K", K1, K2>, HKT.Intro<"Q", Q1, Q2>, HKT.Intro<"W", W1, W2>, HKT.Intro<"X", X1, X2>, HKT.Intro<"I", I1, I2>, HKT.Intro<"S", S1, S2>, HKT.Intro<"R", R1, R2>, HKT.Intro<"E", E1, E2>, B>, 
-/** @tsplus auto */ F: Semimonoidal<F>): HKT.Kind<F, HKT.Mix<"K", [K1, K2]>, HKT.Mix<"Q", [Q1, Q2]>, HKT.Mix<"W", [W1, W2]>, HKT.Mix<"X", [X1, X2]>, HKT.Mix<"I", [I1, I2]>, HKT.Mix<"S", [S1, S2]>, HKT.Mix<"R", [R1, R2]>, HKT.Mix<"E", [E1, E2]>, readonly [A, B]>;

package/typeclass/Showable/show.d.ts

@@ -31,7 +31,7 @@ export interface ShowOptions {
 }
 export declare class ShowContext extends CaseClass<ShowContextArgs> {
 }
-export declare type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, unknown, never, A>;
+export declare type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, never, never, A>;
 export declare type ShowComputation = ShowComputationZ<string>;
 export declare type ShowComputationChunk = ShowComputationZ<Conc<string>>;
 export interface ShowComputationPrimitive {

package/typeclass/Traversable.d.ts

@@ -1,13 +1,12 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Applicative, CompatibleApplicative } from "@fncts/base/typeclass/Applicative";
 import type { Foldable } from "@fncts/base/typeclass/Foldable";
 import type { Functor } from "@fncts/base/typeclass/Functor";
 /**
  * @tsplus type fncts.Traversable
  */
-export interface Traversable<F extends HKT> extends Functor<F>, Foldable<F> {
-    traverse<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>, 
-    /** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+export interface Traversable<F extends HKT, FC = HKT.None> extends Functor<F, FC>, Foldable<F, FC> {
+    traverse: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => <G extends HKT, GC = HKT.None>(G: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
 }
 /**
  * @tsplus type fncts.TraversableOps
@@ -16,16 +15,26 @@ export interface TraversableOps {
 }
 export declare const Traversable: TraversableOps;
 /**
- * @tsplus fluent fncts.Kind traverse
+ * @tsplus static fncts.TraversableOps makeTraverse
  * @tsplus location "@fncts/base/typeclass/Traversable"
  */
-export declare function traverse<F extends HKT, G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>, 
-/** @tsplus auto */ F: Traversable<F>, 
-/** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+export declare function mkTraverse_<F extends HKT, FC = HKT.None>(): (i: <K, Q, W, X, I, S, R, E, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    K: K;
+    Q: Q;
+    W: W;
+    X: X;
+    I: I;
+    S: S;
+    R: R;
+    E: E;
+}) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => (G: Applicative<HKT.F<G>>) => (f: (a: A) => HKT.FK1<G, B>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>) => Traversable<F, FC>["traverse"];
 /**
- * @tsplus fluent fncts.Kind sequence
+ * @tsplus static fncts.TraversableOps sequence
  * @tsplus location "@fncts/base/typeclass/Traversable"
  */
-export declare function sequence<F extends HKT, G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A>(ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, A>>, 
-/** @tsplus auto */ F: Traversable<F>, 
-/** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>>;
+export declare function sequence<F extends HKT, FC>(F: Traversable<F, FC>): <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => <G extends HKT, GC = HKT.None>(G: CompatibleApplicative<G, GC, A>) => [A] extends [
+    HKT.Kind<G, GC, infer KG, infer QG, infer WG, infer XG, infer IG, infer SG, infer RG, infer EG, infer B>
+] ? HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XG, IF, SF, RF, EF, B>> : never;

package/typeclass/TraversableWithIndex.d.ts

@@ -6,9 +6,8 @@ import type { Traversable } from "@fncts/base/typeclass/Traversable";
 /**
  * @tsplus type fncts.TraversableWithIndex
  */
-export interface TraversableWithIndex<F extends HKT> extends FunctorWithIndex<F>, FoldableWithIndex<F>, Traversable<F> {
-    traverseWithIndex<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, KF, QF, WF, XF, IF, SF, RF, EF, A, B>(ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (i: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>, 
-    /** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+export interface TraversableWithIndex<F extends HKT, FC = HKT.None> extends FunctorWithIndex<F, FC>, FoldableWithIndex<F, FC>, Traversable<F, FC> {
+    traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => <G extends HKT, GC = HKT.None>(G: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
 }
 /**
  * @tsplus type fncts.TraversableWithIndexOps
@@ -16,6 +15,20 @@ export interface TraversableWithIndex<F extends HKT> extends FunctorWithIndex<F>
 export interface TraversableWithIndexOps {
 }
 export declare const TraversableWithIndex: TraversableWithIndexOps;
-export declare function traverseWithIndex<F extends HKT, G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, KF, QF, WF, XF, IF, SF, RF, EF, A, B>(ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (i: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>, 
-/** @tsplus auto */ F: TraversableWithIndex<F>, 
-/** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+/**
+ * @tsplus static fncts.TraversableWithIndexOps makeTraverseWithIndex
+ * @tsplus location "@fncts/base/typeclass/TraversableWithIndex"
+ */
+export declare function mkTraverseWithIndex_<F extends HKT, FC = HKT.None>(): (i: <K, Q, W, X, I, S, R, E, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    K: HKT.OrFix<FC, "K", K>;
+    Q: Q;
+    W: W;
+    X: X;
+    I: I;
+    S: S;
+    R: R;
+    E: E;
+}) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => (G: Applicative<HKT.F<G>>) => (f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, a: A) => HKT.FK1<G, B>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>) => TraversableWithIndex<F, FC>["traverseWithIndex"];

package/typeclass/Witherable.d.ts

@@ -7,11 +7,9 @@ import type { Traversable } from "@fncts/base/typeclass/Traversable";
 /**
  * @tsplus type fncts.Witherable
  */
-export interface Witherable<F extends HKT> extends Filterable<F>, Traversable<F> {
-    wither<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>, 
-    /** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-    wilt<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, B1, A, B>(wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>, 
-    /** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B1>]>;
+export interface Witherable<F extends HKT, FC = HKT.None> extends Filterable<F, FC>, Traversable<F, FC> {
+    wither: <KF, QF, WF, XF, IF, SF, RF, EF, A>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => <G extends HKT, GC = HKT.None>(G: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+    wilt: <KF, QF, WF, XF, IF, SF, RF, EF, A>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => <G extends HKT, GC = HKT.None>(G: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B, B1>(f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]>;
 }
 /**
  * @tsplus type fncts.WitherableOps
@@ -20,19 +18,7 @@ export interface WitherableOps {
 }
 export declare const Witherable: WitherableOps;
 /**
- * @tsplus fluent fncts.Kind wither
+ * @tsplus static fncts.WitherableOps filterA
  * @tsplus location "@fncts/base/typeclass/Witherable"
  */
-export declare function wither<F extends HKT, G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>, 
-/** @tsplus auto */ F: Witherable<F>, 
-/** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-export declare function wilt<F extends HKT, G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, B1, A, B>(wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>, 
-/** @tsplus auto */ F: Witherable<F>, 
-/** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B1>]>;
-/**
- * @tsplus fluent fncts.Kind filterA
- * @tsplus location "@fncts/base/typeclass/Witherable"
- */
-export declare function filterA<F extends HKT, G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(fa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, AF>, p: (a: AF) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, boolean>, 
-/** @tsplus auto */ F: Witherable<F>, 
-/** @tsplus auto */ G: Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+export declare function filterA<F extends HKT, FC = HKT.None>(F: Witherable<F, FC>): <KF, QF, WF, XF, IF, SF, RF, EF, AF>(fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>) => <G extends HKT, GC = HKT.None>(G: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG>(p: (a: AF) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, boolean>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;