@fncts/base 0.0.1 → 0.0.4

package/typeclass/MonadExcept.d.ts

@@ -1,14 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Either } from "@fncts/base/data/Either/definition";
-import type { ApplicativeExceptMin } from "@fncts/base/typeclass/ApplicativeExcept";
-import type { MonadMin } from "@fncts/base/typeclass/Monad";
-import { ApplicativeExcept } from "@fncts/base/typeclass/ApplicativeExcept";
-import { Monad } from "@fncts/base/typeclass/Monad";
+import type { ApplicativeExcept } from "@fncts/base/typeclass/ApplicativeExcept";
+import type { Monad } from "@fncts/base/typeclass/Monad";
 /**
  * @tsplus type fncts.MonadExcept
  */
-export interface MonadExcept<F extends HKT.CovariantE, FC = HKT.None> extends Monad<F, FC>, ApplicativeExcept<F, FC> {
-    readonly absolve: absolve<F, FC>;
+export interface MonadExcept<F> extends Monad<F>, ApplicativeExcept<F> {
 }
 /**
  * @tsplus type fncts.MonadExceptOps
@@ -16,17 +13,9 @@ export interface MonadExcept<F extends HKT.CovariantE, FC = HKT.None> extends Mo
 export interface MonadExceptOps {
 }
 export declare const MonadExcept: MonadExceptOps;
-export declare type MonadExceptMin<F extends HKT.CovariantE, FC = HKT.None> = MonadMin<F, FC> & ApplicativeExceptMin<F, FC>;
 /**
- * @tsplus static fncts.MonadExceptOps __call
+ * @tsplus fluent fncts.Kind absolve
  * @tsplus location "@fncts/base/typeclass/MonadExcept"
  */
-export declare function mkMonadExcept<F extends HKT.CovariantE, FC = HKT.None>(F: MonadExceptMin<F, FC>): MonadExcept<F, FC>;
-export interface absolve<F extends HKT, FC = HKT.None> {
-    <K, Q, W, X, I, S, R, E, E1, A>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, Either<HKT.OrFix<FC, "E", E1>, A>>): HKT.Kind<F, FC, K, Q, W, X, I, S, R, HKT.Mix<F, "E", [E, E1]>, A>;
-}
-/**
- * @tsplus static fncts.MonadExceptOps absolveF
- * @tsplus location "@fncts/base/typeclass/MonadExcept"
- */
-export declare function absolveF<F extends HKT.CovariantE, FC = HKT.None>(F: MonadExceptMin<F, FC>): absolve<F, FC>;
+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>;

package/typeclass/Monoid.d.ts

@@ -1,4 +1,5 @@
-import type { SemigroupMin } from "@fncts/base/typeclass/Semigroup";
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 import { Semigroup } from "@fncts/base/typeclass/Semigroup";
 /**
  * @tsplus type fncts.Monoid
@@ -12,7 +13,7 @@ export interface Monoid<A> extends Semigroup<A> {
 export interface MonoidOps {
 }
 export declare const Monoid: MonoidOps;
-export declare type MonoidMin<A> = SemigroupMin<A> & {
+export declare type MonoidMin<A> = Semigroup<A> & {
     readonly nat: A;
 };
 /**
@@ -20,3 +21,24 @@ export declare type MonoidMin<A> = SemigroupMin<A> & {
  * @tsplus location "@fncts/base/typeclass/Monoid"
  */
 export declare function mkMonoid<A>(F: MonoidMin<A>): Monoid<A>;
+/**
+ * @tsplus derive fncts.Monoid lazy
+ * @tsplus location "@fncts/base/typeclass/Monoid"
+ */
+export declare function deriveLazy<A>(fn: (_: Monoid<A>) => Monoid<A>): Monoid<A>;
+/**
+ * @tsplus derive fncts.Monoid<_> 20
+ * @tsplus location "@fncts/base/typeclass/Monoid"
+ */
+export declare function deriveStruct<A extends Record<string, any>>(...args: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+        requiredFields: {
+            [K in RequiredKeys<A>]: Monoid<A[K]>;
+        }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [] : [
+        optionalFields: {
+            [K in OptionalKeys<A>]: Monoid<NonNullable<A[K]>>;
+        }
+    ])
+] : never): Monoid<A>;

