@fncts/base 0.0.3 → 0.0.6

package/data/These/constructors.d.ts

@@ -1,4 +1,5 @@
-import { These } from "@fncts/base/data/These/definition";
+import { These } from "@fncts/base/data/These";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * @tsplus static fncts.TheseOps left
  * @tsplus static fncts.These.Left __call
@@ -17,3 +18,8 @@ export declare function right<E = never, A = never>(a: A): These<E, A>;
  * @tsplus location "@fncts/base/data/These/constructors"
  */
 export declare function both<E = never, A = never>(e: E, a: A): These<E, A>;
+/**
+ * @tsplus static fncts.TheseOps rightOrBoth
+ * @tsplus location "@fncts/base/data/These/constructors"
+ */
+export declare function rightOrBoth<E = never, A = never>(e: Maybe<E>, a: A): These<E, A>;

package/data/These/definition.d.ts

@@ -43,3 +43,8 @@ export declare type These<E, A> = Left<E> | Right<A> | Both<E, A>;
 export interface TheseOps {
 }
 export declare const These: TheseOps;
+/**
+ * @tsplus static fncts.TheseOps isThese
+ * @tsplus location "@fncts/base/data/These/definition"
+ */
+export declare function isThese(u: unknown): u is These<unknown, unknown>;

package/data/These/destructors.d.ts

@@ -1,6 +1,32 @@
-import { These } from "@fncts/base/data/These/definition";
+import { These } from "@fncts/base/data/These";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus getter fncts.These right
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function unsafeGetRight<E, A>(self: These<E, A>): A | undefined;
+/**
+ * @tsplus getter fncts.These left
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function unsafeGetLeft<E, A>(self: These<E, A>): E | undefined;
+/**
+ * @tsplus getter fncts.These rightMaybe
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function rightMaybe<E, A>(self: These<E, A>): Maybe<A>;
+/**
+ * @tsplus getter fncts.These leftMaybe
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function leftMaybe<E, A>(self: These<E, A>): Maybe<E>;
 /**
  * @tsplus fluent fncts.These match
  * @tsplus location "@fncts/base/data/These/destructors"
  */
 export declare function match_<E, A, B, C, D>(self: These<E, A>, left: (e: E) => B, right: (a: A) => C, both: (e: E, a: A) => D): B | C | D;
+/**
+ * @tsplus fluent fncts.These match2
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function match2<E, A, B, C>(self: These<E, A>, left: (e: E) => B, right: (e: Maybe<E>, a: A) => C): B | C;

package/data/These/instances.d.ts

@@ -0,0 +1,13 @@
+import { These } from "@fncts/base/data/These";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+/**
+ * @tsplus derive fncts.Guard[fncts.These]<_> 10
+ * @tsplus location "@fncts/base/data/These/instances"
+ */
+export declare function deriveGuard<A extends These<any, any>>(...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.These]<_> 10
+ * @tsplus location "@fncts/base/data/These/instances"
+ */
+export declare function deriveDecoder<A extends These<any, any>>(...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never): Decoder<A>;

package/data/These.d.ts

@@ -1,3 +1,4 @@
+export * from "./These/api.js";
 export * from "./These/constructors.js";
 export * from "./These/definition.js";
 export * from "./These/destructors.js";

package/data/bigint/definition.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    /**
+     * @tsplus type fncts.BigInt
+     */
+    interface BigInt {
+    }
+    /**
+     * @tsplus type fncts.BigIntOps
+     */
+    interface BigIntConstructor {
+    }
+}
+export {};

package/data/bigint/instances.d.ts

@@ -0,0 +1,7 @@
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus static fncts.BigIntOps Guard
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/bigint/instances"
+ */
+export declare const Guard: P.Guard<bigint>;

package/data/bigint.d.ts

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

package/data/boolean/definition.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    /**
+     * @tsplus type fncts.Boolean
+     */
+    export interface Boolean {
+    }
+    /**
+     * @tsplus type fncts.BooleanOps
+     */
+    export interface BooleanConstructor {
+    }
+}
+export {};

package/data/boolean/instances.d.ts

@@ -0,0 +1,7 @@
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus static fncts.BooleanOps Guard
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/boolean/instances"
+ */
+export declare const Guard: P.Guard<boolean>;

package/data/boolean.d.ts

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

package/data/number/instances.d.ts

