@fncts/base 0.0.3 → 0.0.6

package/typeclass/Foldable.d.ts

@@ -4,13 +4,9 @@ import type { Monoid } from "@fncts/base/typeclass/Monoid";
 /**
  * @tsplus type fncts.Foldable
  */
-export interface Foldable<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
-    readonly foldLeft_: foldLeft_<F, FC>;
-    readonly foldLeft: foldLeft<F, FC>;
-    readonly foldRight_: foldRight_<F, FC>;
-    readonly foldRight: foldRight<F, FC>;
-    readonly foldMap_: foldMap_<F, FC>;
-    readonly foldMap: foldMap<F, FC>;
+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>;
 }
 /**
  * @tsplus type fncts.FoldableOps
@@ -18,30 +14,22 @@ export interface Foldable<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F,
 export interface FoldableOps {
 }
 export declare const Foldable: FoldableOps;
-export declare type FoldableMin<F extends HKT, FC = HKT.None> = {
-    readonly foldLeft_: foldLeft_<F, FC>;
-    readonly foldRight_: foldRight_<F, FC>;
-};
 /**
- * @tsplus static fncts.FoldableOps __call
+ * @tsplus fluent fncts.Kind foldLeft
  * @tsplus location "@fncts/base/typeclass/Foldable"
  */
-export declare function mkFoldable<F extends HKT, FC = HKT.None>(F: FoldableMin<F, FC>): Foldable<F, FC>;
-export interface foldLeft_<F extends HKT, FC = HKT.None> {
-    <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;
-}
-export interface foldLeft<F extends HKT, FC = HKT.None> {
-    <A, B>(b: B, f: (b: B, a: A) => B): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => B;
-}
-export interface foldRight_<F extends HKT, FC = HKT.None> {
-    <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>;
-}
-export interface foldRight<F extends HKT, FC = HKT.None> {
-    <A, B>(b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => Eval<B>;
-}
-export interface foldMap_<F extends HKT, C = HKT.None> {
-    <M>(M: Monoid<M>): <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (a: A) => M) => M;
-}
-export interface foldMap<F extends HKT, C = HKT.None> {
-    <M>(M: Monoid<M>): <A>(f: (a: A) => M) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => M;
-}
+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;

package/typeclass/FoldableWithIndex.d.ts

@@ -1,18 +1,13 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Eval } from "@fncts/base/control/Eval/definition";
-import type { FoldableMin } from "@fncts/base/typeclass/Foldable";
+import type { Foldable } from "@fncts/base/typeclass/Foldable";
 import type { Monoid } from "@fncts/base/typeclass/Monoid";
-import { Foldable } from "@fncts/base/typeclass/Foldable";
 /**
  * @tsplus type fncts.FoldableWithIndex
  */
-export interface FoldableWithIndex<F extends HKT, FC = HKT.None> extends Foldable<F, FC> {
-    readonly foldLeftWithIndex_: foldLeftWithIndex_<F, FC>;
-    readonly foldLeftWithIndex: foldLeftWithIndex<F, FC>;
-    readonly foldRightWithIndex_: foldRightWithIndex_<F, FC>;
-    readonly foldRightWithIndex: foldRightWithIndex<F, FC>;
-    readonly foldMapWithIndex_: foldMapWithIndex_<F, FC>;
-    readonly foldMapWithIndex: foldMapWithIndex<F, FC>;
+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>;
 }
 /**
  * @tsplus type fncts.FoldableWithIndexOps
@@ -20,30 +15,22 @@ export interface FoldableWithIndex<F extends HKT, FC = HKT.None> extends Foldabl
 export interface FoldableWithIndexOps {
 }
 export declare const FoldableWithIndex: FoldableWithIndexOps;
-export declare type FoldableWithIndexMin<F extends HKT, FC = HKT.None> = FoldableMin<F, FC> & {
-    readonly foldLeftWithIndex_: foldLeftWithIndex_<F, FC>;
-    readonly foldRightWithIndex_: foldRightWithIndex_<F, FC>;
-};
 /**
- * @tsplus static fncts.FoldableWithIndexOps __call
+ * @tsplus fluent fncts.Kind foldLeftWithIndex
  * @tsplus location "@fncts/base/typeclass/FoldableWithIndex"
  */