package/typeclass/Nil.d.ts

@@ -2,12 +2,11 @@ import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.Nil
  */
-export interface Nil<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
-    readonly nil: nil<F, FC>;
-}
-export declare type NilMin<F extends HKT, FC = HKT.None> = {
-    readonly nil: nil<F, FC>;
-};
-export interface nil<F extends HKT, FC = HKT.None> {
-    <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>;
+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>;
 }
+/**
+ * @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/Ord/definition.d.ts

@@ -1,12 +1,10 @@
-import type { equals_ } from "@fncts/base/typeclass/Eq";
 import type { Ordering } from "@fncts/base/typeclass/Ordering";
 import { Eq } from "@fncts/base/typeclass/Eq";
 /**
  * @tsplus type fncts.Ord
  */
 export interface Ord<A> extends Eq<A> {
-    readonly compare_: compare_<A>;
-    readonly compare: compare<A>;
+    readonly compare: (x: A, y: A) => Ordering;
 }
 /**
  * @tsplus type fncts.OrdOps
@@ -14,18 +12,8 @@ export interface Ord<A> extends Eq<A> {
 export interface OrdOps {
 }
 export declare const Ord: OrdOps;
-export declare type OrdMin<A> = {
-    compare_: compare_<A>;
-    equals_: equals_<A>;
-};
 /**
  * @tsplus static fncts.OrdOps __call
  * @tsplus location "@fncts/base/typeclass/Ord/definition"
  */
-export declare function mkOrd<A>(O: OrdMin<A>): Ord<A>;
-export interface compare_<A> {
-    (x: A, y: A): Ordering;
-}
-export interface compare<A> {
-    (y: A): (x: A) => Ordering;
-}
+export declare function mkOrd<A>(O: Ord<A>): Ord<A>;

package/typeclass/Pointed.d.ts

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

@@ -1,25 +1,13 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { These } from "@fncts/base/data/These/definition";
+import { These } from "@fncts/base/data/These";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
+import type { Functor } from "@fncts/base/typeclass/Functor";
 import type { Semigroup } from "@fncts/base/typeclass/Semigroup";
-import { Functor } from "@fncts/base/typeclass/Functor";
 /**
  * @tsplus type fncts.Semialign
  */