@@ -1,11 +1,19 @@
 import * as P from "../../typeclass.js";
 /**
  * @tsplus static fncts.NumberOps Eq
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/number/instances"
  */
 export declare const Eq: P.Eq<number>;
 /**
  * @tsplus static fncts.NumberOps Ord
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/number/instances"
  */
 export declare const Ord: P.Ord<number>;
+/**
+ * @tsplus static fncts.NumberOps Guard
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/number/instances"
+ */
+export declare const Guard: P.Guard<number>;

package/data/object/instances.d.ts

@@ -0,0 +1,7 @@
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus implicit
+ * @tsplus static fncts.globalOps Guard
+ * @tsplus location "@fncts/base/data/object/instances"
+ */
+export declare const Guard: P.Guard<{}>;

package/data/string/instances.d.ts

@@ -1,21 +1,31 @@
 import * as P from "../../typeclass.js";
 /**
  * @tsplus static fncts.StringOps Eq
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/string/instances"
  */
 export declare const Eq: P.Eq<string>;
 /**
  * @tsplus static fncts.StringOps Semigroup
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/string/instances"
  */
 export declare const Semigroup: P.Semigroup<string>;
 /**
  * @tsplus static fncts.StringOps Monoid
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/string/instances"
  */
 export declare const Monoid: P.Monoid<string>;
 /**
  * @tsplus static fncts.StringOps Ord
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/string/instances"
  */
 export declare const Ord: P.Ord<string>;
+/**
+ * @tsplus static fncts.StringOps Guard
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/string/instances"
+ */
+export declare const Guard: P.Guard<string>;

package/internal/Stack.d.ts