-export declare function mkFoldableWithIndex<F extends HKT, FC = HKT.None>(F: FoldableWithIndexMin<F, FC>): FoldableWithIndex<F, FC>;
-export interface foldLeftWithIndex_<F extends HKT, FC = HKT.None> {
-    <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, HKT.OrFix<FC, "K", K>>, b: B, a: A) => B): B;
-}
-export interface foldLeftWithIndex<F extends HKT, FC = HKT.None> {
-    <K, A, B>(b: B, f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, b: B, a: A) => B): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => B;
-}
-export interface foldRightWithIndex_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, b: Eval<B>, f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A, b: Eval<B>) => Eval<B>): Eval<B>;
-}
-export interface foldRightWithIndex<F extends HKT, C = HKT.None> {
-    <K, A, B>(b: Eval<B>, f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A, b: Eval<B>) => Eval<B>): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => Eval<B>;
-}
-export interface foldMapWithIndex_<F extends HKT, C = HKT.None> {
-    <M>(M: Monoid<M>): <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (k: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => M) => M;
-}
-export interface foldMapWithIndex<F extends HKT, C = HKT.None> {
-    <M>(M: Monoid<M>): <K, A>(f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => M) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => M;
-}
+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;

package/typeclass/Functor.d.ts

@@ -3,11 +3,8 @@ import { Lazy } from "@fncts/base/data/function/definition";
 /**
  * @tsplus type fncts.Functor
  */
-export interface Functor<F extends HKT, C = HKT.None> extends HKT.Typeclass<F, C> {
-    readonly map_: map_<F, C>;
-    readonly map: map<F, C>;
-    readonly as_: as_<F, C>;
-    readonly as: as<F, C>;
+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>;
 }
 /**
  * @tsplus type fncts.FunctorOps
@@ -15,23 +12,15 @@ export interface Functor<F extends HKT, C = HKT.None> extends HKT.Typeclass<F, C
 export interface FunctorOps {
 }
 export declare const Functor: FunctorOps;
-export declare type FunctorMin<F extends HKT, C = HKT.None> = {
-    readonly map_: map_<F, C>;
-};
 /**
- * @tsplus static fncts.FunctorOps __call
+ * @tsplus fluent fncts.Kind map
  * @tsplus location "@fncts/base/typeclass/Functor"
  */
-export declare function mkFunctor<F extends HKT, C = HKT.None>(F: FunctorMin<F, C>): Functor<F, C>;
-export interface map_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (a: A) => B): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
-}
-export interface map<F extends HKT, C = HKT.None> {
-    <A, B>(f: (a: A) => B): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
-}
-export interface as_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, b: Lazy<B>): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
-}
-export interface as<F extends HKT, C = HKT.None> {
-    <B>(b: Lazy<B>): <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
-}
+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>;

package/typeclass/FunctorWithIndex.d.ts

@@ -1,27 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-import { Functor } from "@fncts/base/typeclass/Functor";
-export interface FunctorWithIndex<F extends HKT, C = HKT.None> extends Functor<F, C> {
-    readonly mapWithIndex_: mapWithIndex_<F, C>;
-    readonly mapWithIndex: mapWithIndex<F, C>;
+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 declare type FunctorWithIndexMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
-    readonly mapWithIndex_: mapWithIndex_<F, FC>;
-};
 /**
  * @tsplus type fncts.FunctorWithIndexOps
  */
 export interface FunctorWithIndexOps {
 }
 export declare const FunctorWithIndex: FunctorWithIndexOps;
-/**
- * @tsplus static fncts.FunctorWithIndexOps __call
- * @tsplus location "@fncts/base/typeclass/FunctorWithIndex"
- */
-export declare function mkFunctorWithIndex<F extends HKT, C = HKT.None>(F: FunctorWithIndexMin<F, C>): FunctorWithIndex<F, C>;
-export interface mapWithIndex_<F extends HKT, C = HKT.None> {
-    <K, W, Q, X, I, S, R, E, A, B>(fa: HKT.Kind<F, C, K, W, Q, X, I, S, R, E, A>, f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => B): HKT.Kind<F, C, K, W, Q, X, I, S, R, E, B>;
-}
-export interface mapWithIndex<F extends HKT, C = HKT.None> {
-    <K, A, B>(f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => B): <W, Q, X, I, S, R, E>(fa: HKT.Kind<F, C, K, W, Q, X, I, S, R, E, A>) => HKT.Kind<F, C, K, W, Q, X, I, S, R, E, B>;
-}

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