@fncts/base 0.0.1

package/typeclass/Semialign.d.ts

@@ -0,0 +1,84 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { These } from "@fncts/base/data/These/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { FunctorMin } 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>;
+}
+/**
+ * @tsplus type fncts.SemialignOps
+ */
+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>;
+/**
+ * @tsplus static fncts.SemialignOps __call
+ * @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 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>;
+}
+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>;
+}
+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]>;
+}
+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]>;
+}
+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>;

package/typeclass/Semigroup/api.d.ts

@@ -0,0 +1,12 @@
+import type { Ord } from "@fncts/base/typeclass/Ord";
+import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
+/**
+ * @tsplus static fncts.SemigroupOps min
+ * @tsplus location "@fncts/base/typeclass/Semigroup/api"
+ */
+export declare function min<A>(O: Ord<A>): Semigroup<A>;
+/**
+ * @tsplus static fncts.SemigroupOps max
+ * @tsplus location "@fncts/base/typeclass/Semigroup/api"
+ */
+export declare function max<A>(O: Ord<A>): Semigroup<A>;

package/typeclass/Semigroup/definition.d.ts

@@ -0,0 +1,20 @@
+import type { Closure, combine_ } from "@fncts/base/typeclass/Closure";
+/**
+ * @tsplus type fncts.Semigroup
+ */
+export interface Semigroup<A> extends Closure<A> {
+}
+/**
+ * @tsplus type fncts.SemigroupOps
+ */
+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>;

package/typeclass/Semigroup.d.ts

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

package/typeclass/Semimonoidal.d.ts

@@ -0,0 +1,25 @@
+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 declare type SemimonoidalMin<F extends HKT, C = HKT.None> = {
+    readonly zip_: zip_<F, C>;
+};
+/**
+ * @tsplus type fncts.SemimonoidalOps
+ */
+export interface SemimonoidalOps {
+}
+export declare const Semimonoidal: SemimonoidalOps;
+/**
+ * @tsplus static fncts.SemimonoidalOps __call
+ * @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]>;
+}

package/typeclass/Showable/definition.d.ts

@@ -0,0 +1,17 @@
+import type { ShowComputationExternal } from "@fncts/base/typeclass/Showable/show";
+export declare const showable: unique symbol;
+/**
+ * @tsplus static fncts.builtin.SymbolOps showable
+ * @tsplus location "@fncts/base/typeclass/Showable/definition"
+ */
+export declare const _showable: typeof showable;
+export interface Showable {
+    [showable]: ShowComputationExternal;
+}
+export declare function isShowable(value: unknown): value is Showable;
+/**
+ * @tsplus type ShowableOps
+ */
+export interface ShowableOps {
+}
+export declare const Showable: ShowableOps;

package/typeclass/Showable/show.d.ts

@@ -0,0 +1,54 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Z } from "@fncts/base/control/Z/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { StyleFunction } from "@fncts/base/typeclass/Showable/styles";
+export interface ShowContextArgs {
+    readonly stylize: StyleFunction;
+    readonly circular: HashMap<unknown, number>;
+    readonly seen: Array<unknown>;
+    readonly indentationLevel: number;
+    readonly maxArrayLength: number;
+    readonly breakLength: number;
+    readonly compact: number | boolean;
+    readonly colors: boolean;
+    readonly depth: number;
+    readonly showHidden: boolean;
+    readonly maxStringLength: number;
+    readonly currentDepth: number;
+    readonly recurseTimes: number;
+    readonly budget: Record<number, number>;
+}
+export interface ShowOptions {
+    readonly maxArrayLength: number;
+    readonly maxStringLength: number;
+    readonly breakLength: number;
+    readonly compact: number | boolean;
+    readonly colors: boolean;
+    readonly depth: number;
+    readonly showHidden: boolean;
+    readonly indentationLevel: number;
+}
+export declare class ShowContext extends CaseClass<ShowContextArgs> {
+}
+export declare type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, unknown, never, A>;
+export declare type ShowComputation = ShowComputationZ<string>;
+export declare type ShowComputationChunk = ShowComputationZ<Conc<string>>;
+export interface ShowComputationPrimitive {
+    readonly _tag: "Primitive";
+    readonly computation: ShowComputation;
+}
+export declare function showComputationPrimitive(computation: ShowComputation): ShowComputationPrimitive;
+export interface ShowComputationComplex {
+    readonly _tag: "Complex";
+    extrasType?: number;
+    base?: ShowComputation;
+    indices?: ShowComputationChunk;
+    keys?: ShowComputationChunk;
+    braces?: [string, string];
+}
+export declare function showComputationComplex(args: Omit<ShowComputationComplex, "_tag">): ShowComputationComplex;
+export declare type ShowComputationExternal = ShowComputationPrimitive | ShowComputationComplex;
+export declare function show(value: unknown): string;
+export declare function showWithOptions(value: unknown, options: Partial<ShowOptions>): string;
+export declare function _show(value: unknown): ShowComputation;
+export declare function showProperty(value: object, key: PropertyKey, type: number, desc?: PropertyDescriptor): ShowComputation;