-export interface Semialign<F extends HKT, C = HKT.None> extends Functor<F, C> {
-    readonly alignWith_: alignWith_<F, C>;
-    readonly alignWith: alignWith<F, C>;
-    readonly align_: align_<F, C>;
-    readonly align: align<F, C>;
-    readonly alignCombine_: alignCombine_<F, C>;
-    readonly alignCombine: alignCombine<F, C>;
-    readonly padZip_: padZip_<F, C>;
-    readonly padZip: padZip<F, C>;
-    readonly padZipWith_: padZipWith_<F, C>;
-    readonly padZipWith: padZipWith<F, C>;
-    readonly zipAll_: zipAll_<F, C>;
-    readonly zipAll: zipAll<F, C>;
+export interface Semialign<F extends HKT> extends Functor<F> {
+    readonly alignWith: alignWith<F>;
 }
 /**
  * @tsplus type fncts.SemialignOps
@@ -27,58 +15,58 @@ export interface Semialign<F extends HKT, C = HKT.None> extends Functor<F, C> {
 export interface SemialignOps {
 }
 export declare const Semialign: SemialignOps;
-export declare type SemialignMin<F extends HKT, C = HKT.None> = ({
-    readonly alignWith_: alignWith_<F, C>;
-} | {
-    readonly align_: align_<F, C>;
-}) & FunctorMin<F, C>;
+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>>;
+}
 /**
- * @tsplus static fncts.SemialignOps __call
+ * @tsplus fluent fncts.Kind align
  * @tsplus location "@fncts/base/typeclass/Semialign"
  */
-export declare function mkSemialign<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): Semialign<F, C>;
-export interface align_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, fb: HKT.Kind<F, C, 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, C, 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 align<F extends HKT, C = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, B>(fb: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>): <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, HKT.Intro<F, "K", K1, K>, HKT.Intro<F, "Q", Q1, Q>, HKT.Intro<F, "W", W1, W>, HKT.Intro<F, "X", X1, X>, HKT.Intro<F, "I", I1, I>, HKT.Intro<F, "S", S1, S>, HKT.Intro<F, "R", R1, R>, HKT.Intro<F, "E", E1, E>, A>) => HKT.Kind<F, C, HKT.Mix<F, "K", [K1, K]>, HKT.Mix<F, "Q", [Q1, Q]>, HKT.Mix<F, "W", [W1, W]>, HKT.Mix<F, "X", [X1, X]>, HKT.Mix<F, "I", [I1, I]>, HKT.Mix<F, "S", [S1, S]>, HKT.Mix<F, "R", [R1, R]>, HKT.Mix<F, "E", [E1, E]>, These<A, B>>;
-}
-export interface alignWith_<F extends HKT, TC = 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, TC, K, Q, W, X, I, S, R, E, A>, fb: HKT.Kind<F, TC, 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, TC, 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 alignWith<F extends HKT, TC = HKT.None> {
-    <A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(fb: HKT.Kind<F, TC, K1, Q1, W1, X1, I1, S1, R1, E1, B>, f: (th: These<A, B>) => C): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, TC, HKT.Intro<F, "K", K1, K>, HKT.Intro<F, "Q", Q1, Q>, HKT.Intro<F, "W", W1, W>, HKT.Intro<F, "X", X1, X>, HKT.Intro<F, "I", I1, I>, HKT.Intro<F, "S", S1, S>, HKT.Intro<F, "R", R1, R>, HKT.Intro<F, "E", E1, E>, A>) => HKT.Kind<F, TC, HKT.Mix<F, "K", [K1, K]>, HKT.Mix<F, "Q", [Q1, Q]>, HKT.Mix<F, "W", [W1, W]>, HKT.Mix<F, "X", [X1, X]>, HKT.Mix<F, "I", [I1, I]>, HKT.Mix<F, "S", [S1, S]>, HKT.Mix<F, "R", [R1, R]>, HKT.Mix<F, "E", [E1, E]>, C>;
-}
-export declare function alignWithF_<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): alignWith_<F, C>;
-export interface alignCombine_<F extends HKT, C = HKT.None> {
-    <A>(S: Semigroup<A>): <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1>(fa1: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, fa2: HKT.Kind<F, C, 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>) => HKT.Kind<F, C, 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 alignCombine<F extends HKT, C = HKT.None> {
-    <A>(S: Semigroup<A>): <K1, Q1, W1, X1, I1, S1, R1, E1>(fb: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, A>) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, HKT.Intro<F, "K", K1, K>, HKT.Intro<F, "Q", Q1, Q>, HKT.Intro<F, "W", W1, W>, HKT.Intro<F, "X", X1, X>, HKT.Intro<F, "I", I1, I>, HKT.Intro<F, "S", S1, S>, HKT.Intro<F, "R", R1, R>, HKT.Intro<F, "E", E1, E>, A>) => HKT.Kind<F, C, HKT.Mix<F, "K", [K1, K]>, HKT.Mix<F, "Q", [Q1, Q]>, HKT.Mix<F, "W", [W1, W]>, HKT.Mix<F, "X", [X1, X]>, HKT.Mix<F, "I", [I1, I]>, HKT.Mix<F, "S", [S1, S]>, HKT.Mix<F, "R", [R1, R]>, HKT.Mix<F, "E", [E1, E]>, A>;
+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 alignCombineF_<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): alignCombine_<F, C>;
-export declare function alignCombineF<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): alignCombine<F, C>;
-export interface padZip_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, fb: HKT.Kind<F, C, 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, C, 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 padZip<F extends HKT, C = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, B>(fb: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>): <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, HKT.Intro<F, "K", K1, K>, HKT.Intro<F, "Q", Q1, Q>, HKT.Intro<F, "W", W1, W>, HKT.Intro<F, "X", X1, X>, HKT.Intro<F, "I", I1, I>, HKT.Intro<F, "S", S1, S>, HKT.Intro<F, "R", R1, R>, HKT.Intro<F, "E", E1, E>, A>) => HKT.Kind<F, C, HKT.Mix<F, "K", [K1, K]>, HKT.Mix<F, "Q", [Q1, Q]>, HKT.Mix<F, "W", [W1, W]>, HKT.Mix<F, "X", [X1, X]>, HKT.Mix<F, "I", [I1, I]>, HKT.Mix<F, "S", [S1, S]>, HKT.Mix<F, "R", [R1, R]>, HKT.Mix<F, "E", [E1, E]>, readonly [Maybe<A>, Maybe<B>]>;
-}
-export declare function padZipF_<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): padZip_<F, C>;
-export declare function padZipF<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): padZip<F, C>;
-export interface padZipWith_<F extends HKT, C = 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, C, K, Q, W, X, I, S, R, E, A>, fb: HKT.Kind<F, C, 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, C, 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 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 interface padZipWith<F extends HKT, C = HKT.None> {
-    <A, K1, Q1, W1, X1, I1, S1, R1, E1, B, D>(fb: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>, f: (_: readonly [Maybe<A>, Maybe<B>]) => D): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, HKT.Intro<F, "K", K1, K>, HKT.Intro<F, "Q", Q1, Q>, HKT.Intro<F, "W", W1, W>, HKT.Intro<F, "X", X1, X>, HKT.Intro<F, "I", I1, I>, HKT.Intro<F, "S", S1, S>, HKT.Intro<F, "R", R1, R>, HKT.Intro<F, "E", E1, E>, A>) => HKT.Kind<F, C, HKT.Mix<F, "K", [K1, K]>, HKT.Mix<F, "Q", [Q1, Q]>, HKT.Mix<F, "W", [W1, W]>, HKT.Mix<F, "X", [X1, X]>, HKT.Mix<F, "I", [I1, I]>, HKT.Mix<F, "S", [S1, S]>, HKT.Mix<F, "R", [R1, R]>, HKT.Mix<F, "E", [E1, E]>, D>;
+/**
+ * @tsplus fluent fncts.Kind 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 padZipWithF_<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): padZipWith_<F, C>;
-export declare function padZipWithF<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): padZipWith<F, C>;
-export interface zipAll_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, fb: HKT.Kind<F, C, 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, C, 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 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 interface zipAll<F extends HKT, C = HKT.None> {
-    <A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(fb: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>, a: A, b: B): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, HKT.Intro<F, "K", K1, K>, HKT.Intro<F, "Q", Q1, Q>, HKT.Intro<F, "W", W1, W>, HKT.Intro<F, "X", X1, X>, HKT.Intro<F, "I", I1, I>, HKT.Intro<F, "S", S1, S>, HKT.Intro<F, "R", R1, R>, HKT.Intro<F, "E", E1, E>, A>) => HKT.Kind<F, C, HKT.Mix<F, "K", [K1, K]>, HKT.Mix<F, "Q", [Q1, Q]>, HKT.Mix<F, "W", [W1, W]>, HKT.Mix<F, "X", [X1, X]>, HKT.Mix<F, "I", [I1, I]>, HKT.Mix<F, "S", [S1, S]>, HKT.Mix<F, "R", [R1, R]>, HKT.Mix<F, "E", [E1, E]>, readonly [A, B]>;
+/**
+ * @tsplus fluent fncts.Kind 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 zipAllF_<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): zipAll_<F, C>;
-export declare function zipAllF<F extends HKT, C = HKT.None>(F: SemialignMin<F, C>): zipAll<F, C>;
+/**
+ * @tsplus fluent fncts.Kind 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]>;

package/typeclass/Semigroup/definition.d.ts

@@ -1,4 +1,5 @@
-import type { Closure, combine_ } from "@fncts/base/typeclass/Closure";
+import type { Closure } from "@fncts/base/typeclass/Closure";
+import { mkClosure } from "@fncts/base/typeclass/Closure";
 /**
  * @tsplus type fncts.Semigroup
  */