@@ -7,6 +7,7 @@ export declare class Stack<A> {
     constructor(node?: Node<A> | undefined);
     clone(): Stack<A>;
     get hasNext(): boolean;
+    get isEmpty(): boolean;
     peek(): A | undefined;
     pop(): A | undefined;
     push(value: A): void;

package/json/EitherJson.d.ts

@@ -0,0 +1,24 @@
+import { Decoder } from "@fncts/base/data/Decoder";
+export interface RightJson<A> {
+    readonly _tag: "Right";
+    readonly right: A;
+}
+export interface LeftJson<E> {
+    readonly _tag: "Left";
+    readonly left: E;
+}
+/**
+ * @tsplus type fncts.EitherJson
+ */
+export declare type EitherJson<E, A> = LeftJson<E> | RightJson<A>;
+/**
+ * @tsplus type fncts.EitherJsonOps
+ */
+export interface EitherJsonOps {
+}
+export declare const EitherJson: EitherJsonOps;
+/**
+ * @tsplus static fncts.EitherJsonOps getDecoder
+ * @tsplus location "@fncts/base/json/EitherJson"
+ */
+export declare function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<EitherJson<E, A>>;

package/json/MaybeJson.d.ts

@@ -0,0 +1,23 @@
+import { Decoder } from "@fncts/base/data/Decoder";
+export interface NothingJson {
+    readonly _tag: "Nothing";
+}
+export interface JustJson<A> {
+    readonly _tag: "Just";
+    readonly value: A;
+}
+/**
+ * @tsplus type fncts.MaybeJson
+ */
+export declare type MaybeJson<A> = NothingJson | JustJson<A>;
+/**
+ * @tsplus type fncts.MaybeJsonOps
+ */
+export interface MaybeJsonOps {
+}
+export declare const MaybeJson: MaybeJsonOps;
+/**
+ * @tsplus static fncts.MaybeJsonOps getDecoder
+ * @tsplus location "@fncts/base/json/MaybeJson"
+ */
+export declare function getDecoder<A>(value: Decoder<A>): Decoder<MaybeJson<A>>;

package/json/TheseJson.d.ts

@@ -0,0 +1,26 @@
+import { Decoder } from "@fncts/base/data/Decoder";
+export interface LeftJson<E> {
+    readonly _tag: "Left";
+    readonly left: E;
+}
+export interface RightJson<A> {
+    readonly _tag: "Right";
+    readonly right: A;
+}
+export interface BothJson<E, A> {
+    readonly _tag: "Both";
+    readonly left: E;
+    readonly right: A;
+}
+export declare type TheseJson<E, A> = LeftJson<E> | RightJson<A> | BothJson<E, A>;
+/**
+ * @tsplus type fncts.TheseJsonOps
+ */
+export interface TheseJsonOps {
+}
+export declare const TheseJson: TheseJsonOps;
+/**
+ * @tsplus static fncts.TheseJsonOps getDecoder
+ * @tsplus location "@fncts/base/json/TheseJson"
+ */
+export declare function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<TheseJson<E, A>>;

package/optics/Traversal/api/fromTraversable.d.ts

@@ -5,4 +5,4 @@ import { PTraversal } from "@fncts/base/optics/Traversal/definition";
  * @tsplus static fncts.optics.PTraversalOps fromTraversable
  * @tsplus location "@fncts/base/optics/Traversal/api/fromTraversable"
  */
-export declare function fromTraversable<T extends HKT, C = HKT.None>(T: P.Traversable<T, C>): <A, B, K = HKT.Low<T, "K">, Q = HKT.Low<T, "Q">, W = HKT.Low<T, "W">, X = HKT.Low<T, "X">, I = HKT.Low<T, "I">, S = HKT.Low<T, "S">, R = HKT.Low<T, "R">, E = HKT.Low<T, "E">, K1 = HKT.Low<T, "K">, Q1 = HKT.Low<T, "Q">, W1 = HKT.Low<T, "W">, X1 = HKT.Low<T, "X">, I1 = HKT.Low<T, "I">, S1 = HKT.Low<T, "S">, R1 = HKT.Low<T, "R">, E1 = HKT.Low<T, "E">>() => PTraversal<HKT.Kind<T, C, K, Q, W, X, I, S, R, E, A>, HKT.Kind<T, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>, A, B>;
+export declare function fromTraversable<T extends HKT>(T: P.Traversable<T>): <A, B, K = any, Q = unknown, W = never, X = never, I = any, S = any, R = unknown, E = never>() => PTraversal<import("@fncts/typelevel/HKT").HKT.Kind<T, K, Q, W, X, I, S, R, E, A>, import("@fncts/typelevel/HKT").HKT.Kind<T, K, Q, W, X, I, S, R, E, B>, A, B>;

package/optics/Traversal/definition.d.ts

@@ -6,11 +6,12 @@ import { PSetter } from "@fncts/base/optics/Setter";
  * @tsplus type fncts.optics.PTraversal
  */
 export interface PTraversal<S, T, A, B> extends PSetter<S, T, A, B>, Fold<S, A> {
-    readonly modifyA_: modifyA_<S, T, A, B>;
-    readonly modifyA: modifyA<S, T, A, B>;
+    modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(s: S, f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>, 
+    /** @tsplus auto */ F: Applicative<F>): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
 }
 export interface PTraversalMin<S, T, A, B> {
-    readonly modifyA_: modifyA_<S, T, A, B>;
+    modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(s: S, f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>, 
+    /** @tsplus auto */ F: Applicative<F>): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
 }
 /**
  * @tsplus type fncts.optics.PTraversalOps
@@ -38,9 +39,3 @@ export interface TraversalOps extends PTraversalOps {
  * @tsplus location "@fncts/base/optics/Traversal/definition"
  */
 export declare function mkTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A>;
-export interface modifyA_<S, T, A, B> {
-    <F extends HKT, C = HKT.None>(F: Applicative<F, C>): <K, Q, W, X, I, _S, R, E>(s: S, f: (a: A) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, B>) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, T>;
-}
-export interface modifyA<S, T, A, B> {
-    <F extends HKT, C = HKT.None>(F: Applicative<F, C>): <K, Q, W, X, I, _S, R, E>(f: (a: A) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, B>) => (s: S) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, T>;
-}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "dependencies": {
-    "@fncts/typelevel": "0.0.3"
+    "@fncts/typelevel": "0.0.6"
   },
   "exports": {
     "./*": {

package/typeclass/Align.d.ts

@@ -1,11 +1,10 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { Nil, NilMin } from "@fncts/base/typeclass/Nil";
-import type { SemialignMin } from "@fncts/base/typeclass/Semialign";
-import { Semialign } from "@fncts/base/typeclass/Semialign";
+import type { Nil } from "@fncts/base/typeclass/Nil";
+import type { Semialign } from "@fncts/base/typeclass/Semialign";
 /**
  * @tsplus type fncts.Align
  */
-export interface Align<F extends HKT, FC = HKT.None> extends Semialign<F, FC>, Nil<F, FC> {
+export interface Align<F extends HKT> extends Semialign<F>, Nil<F> {
 }
 /**
  * @tsplus type fncts.AlignOps
@@ -13,9 +12,3 @@ export interface Align<F extends HKT, FC = HKT.None> extends Semialign<F, FC>, N
 export interface AlignOps {
 }
 export declare const Align: AlignOps;
-export declare type AlignMin<F extends HKT, FC = HKT.None> = SemialignMin<F, FC> & NilMin<F, FC>;
-/**
- * @tsplus static fncts.AlignOps __call
- * @tsplus location "@fncts/base/typeclass/Align"
- */
-export declare function mkAlign<F extends HKT, FC = HKT.None>(F: AlignMin<F, FC>): Align<F, FC>;

package/typeclass/Alt.d.ts

@@ -1,12 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-import { Functor } from "@fncts/base/typeclass/Functor";
+import { Lazy } from "@fncts/base/data/function/definition";
+import type { Functor } from "@fncts/base/typeclass/Functor";
 /**
  * @tsplus type fncts.Alt
  */
-export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-    readonly alt_: alt_<F, FC>;
-    readonly alt: alt<F, FC>;
+export interface Alt<F extends HKT> extends Functor<F> {
+    alt<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>, that: Lazy<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>, HKT.Intro<"A", A, 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]>, HKT.Mix<"A", [A, B]>>;
 }
 /**
  * @tsplus type fncts.AltOps
@@ -14,17 +13,5 @@ export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
 export interface AltOps {
 }
 export declare const Alt: AltOps;
-export declare type AltMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
-    readonly alt_: alt_<F, FC>;
-};
-/**
- * @tsplus static fncts.AltOps __call
- * @tsplus location "@fncts/base/typeclass/Alt"
- */
-export declare function mkAlt<F extends HKT, C = HKT.None>(F: AltMin<F, C>): Alt<F, C>;
-export interface alt<F extends HKT, C = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, B>(that: () => 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>, HKT.Intro<F, "A", B, 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]>, HKT.Mix<F, "A", [B, A]>>;
-}
-export interface alt_<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>, that: () => 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>, HKT.Intro<F, "A", A, 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]>, HKT.Mix<F, "A", [A, B]>>;
-}
+export declare function alt<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, that: Lazy<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>, HKT.Intro<"A", A, B>>>, 
+/** @tsplus auto */ F: Alt<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]>, HKT.Mix<"A", [A, B]>>;