package/typeclass/Showable/styles.d.ts

@@ -0,0 +1,8 @@
+export declare type Style = "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "bold" | "italic" | "underline";
+export declare type ShowGroup = "string" | "number" | "boolean" | "bigint" | "special" | "undefined" | "null" | "symbol" | "date" | "regexp" | "module" | "dim";
+export declare type ShowStyle = Record<ShowGroup, (s: string) => string>;
+export declare const defaultShowStyle: ShowStyle;
+export declare type StyleFunction = (str: string, group: ShowGroup) => string;
+export declare type GetStyle = (group: ShowGroup) => string;
+export declare function stylizeWithColor(str: string, group: ShowGroup): string;
+export declare function stylizeNoColor(str: string, _: ShowGroup): string;

package/typeclass/Showable/util.d.ts

@@ -0,0 +1,38 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+export declare const addBacktickQuotes: (s: string) => string;
+export declare const addSingleQuotes: (s: string) => string;
+export declare const addDoubleQuotes: (s: string) => string;
+export declare const ansiPattern: string;
+export declare const ansi: RegExp;
+export declare const meta: string[];
+export declare const strEscapeSequencesRegExp: RegExp;
+export declare const strEscapeSequencesReplacer: RegExp;
+export declare const strEscapeSequencesRegExpSingle: RegExp;
+export declare const strEscapeSequencesReplacerSingle: RegExp;
+export declare const colorRegExp: RegExp;
+export declare const classRegExp: RegExp;
+export declare const stripCommentsRegExp: RegExp;
+export declare const keyStrRegExp: RegExp;
+export declare const numberRegExp: RegExp;
+export declare function escapeFn(str: string): string;
+export declare const OBJECT_TYPE = 0;
+export declare const ARRAY_TYPE = 1;
+export declare const ARRAY_EXTRAS_TYPE = 2;
+export declare const PROTO_TYPE = 3;
+export declare function hex(arrayBuffer: ArrayBuffer): string;
+export declare function pluralize(n: number): string;
+export declare function getKeys(value: object, showHidden?: boolean): Array<PropertyKey>;
+export declare function getStringWidth(input: string, removeControlChars?: boolean): number;
+/**
+ * Returns true if the character represented by a given
+ * Unicode code point is full-width. Otherwise returns false.
+ */
+export declare function isFullWidthCodePoint(code: number): boolean;
+export declare function isZeroWidthCodePoint(code: number): boolean;
+export declare function getConstructorName(value: object): [string | null, Conc<PropertyKey>];
+export declare function getPrototypeProperties(main: object, obj: object): Conc<PropertyKey>;
+export declare function getPrefix(constructor: string | null, tag: string, fallback: string, size?: string): string;
+export declare function getFunctionBase(value: Function, constructor: string | null, tag: string): string;
+export declare function getClassBase(value: Function, constructor: string | null, tag: string): string;
+export declare function addQuotes(str: string, quotes: number): string;
+export declare function strEscape(str: string): string;

package/typeclass/Showable.d.ts

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

package/typeclass/Traversable.d.ts

@@ -0,0 +1,71 @@
+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";
+/**
+ * @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>;
+}
+/**
+ * @tsplus type fncts.TraversableOps
+ */
+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 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;
+}

package/typeclass/TraversableWithIndex.d.ts

@@ -0,0 +1,64 @@
+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";
+/**
+ * @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>;
+}
+/**
+ * @tsplus type fncts.TraversableWithIndexOps
+ */
+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>;

package/typeclass/Witherable.d.ts