@@ -10,11 +11,8 @@ export interface Semigroup<A> extends Closure<A> {
 export interface SemigroupOps {
 }
 export declare const Semigroup: SemigroupOps;
-export declare type SemigroupMin<A> = {
-    combine_: combine_<A>;
-};
 /**
  * @tsplus static fncts.SemigroupOps __call
  * @tsplus location "@fncts/base/typeclass/Semigroup/definition"
  */
-export declare const mkSemigroup: <A>(F: SemigroupMin<A>) => Semigroup<A>;
+export declare const mkSemigroup: typeof mkClosure;

package/typeclass/Semigroup/derivations.d.ts

@@ -0,0 +1,25 @@
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
+/**
+ * @tsplus derive fncts.Semigroup lazy
+ * @tsplus location "@fncts/base/typeclass/Semigroup/derivations"
+ */
+export declare function deriveLazy<A>(fn: (_: Semigroup<A>) => Semigroup<A>): Semigroup<A>;
+/**
+ * @tsplus derive fncts.Semigroup<_> 20
+ * @tsplus static fncts.SemigroupOps deriveStruct
+ * @tsplus location "@fncts/base/typeclass/Semigroup/derivations"
+ */
+export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+        requiredFields: {
+            [K in RequiredKeys<A>]: Semigroup<A[K]>;
+        }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [] : [
+        optionalFields: {
+            [K in OptionalKeys<A>]: Semigroup<NonNullable<A[K]>>;
+        }
+    ])
+] : never): Semigroup<A>;

