@fncts/base 0.0.2 → 0.0.5

package/typeclass/Guard/api.d.ts

@@ -0,0 +1,20 @@
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Guard } from "@fncts/base/typeclass/Guard/definition";
+/**
+ * @tsplus fluent fncts.Guard __call
+ * @tsplus location "@fncts/base/typeclass/Guard/api"
+ */
+export declare function is<A>(self: Guard<A>, u: unknown): u is A;
+/**
+ * @tsplus fluent fncts.Guard refine
+ * @tsplus operator fncts.Guard &&
+ * @tsplus location "@fncts/base/typeclass/Guard/api"
+ */
+export declare function refine<A, B extends A>(self: Guard<A>, refinement: Refinement<A, B>): Guard<B>;
+export declare function refine<A>(self: Guard<A>, predicate: Predicate<A>): Guard<A>;
+/**
+ * @tsplus fluent fncts.Guard assert
+ * @tsplus location "@fncts/base/typeclass/Guard/api"
+ */
+export declare function assert<A>(self: Guard<A>, u: unknown): asserts u is A;

package/typeclass/Guard/definition.d.ts

@@ -0,0 +1,22 @@
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+export interface GuardF extends Guard<any> {
+}
+export declare const GuardTypeId: unique symbol;
+export declare type GuardTypeId = typeof GuardTypeId;
+/**
+ * @tsplus type fncts.Guard
+ * @tsplus companion fncts.GuardOps
+ */
+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>>;
+    constructor(is: Refinement<unknown, A>);
+}
+/**
+ * @tsplus static fncts.GuardOps __call
+ * @tsplus location "@fncts/base/typeclass/Guard/definition"
+ */
+export declare function makeGuard<A>(refinement: Refinement<unknown, A>): Guard<A>;

package/typeclass/Guard/derivations.d.ts

@@ -0,0 +1,36 @@
+import { Guard } from "@fncts/base/typeclass/Guard";
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+/**
+ * @tsplus derive fncts.Guard lazy
+ * @tsplus location "@fncts/base/typeclass/Guard/derivations"
+ */
+export declare function deriveLazy<A>(f: (_: Guard<A>) => Guard<A>): Guard<A>;
+/**
+ * @tsplus derive fncts.Guard<_> 20
+ * @tsplus location "@fncts/base/typeclass/Guard/derivations"
+ */
+export declare function deriveLiteral<A extends string | number | boolean>(...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Guard<_> 20
+ * @tsplus location "@fncts/base/typeclass/Guard/derivations"
+ */
+export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+        requiredFields: {
+            [k in RequiredKeys<A>]: Guard<A[k]>;
+        }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [] : [
+        optionalFields: {
+            [k in OptionalKeys<A>]: Guard<NonNullable<A[k]>>;
+        }
+    ])
+] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Guard<|> 30
+ * @tsplus location "@fncts/base/typeclass/Guard/derivations"
+ */
+export declare function deriveUnion<A extends unknown[]>(...members: {
+    [K in keyof A]: Guard<A[K]>;
+}): Guard<A[number]>;

package/typeclass/Guard.d.ts

@@ -0,0 +1,2 @@
+export * from "./Guard/api.js";
+export * from "./Guard/definition.js";

package/typeclass/HashEq.d.ts

@@ -1,4 +1,3 @@
-import type { EqMin } from "./Eq.js";
 import type { Hash } from "./Hash.js";
 import { Eq } from "./Eq.js";
 /**
@@ -12,7 +11,7 @@ export interface HashEq<A> extends Hash<A>, Eq<A> {
 export interface HashEqOps {
 }
 export declare const HashEq: HashEqOps;
-export declare type HashEqMin<A> = Hash<A> & EqMin<A>;
+export declare type HashEqMin<A> = Hash<A> & Eq<A>;
 /**
  * @tsplus static fncts.HashEqOps __call
  * @tsplus location "@fncts/base/typeclass/HashEq"

package/typeclass/Monad.d.ts

@@ -1,9 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
-import type { ChainMin } from "@fncts/base/typeclass/Chain";
-import { Applicative } from "@fncts/base/typeclass/Applicative";
-import { FlatMap } from "@fncts/base/typeclass/Chain";
-export interface Monad<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, FlatMap<F, FC> {
+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> {
 }
 /**
  * @tsplus type fncts.MonadOps
@@ -11,9 +9,3 @@ export interface Monad<F extends HKT, FC = HKT.None> extends Applicative<F, FC>,
 export interface MonadOps {
 }
 export declare const Monad: MonadOps;
-export declare type MonadMin<F extends HKT, FC = HKT.None> = ApplicativeMin<F, FC> & ChainMin<F, FC>;
-/**
- * @tsplus static fncts.MonadOps __call
- * @tsplus location "@fncts/base/typeclass/Monad"
- */
-export declare function mkMonad<F extends HKT, FC = HKT.None>(F: MonadMin<F, FC>): Monad<F, FC>;

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