@@ -0,0 +1,98 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { FilterableMin } from "@fncts/base/typeclass/Filterable";
+import type { TraversableMin } from "@fncts/base/typeclass/Traversable";
+import { Filterable } from "@fncts/base/typeclass/Filterable";
+import { Traversable } from "@fncts/base/typeclass/Traversable";
+/**
+ * @tsplus type fncts.Witherable
+ */
+export interface Witherable<F extends HKT, FC = HKT.None> extends Filterable<F, FC>, Traversable<F, FC> {
+    readonly wilt_: wilt_<F, FC>;
+    readonly wilt: wilt<F, FC>;
+    readonly wither_: wither_<F, FC>;
+    readonly wither: wither<F, FC>;
+}
+/**
+ * @tsplus type fncts.WitherableOps
+ */
+export interface WitherableOps {
+}
+export declare const Witherable: WitherableOps;
+export declare type WitherableMin<F extends HKT, FC = HKT.None> = FilterableMin<F, FC> & TraversableMin<F, FC> & {
+    readonly wilt_: wilt_<F, FC>;
+    readonly wither_: wither_<F, FC>;
+};
+/**
+ * @tsplus static fncts.WitherableOps __call
+ * @tsplus location "@fncts/base/typeclass/Witherable"
+ */
+export declare function mkWitherable<F extends HKT, FC = HKT.None>(F: WitherableMin<F, FC>): Witherable<F, FC>;
+export interface wither<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, Maybe<B>>) => <KF, QF, WF, XF, IF, SF, RF, EF>(wa: 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 wither_<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>(wa: 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, Maybe<B>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+}
+export interface witherSelf<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: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+}
+export declare function mkWither<F extends HKT, FC = HKT.None>(): (i: <FK, FQ, FW, FX, FI, FS, FR, FE, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    FK: FK;
+    FQ: FQ;
+    FW: FW;
+    FX: FX;
+    FI: FI;
+    FS: FS;
+    FR: FR;
+    FE: FE;
+}) => (A: Applicative<HKT.F<G>>) => (f: (a: A) => HKT.FK1<G, Maybe<B>>) => (wa: HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, A>) => HKT.FK1<G, HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, B>>) => wither<F, FC>;
+export declare function mkWither_<F extends HKT, FC = HKT.None>(): (i: <FK, FQ, FW, FX, FI, FS, FR, FE, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    FK: FK;
+    FQ: FQ;
+    FW: FW;
+    FX: FX;
+    FI: FI;
+    FS: FS;
+    FR: FR;
+    FE: FE;
+}) => (A: Applicative<HKT.F<G>>) => (wa: HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, A>, f: (a: A) => HKT.FK1<G, Maybe<B>>) => HKT.FK1<G, HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, B>>) => wither_<F, FC>;
+export interface wilt<F extends HKT, FC = HKT.None> {
+    <G extends HKT, CG = HKT.None>(A: Applicative<G, CG>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B1>(f: (a: A) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>) => <KF, QF, WF, XF, IF, SF, RF, EF>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]>;
+}
+export interface wilt_<F extends HKT, FC = HKT.None> {
+    <G extends HKT, CG = HKT.None>(A: Applicative<G, CG>): <KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, B1, A, B>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (a: A) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]>;
+}
+export interface wiltSelf<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: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B, B1>(f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]>;
+}
+export declare function mkWilt<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B1, G>(_: {
+    A: A;
+    B: B;
+    B1: B1;
+    G: G;
+    KF: KF;
+    QF: QF;
+    WF: WF;
+    XF: XF;
+    IF: IF;
+    SF: SF;
+    RF: RF;
+    EF: EF;
+}) => (A: Applicative<HKT.F<G>>) => (f: (a: A) => HKT.FK1<G, Either<B, B1>>) => (wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => HKT.FK1<G, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]>) => wilt<F, FC>;
+export interface filterA_<F extends HKT, CF = HKT.None> {
+    <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <KF, QF, WF, XF, IF, SF, RF, EF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>, p: (a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+}
+export declare function filterAF_<F extends HKT, CF = HKT.None>(F: WitherableMin<F, CF>): filterA_<F, CF>;
+export interface filterA<F extends HKT, CF = HKT.None> {
+    <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <AF, KG, QG, WG, XG, IG, SG, RG, EG>(p: (a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>) => <KF, QF, WF, XF, IF, SF, RF, EF>(fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+}
+export declare function filterAF<F extends HKT, CF = HKT.None>(F: WitherableMin<F, CF>): filterA<F, CF>;