package/typeclass/Semimonoidal.d.ts

@@ -1,11 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
-export interface Semimonoidal<F extends HKT, C = HKT.None> extends HKT.Typeclass<F, C> {
-    readonly zip_: zip_<F, C>;
-    readonly zip: zip<F, C>;
+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]>;
 }
-export declare type SemimonoidalMin<F extends HKT, C = HKT.None> = {
-    readonly zip_: zip_<F, C>;
-};
 /**
  * @tsplus type fncts.SemimonoidalOps
  */
@@ -13,13 +9,8 @@ export interface SemimonoidalOps {
 }
 export declare const Semimonoidal: SemimonoidalOps;
 /**
- * @tsplus static fncts.SemimonoidalOps __call
+ * @tsplus fluent fncts.Kind zip
  * @tsplus location "@fncts/base/typeclass/Semimonoidal"
  */
-export declare function mkSemimonoidal<F extends HKT, C = HKT.None>(F: SemimonoidalMin<F, C>): Semimonoidal<F, C>;
-export interface zip_<F extends HKT, C = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fa: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, A>, fb: HKT.Kind<F, C, 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, C, 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]>, readonly [A, B]>;
-}
-export interface zip<F extends HKT, C = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, B>(fb: HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>): <K2, Q2, W2, X2, I2, S2, R2, E2, A>(fa: HKT.Kind<F, C, 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, C, 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]>, readonly [A, B]>;
-}
+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/Traversable.d.ts

@@ -1,16 +1,13 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { Applicative, CompatibleApplicative } from "@fncts/base/typeclass/Applicative";
-import type { FoldableMin } from "@fncts/base/typeclass/Foldable";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-import { Foldable } from "@fncts/base/typeclass/Foldable";
-import { Functor } from "@fncts/base/typeclass/Functor";
+import type { Applicative } 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, FC = HKT.None> extends Functor<F, FC>, Foldable<F, FC> {
-    readonly traverse_: traverse_<F, FC>;
-    readonly traverse: traverse<F, FC>;
-    readonly sequence: sequence<F, FC>;
+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>>;
 }
 /**
  * @tsplus type fncts.TraversableOps
@@ -18,54 +15,17 @@ export interface Traversable<F extends HKT, FC = HKT.None> extends Functor<F, FC
 export interface TraversableOps {
 }
 export declare const Traversable: TraversableOps;
-export declare type TraversableMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & FoldableMin<F, FC> & {
-    readonly traverse_: traverse_<F, FC>;
-};
 /**
- * @tsplus static fncts.TraversableOps __call
+ * @tsplus fluent fncts.Kind traverse
  * @tsplus location "@fncts/base/typeclass/Traversable"
  */