package/typeclass/Alternative.d.ts

@@ -1,13 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { AltMin } from "@fncts/base/typeclass/Alt";
-import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
-import type { Nil, NilMin } from "@fncts/base/typeclass/Nil";
-import { Alt } from "@fncts/base/typeclass/Alt";
-import { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Alt } from "@fncts/base/typeclass/Alt";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Nil } from "@fncts/base/typeclass/Nil";
 /**
  * @tsplus type fncts.Alternative
  */
-export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Nil<F, FC>, Alt<F, FC> {
+export interface Alternative<F extends HKT> extends Applicative<F>, Nil<F>, Alt<F> {
 }
 /**
  * @tsplus type fncts.AlternativeOps
@@ -15,9 +13,3 @@ export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F
 export interface AlternativeOps {
 }
 export declare const Alternative: AlternativeOps;
-export declare type AlternativeMin<F extends HKT, FC = HKT.None> = ApplicativeMin<F, FC> & NilMin<F, FC> & AltMin<F, FC>;
-/**
- * @tsplus static fncts.AlternativeOps __call
- * @tsplus location "@fncts/base/typeclass/Alternative"
- */
-export declare function mkAlternative<F extends HKT, C = HKT.None>(F: AlternativeMin<F, C>): Alternative<F, C>;

package/typeclass/Applicative.d.ts

@@ -1,9 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { ApplyMin } from "@fncts/base/typeclass/Apply";
-import type { PointedMin } from "@fncts/base/typeclass/Pointed";
-import { Apply } from "@fncts/base/typeclass/Apply";
-import { Pointed } from "@fncts/base/typeclass/Pointed";
-export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>, Pointed<F, FC> {
+import type { Apply } from "@fncts/base/typeclass/Apply";
+import type { Pointed } from "@fncts/base/typeclass/Pointed";
+export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {
 }
 /**
  * @tsplus type fncts.ApplicativeOps
@@ -11,10 +9,3 @@ export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>,
 export interface ApplicativeOps {
 }
 export declare const Applicative: ApplicativeOps;
-export declare type ApplicativeMin<F extends HKT, FC = HKT.None> = ApplyMin<F, FC> & PointedMin<F, FC>;
-/**
- * @tsplus static fncts.ApplicativeOps __call
- * @tsplus location "@fncts/base/typeclass/Applicative"
- */
-export declare function mkApplicative<F extends HKT, FC = HKT.None>(F: ApplicativeMin<F, FC>): Applicative<F, FC>;
-export declare type CompatibleApplicative<F extends HKT, C, A> = Applicative<F, C> & ([A] extends [HKT.Kind<F, any, any, any, any, any, any, any, any, any, any>] ? unknown : ["invalid Applicative instance for", A]);

package/typeclass/ApplicativeExcept.d.ts

@@ -1,18 +1,13 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { HKT } from "@fncts/typelevel/HKT";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
-import type { Fail, FailMin } from "@fncts/base/typeclass/Fail";
-import { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Fail } from "@fncts/base/typeclass/Fail";
 /**
  * @tsplus type fncts.ApplicativeExcept
  */
-export interface ApplicativeExcept<F extends HKT.CovariantE, C = HKT.None> extends Applicative<F, C>, Fail<F, C> {
-    readonly catchAll_: CatchAllFn_<F, C>;
-    readonly catchAll: CatchAllFn<F, C>;
-    readonly catchJust_: CatchJustFn_<F, C>;
-    readonly catchJust: CatchJustFn<F, C>;
-    readonly either: EitherFn<F, C>;
+export interface ApplicativeExcept<F extends HKT> extends Applicative<F>, Fail<F> {
+    catchAll<K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (e: E) => 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>, A1>): 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]>, E1, A | A1>;
 }
 /**
  * @tsplus type fncts.ApplicativeExceptOps
@@ -20,41 +15,21 @@ export interface ApplicativeExcept<F extends HKT.CovariantE, C = HKT.None> exten
 export interface ApplicativeExceptOps {
 }
 export declare const ApplicativeExcept: ApplicativeExceptOps;
-export declare type ApplicativeExceptMin<F extends HKT.CovariantE, C = HKT.None> = ApplicativeMin<F, C> & FailMin<F, C> & {
-    readonly catchAll_: CatchAllFn_<F, C>;
-};
-/**
- * @tsplus static fncts.ApplicativeExceptOps __call
- * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
- */
-export declare function mkApplicativeExcept<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): ApplicativeExcept<F, C>;
-export interface CatchAllFn_<F extends HKT.CovariantE, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (e: HKT.OrFix<C, "E", E>) => 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>, A1>): 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]>, E1, A | A1>;
-}
-export interface CatchAllFn<F extends HKT.CovariantE, C = HKT.None> {
-    <E, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(f: (e: HKT.OrFix<C, "E", E>) => HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, A1>): <K, Q, W, X, I, S, R, 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]>, E1, A | A1>;
-}
-export interface CatchJustFn_<F extends HKT.CovariantE, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (e: HKT.OrFix<C, "E", E>) => Maybe<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>, A1>>): 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 | A1>;
-}
 /**
- * @tsplus static fncts.ApplicativeExceptOps catchJustF_
+ * @tsplus fluent fncts.Kind catchAll
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare function catchJustF_<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): CatchJustFn_<F, C>;
-export interface CatchJustFn<F extends HKT, C = HKT.None> {
-    <E, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(f: (e: HKT.OrFix<C, "E", E>) => Maybe<HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, A1>>): <K, Q, W, X, I, S, R, 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]>, A | A1>;
-}
+export declare function catchAll<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (e: E) => 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>, A1>, 
+/** @tsplus auto */ F: ApplicativeExcept<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]>, E1, A | A1>;
 /**
- * @tsplus static fncts.ApplicativeExceptOps catchJustF
+ * @tsplus fluent fncts.Kind catchJust
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare function catchJustF<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): CatchJustFn<F, C>;
-export interface EitherFn<F extends HKT, C = HKT.None> {
-    <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, never, Either<HKT.OrFix<C, "E", E>, A>>;
-}
+export declare function catchJust<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (e: E) => Maybe<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>, A1>>, 
+/** @tsplus auto */ F: ApplicativeExcept<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]>, A | A1>;
 /**
- * @tsplus static fncts.ApplicativeExceptOps eitherF
+ * @tsplus fluent fncts.Kind either
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare function eitherF<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): EitherFn<F, C>;
+export declare function either<F extends HKT, K, Q, W, X, I, S, R, E, A>(self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, 
+/** @tsplus auto */ F: ApplicativeExcept<F>): HKT.Kind<F, K, Q, W, X, I, S, R, never, Either<E, A>>;