-export declare function mkTraversable<F extends HKT, FC = HKT.None>(F: TraversableMin<F, FC>): Traversable<F, FC>;
-export interface traverse_<F extends HKT, FC = HKT.None> {
-    <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>, 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>>;
-}
-export interface traverseSelf<F extends HKT, FC = HKT.None> {
-    <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>(A: 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>>;
-}
-export interface traverse<F extends HKT, FC = HKT.None> {
-    <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B>(f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => <KF, QF, WF, XF, IF, SF, RF, EF>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => 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>>;
-}
-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;
-}) => (G: Applicative<HKT.F<G>>) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, f: (a: A) => HKT.FK1<G, B>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>) => traverse_<F, FC>;
-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;
-}) => (G: Applicative<HKT.F<G>>) => (f: (a: A) => HKT.FK1<G, B>) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>) => traverse<F, FC>;
-export interface sequence<F extends HKT, FC = HKT.None> {
-    <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, A>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>>;
-}
-export interface sequenceSelf<F extends HKT, FC = HKT.None> {
-    <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <G extends HKT, GC = HKT.None>(A: 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, XF, IF, SF, RF, EF, B>> : never;
-}
+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>>;
+/**
+ * @tsplus fluent fncts.Kind 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>>;

package/typeclass/TraversableWithIndex.d.ts

@@ -1,17 +1,14 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import type { Applicative } from "@fncts/base/typeclass/Applicative";
-import type { FoldableWithIndexMin } from "@fncts/base/typeclass/FoldableWithIndex";
-import type { FunctorWithIndexMin } from "@fncts/base/typeclass/FunctorWithIndex";
-import type { TraversableMin } from "@fncts/base/typeclass/Traversable";
-import { FoldableWithIndex } from "@fncts/base/typeclass/FoldableWithIndex";
-import { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
-import { Traversable } from "@fncts/base/typeclass/Traversable";
+import type { FoldableWithIndex } from "@fncts/base/typeclass/FoldableWithIndex";
+import type { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
+import type { Traversable } from "@fncts/base/typeclass/Traversable";
 /**
  * @tsplus type fncts.TraversableWithIndex
  */
-export interface TraversableWithIndex<F extends HKT, FC = HKT.None> extends FunctorWithIndex<F, FC>, FoldableWithIndex<F, FC>, Traversable<F, FC> {
-    readonly traverseWithIndex_: traverseWithIndex_<F, FC>;
-    readonly traverseWithIndex: traverseWithIndex<F, FC>;
+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>>;
 }
 /**
  * @tsplus type fncts.TraversableWithIndexOps
@@ -19,46 +16,6 @@ export interface TraversableWithIndex<F extends HKT, FC = HKT.None> extends Func
 export interface TraversableWithIndexOps {
 }
 export declare const TraversableWithIndex: TraversableWithIndexOps;
-export declare type TraversableWithIndexMin<F extends HKT, FC = HKT.None> = FunctorWithIndexMin<F, FC> & FoldableWithIndexMin<F, FC> & TraversableMin<F, FC> & {
-    readonly traverseWithIndex_: traverseWithIndex_<F, FC>;
-};
-/**
- * @tsplus static fncts.TraversableWithIndexOps __call
- * @tsplus location "@fncts/base/typeclass/TraversableWithIndex"
- */
-export declare function mkTraversableWithIndex<F extends HKT, FC = HKT.None>(F: TraversableWithIndexMin<F, FC>): TraversableWithIndex<F, FC>;
-export interface traverseWithIndex_<F extends HKT, FC = HKT.None> {
-    <G extends HKT, CG = HKT.None>(A: Applicative<G, CG>): <KG, QG, WG, XG, IG, SG, RG, EG, KF, QF, WF, XF, IF, SF, RF, EF, A, B>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, B>) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-export interface traverseWithIndex<F extends HKT, FC = HKT.None> {
-    <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, KF, A, B>(f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => <QF, WF, XF, IF, SF, RF, EF>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => 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>>;
-}
-export interface traverseWithIndexSelf<F extends HKT, FC = HKT.None> {
-    <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>(A: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", 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>>;
-}
-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: K;
-    Q: Q;
-    W: W;
-    X: X;
-    I: I;
-    S: S;
-    R: R;
-    E: E;
-}) => (A: Applicative<HKT.F<G>>) => (f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, a: A) => HKT.FK1<G, B>) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>) => traverseWithIndex_<F, FC>;
-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;
-}) => (G: Applicative<HKT.F<G>>) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, 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>>) => traverseWithIndex_<F, FC>;
+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>>;