@fncts/base 0.0.20 → 0.0.21

package/_src/typeclass/Showable/util.ts

@@ -1,11 +1,9 @@
 import { isFunction } from "@fncts/base/util/predicates";
 
-const builtInObjects = new Set(Object.getOwnPropertyNames(globalThis).filter((e) => /^[A-Z][a-zA-Z0-9]+$/.test(e)));
-
-export const addBacktickQuotes = String.surround("`");
-export const addSingleQuotes   = String.surround("'");
-export const addDoubleQuotes   = String.surround('"');
-
+const builtInObjects           = new Set(Object.getOwnPropertyNames(globalThis).filter((e) => /^[A-Z][a-zA-Z0-9]+$/.test(e)));
+export const addBacktickQuotes        = String.surround("`");
+export const addSingleQuotes          = String.surround("'");
+export const addDoubleQuotes          = String.surround('"');
 const byteToHex: Array<string> = [];
 
 // Regex used for ansi escape code splitting
@@ -17,68 +15,56 @@ export const ansiPattern =
   "(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)" +
   "|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))";
 export const ansi = new RegExp(ansiPattern, "g");
-
 // Escaped control characters (plus the single quote and the backslash). Use
 // empty strings to fill up unused entries.
 // prettier-ignore
 export const meta = [
-  "\\x00", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\x06", "\\x07", // x07
-  "\\b", "\\t", "\\n", "\\x0B", "\\f", "\\r", "\\x0E", "\\x0F",           // x0F
-  "\\x10", "\\x11", "\\x12", "\\x13", "\\x14", "\\x15", "\\x16", "\\x17", // x17
-  "\\x18", "\\x19", "\\x1A", "\\x1B", "\\x1C", "\\x1D", "\\x1E", "\\x1F", // x1F
-  "", "", "", "", "", "", "", "\\'", "", "", "", "", "", "", "", "",      // x2F
-  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",         // x3F
-  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",         // x4F
-  "", "", "", "", "", "", "", "", "", "", "", "", "\\\\", "", "", "",     // x5F
-  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",         // x6F
-  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "\\x7F",    // x7F
-  "\\x80", "\\x81", "\\x82", "\\x83", "\\x84", "\\x85", "\\x86", "\\x87", // x87
-  "\\x88", "\\x89", "\\x8A", "\\x8B", "\\x8C", "\\x8D", "\\x8E", "\\x8F", // x8F
-  "\\x90", "\\x91", "\\x92", "\\x93", "\\x94", "\\x95", "\\x96", "\\x97", // x97
-  "\\x98", "\\x99", "\\x9A", "\\x9B", "\\x9C", "\\x9D", "\\x9E", "\\x9F", // x9F
+    "\\x00", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\x06", "\\x07",
+    "\\b", "\\t", "\\n", "\\x0B", "\\f", "\\r", "\\x0E", "\\x0F",
+    "\\x10", "\\x11", "\\x12", "\\x13", "\\x14", "\\x15", "\\x16", "\\x17",
+    "\\x18", "\\x19", "\\x1A", "\\x1B", "\\x1C", "\\x1D", "\\x1E", "\\x1F",
+    "", "", "", "", "", "", "", "\\'", "", "", "", "", "", "", "", "",
+    "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+    "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+    "", "", "", "", "", "", "", "", "", "", "", "", "\\\\", "", "", "",
+    "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+    "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "\\x7F",
+    "\\x80", "\\x81", "\\x82", "\\x83", "\\x84", "\\x85", "\\x86", "\\x87",
+    "\\x88", "\\x89", "\\x8A", "\\x8B", "\\x8C", "\\x8D", "\\x8E", "\\x8F",
+    "\\x90", "\\x91", "\\x92", "\\x93", "\\x94", "\\x95", "\\x96", "\\x97",
+    "\\x98", "\\x99", "\\x9A", "\\x9B", "\\x9C", "\\x9D", "\\x9E", "\\x9F", // x9F
 ];
-
 export const strEscapeSequencesRegExp         = /[\x00-\x1f\x27\x5c\x7f-\x9f]/;
 export const strEscapeSequencesReplacer       = /[\x00-\x1f\x27\x5c\x7f-\x9f]/g;
 export const strEscapeSequencesRegExpSingle   = /[\x00-\x1f\x5c\x7f-\x9f]/;
 export const strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c\x7f-\x9f]/g;
 export const colorRegExp                      = /\u001b\[\d\d?m/g;
-
-export const classRegExp         = /^(\s+[^(]*?)\s*{/;
-export const stripCommentsRegExp = /(\/\/.*?\n)|(\/\*(.|\n)*?\*\/)/g;
-
-export const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
-export const numberRegExp = /^(0|[1-9][0-9]*)$/;
-
+export const classRegExp                      = /^(\s+[^(]*?)\s*{/;
+export const stripCommentsRegExp              = /(\/\/.*?\n)|(\/\*(.|\n)*?\*\/)/g;
+export const keyStrRegExp                     = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
+export const numberRegExp                     = /^(0|[1-9][0-9]*)$/;
 export function escapeFn(str: string): string {
   return meta[str.charCodeAt(0)]!;
 }
-
 export const OBJECT_TYPE       = 0;
 export const ARRAY_TYPE        = 1;
 export const ARRAY_EXTRAS_TYPE = 2;
 export const PROTO_TYPE        = 3;
-
 for (let n = 0; n <= 0xff; ++n) {
   const hexOctet = n.toString(16).padStart(2, "0");
   byteToHex.push(hexOctet);
 }
-
 export function hex(arrayBuffer: ArrayBuffer) {
   const buff      = new Uint8Array(arrayBuffer);
   const hexOctets = Array<string>(buff.length);
-
   for (let i = 0; i < buff.length; ++i) {
     hexOctets[i] = byteToHex[buff[i]!]!;
   }
-
   return hexOctets.join("");
 }
-
 export function pluralize(n: number): string {
   return n > 1 ? "s" : "";
 }
-
 export function getKeys(value: object, showHidden = true): Array<PropertyKey> {
   const symbols                  = Object.getOwnPropertySymbols(value);
   const keys: Array<PropertyKey> = Object.getOwnPropertyNames(value);
@@ -92,7 +78,6 @@ export function getKeys(value: object, showHidden = true): Array<PropertyKey> {
   }
   return keys;
 }
-
 export function getStringWidth(input: string, removeControlChars = true): number {
   let width = 0;
   let str   = input;
@@ -110,7 +95,6 @@ export function getStringWidth(input: string, removeControlChars = true): number
   }
   return width;
 }
-
 /**
  * Returns true if the character represented by a given
  * Unicode code point is full-width. Otherwise returns false.
@@ -153,7 +137,6 @@ export function isFullWidthCodePoint(code: number): boolean {
       (code >= 0x20000 && code <= 0x3fffd))
   );
 }
-
 export function isZeroWidthCodePoint(code: number): boolean {
   return (
     code <= 0x1f || // C0 control codes
@@ -167,7 +150,6 @@ export function isZeroWidthCodePoint(code: number): boolean {
     (code >= 0xe0100 && code <= 0xe01ef)
   ); // Variation Selectors
 }
-
 export function getConstructorName(value: object): [string | null, Conc<PropertyKey>] {
   let obj        = value;
   const tmp      = obj;
@@ -186,23 +168,19 @@ export function getConstructorName(value: object): [string | null, Conc<Property
       }
       return [descriptor.value.name, protoProps];
     }
-
     obj = Object.getPrototypeOf(obj);
     if (!firstProto) {
       firstProto = obj;
     }
   }
-
   return [null, Conc.empty()];
 }
-
 export function getPrototypeProperties(main: object, obj: object): Conc<PropertyKey> {
   let proto                   = obj;
   const keySet                = new Set<PropertyKey>();
   let keys: PropertyKey[]     = [];
   let depth                   = 0;
   const output: PropertyKey[] = [];
-
   while (depth <= 3) {
     if (depth !== 0 || main === proto) {
       proto = Object.getPrototypeOf(proto);
@@ -214,7 +192,6 @@ export function getPrototypeProperties(main: object, obj: object): Conc<Property
         return Conc.from(output);
       }
     }
-
     if (depth !== 0) {
       for (let i = 0; i < keys.length; i++) {
         keySet.add(keys[i]!);
@@ -240,7 +217,6 @@ export function getPrototypeProperties(main: object, obj: object): Conc<Property
   }
   return Conc.from(output);
 }
-
 function isInstanceof(value: unknown, constructor: Function): boolean {
   try {
     return value instanceof constructor;
@@ -248,11 +224,9 @@ function isInstanceof(value: unknown, constructor: Function): boolean {
     return false;
   }
 }
-
 function isUndetectableObject(obj: unknown): boolean {
   return typeof obj !== "undefined" && obj !== undefined;
 }
-
 export function getPrefix(constructor: string | null, tag: string, fallback: string, size = "") {
   if (constructor === null) {
     if (tag !== "" && fallback !== tag) {
@@ -260,13 +234,11 @@ export function getPrefix(constructor: string | null, tag: string, fallback: str
     }
     return `[${fallback}${size}: null prototype] `;
   }
-
   if (tag !== "" && constructor !== tag) {
     return `${constructor}${size} [${tag}] `;
   }
   return `${constructor}${size} `;
 }
-
 export function getFunctionBase(value: Function, constructor: string | null, tag: string): string {
   const stringified = value.toString();
   if (stringified.startsWith("class") && stringified.endsWith("}")) {
@@ -298,7 +270,6 @@ export function getFunctionBase(value: Function, constructor: string | null, tag
   }
   return base;
 }
-
 export function getClassBase(value: Function, constructor: string | null, tag: string): string {
   const hasName = Object.prototype.hasOwnProperty.call(value, "name");
   const name    = (hasName && value.name) || "(anonymous)";
@@ -319,7 +290,6 @@ export function getClassBase(value: Function, constructor: string | null, tag: s
   }
   return `[${base}]`;
 }
-
 export function addQuotes(str: string, quotes: number): string {
   if (quotes === -1) {
     return `"${str}"`;
@@ -329,12 +299,10 @@ export function addQuotes(str: string, quotes: number): string {
   }
   return `'${str}'`;
 }
-
 export function strEscape(str: string): string {
   let escapeTest    = strEscapeSequencesRegExp;
   let escapeReplace = strEscapeSequencesReplacer;
   let singleQuote   = 39;
-
   // Check for double quotes. If not present, do not escape single quotes and
   // instead wrap the text in double quotes. If double quotes exist, check for
   // backticks. If they do not exist, use those as fallback instead of the
@@ -352,7 +320,6 @@ export function strEscape(str: string): string {
       escapeReplace = strEscapeSequencesReplacerSingle;
     }
   }
-
   // Some magic numbers that worked out fine while benchmarking with v8 6.0
   if (str.length < 5000 && !escapeTest.test(str)) {
     return addQuotes(str, singleQuote);
@@ -362,7 +329,6 @@ export function strEscape(str: string): string {
     str = str.replace(escapeReplace, escapeFn);
     return addQuotes(str, singleQuote);
   }
-
   let result      = "";
   let last        = 0;
   const lastIndex = str.length;
@@ -377,7 +343,6 @@ export function strEscape(str: string): string {
       last = i + 1;
     }
   }
-
   if (last !== lastIndex) {
     result += str.slice(last);
   }

package/_src/typeclass/Traversable.ts

@@ -8,12 +8,12 @@ import { identity } from "@fncts/base/data/function";
  * @tsplus type fncts.Traversable
  */
 export interface Traversable<F extends HKT, FC = HKT.None> extends Functor<F, FC>, Foldable<F, FC> {
-  traverse: <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>(
+  traverse: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+  ) => <A, 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>,
+  ) => <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>>;
 }
 
@@ -41,10 +41,10 @@ export function mkTraverse_<F extends HKT, FC = HKT.None>(): (
     R: R;
     E: E;
   }) => (
-    ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
-  ) => (
     G: Applicative<HKT.F<G>>,
-  ) => (f: (a: A) => HKT.FK1<G, B>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
+  ) => (
+    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>>,
 ) => Traversable<F, FC>["traverse"];
 export function mkTraverse_() {
   return (i: any) => i();
@@ -55,15 +55,10 @@ export function mkTraverse_() {
  */
 export function sequence<F extends HKT, FC>(
   F: Traversable<F, FC>,
-): <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>(
-  G: 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, XG, IF, SF, RF, EF, B>>
-  : never {
-  // @ts-expect-error
-  return (ta) => (G) => F.traverse(ta)(G)(identity);
+): <G extends HKT, GC = HKT.None>(
+  G: 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>> {
+  return (G) => F.traverse(G)(identity);
 }

package/_src/typeclass/TraversableWithIndex.ts

@@ -10,12 +10,12 @@ export interface TraversableWithIndex<F extends HKT, FC = HKT.None>
   extends FunctorWithIndex<F, FC>,
     FoldableWithIndex<F, FC>,
     Traversable<F, FC> {
-  traverseWithIndex: <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>(
+  traverseWithIndex: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+  ) => <KF, A, KG, QG, WG, XG, IG, SG, RG, EG, B>(
     f: (i: HKT.IndexFor<F, 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>>;
 }
 
@@ -43,12 +43,10 @@ export function mkTraverseWithIndex_<F extends HKT, FC = HKT.None>(): (
     R: R;
     E: E;
   }) => (
-    ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
-  ) => (
     G: Applicative<HKT.F<G>>,
   ) => (
     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>>,
+  ) => (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>>,
 ) => TraversableWithIndex<F, FC>["traverseWithIndex"];
 export function mkTraverseWithIndex_() {
   return (i: any) => i();

package/_src/typeclass/Witherable.ts

@@ -2,23 +2,25 @@ import type { Applicative } from "@fncts/base/typeclass/Applicative";
 import type { Filterable } from "@fncts/base/typeclass/Filterable";
 import type { Traversable } from "@fncts/base/typeclass/Traversable";
 
+import { pipe } from "@fncts/base/data/function";
 /**
  * @tsplus type fncts.Witherable
  */
 export interface Witherable<F extends HKT, FC = HKT.None> extends Filterable<F, FC>, Traversable<F, FC> {
-  wither: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  wither: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+  ) => <A, 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>>;
-  wilt: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
+  ) => <KF, QF, WF, XF, IF, SF, RF, EF>(
     wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  ) => 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>>;
+
+  wilt: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B, B1>(
+  ) => <A, 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>>,
+  ) => <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,
@@ -46,12 +48,18 @@ export const Witherable: WitherableOps = {};
  */
 export function filterA<F extends HKT, FC = HKT.None>(
   F: Witherable<F, FC>,
-): <KF, QF, WF, XF, IF, SF, RF, EF, AF>(
-  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
-) => <G extends HKT, GC = HKT.None>(
+): <G extends HKT, GC = HKT.None>(
   G: Applicative<G, GC>,
-) => <KG, QG, WG, XG, IG, SG, RG, EG>(
+) => <AF, KG, QG, WG, XG, IG, SG, RG, EG>(
   p: (a: AF) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+) => <KF, QF, WF, XF, IF, SF, RF, EF>(
+  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
 ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>> {
-  return (fa) => (G) => (p) => F.wither(fa)(G)((a) => G.map(p(a), (bb) => (bb ? Just(a) : Nothing())));
+  return (G) => (p) =>
+    F.wither(G)((a) =>
+      pipe(
+        p(a),
+        G.map((bb) => (bb ? Just(a) : Nothing())),
+      ),
+    );
 }

package/_src/typeclass/WitherableWithIndex.ts

@@ -3,6 +3,8 @@ import type { FilterableWithIndex } from "@fncts/base/typeclass/FilterableWithIn
 import type { TraversableWithIndex } from "@fncts/base/typeclass/TraversableWithIndex";
 import type { Witherable } from "@fncts/base/typeclass/Witherable";
 
+import { pipe } from "@fncts/base/data/function";
+
 /**
  * @tsplus type fncts.WitherableWithIndex
  */
@@ -10,19 +12,20 @@ export interface WitherableWithIndex<F extends HKT, FC = HKT.None>
   extends FilterableWithIndex<F, FC>,
     TraversableWithIndex<F, FC>,
     Witherable<F, FC> {
-  witherWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  witherWithIndex: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+  ) => <KF, A, KG, QG, WG, XG, IG, SG, RG, EG, B>(
     f: (k: HKT.IndexFor<F, KF>, 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>>;
-  wiltWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2>(
+  ) => <QF, WF, XF, IF, SF, RF, EF>(
     wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  ) => 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>>;
+
+  wiltWithIndex: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B, B2>(
+  ) => <KF, A, KG, QG, WG, XG, IG, SG, RG, EG, B, B2>(
     f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>,
+  ) => <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,
@@ -62,11 +65,11 @@ export function makeWitherWithIndex<F extends HKT, FC = HKT.None>(): (
     FR: RF;
     FE: EF;
   }) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => (
     G: Applicative<HKT.F<G>>,
   ) => (
     f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>,
+  ) => (
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
   ) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>,
 ) => WitherableWithIndex<F, FC>["witherWithIndex"];
 export function makeWitherWithIndex() {
@@ -91,11 +94,11 @@ export function makeWiltWithIndex<F extends HKT, FC = HKT.None>(): (
     B: B;
     B1: B1;
   }) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => (
     G: Applicative<HKT.F<G>>,
   ) => (
     f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, 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>]
@@ -107,12 +110,18 @@ export function makeWiltWithIndex() {
 
 export function filterWithIndexA<F extends HKT, FC = HKT.None>(
   F: WitherableWithIndex<F, FC>,
-): <KF, QF, WF, XF, IF, SF, RF, EF, AF>(
-  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
-) => <G extends HKT, GC = HKT.None>(
+): <G extends HKT, GC = HKT.None>(
   G: Applicative<G, GC>,
-) => <KG, QG, WG, XG, IG, SG, RG, EG>(
+) => <KF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(
   p: (i: HKT.IndexFor<F, KF>, a: AF) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+) => <QF, WF, XF, IF, SF, RF, EF>(
+  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
 ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>> {
-  return (fa) => (G) => (p) => F.witherWithIndex(fa)(G)((i, a) => G.map(p(i, a), (bb) => (bb ? Just(a) : Nothing())));
+  return (G) => (p) =>
+    F.witherWithIndex(G)((i, a) =>
+      pipe(
+        p(i, a),
+        G.map((bb) => (bb ? Just(a) : Nothing())),
+      ),
+    );
 }

package/_src/typeclass/builtin/Symbol.ts

@@ -4,5 +4,4 @@ declare global {
    */
   export interface SymbolConstructor {}
 }
-
 export {};

package/_src/types/extractions.ts

@@ -1,8 +1,17 @@
-export type ExtractContravariantPhantom<A, P extends PropertyKey> = [A] extends [{ [K in P]: (_: infer T) => void }]
+export type ExtractContravariantPhantom<A, P extends PropertyKey> = [A] extends [
+  {
+    [K in P]: (_: infer T) => void;
+  },
+]
+  ? T
+  : never;
+export type ExtractCovariantPhantom<A, P extends PropertyKey> = [A] extends [
+  {
+    [K in P]: () => infer T;
+  },
+]
   ? T
   : never;
-export type ExtractCovariantPhantom<A, P extends PropertyKey> = [A] extends [{ [K in P]: () => infer T }] ? T : never;
-
 export type _W<A> = ExtractCovariantPhantom<A, "_W">;
 export type _S1<A> = ExtractContravariantPhantom<A, "_S1">;
 export type _S2<A> = ExtractCovariantPhantom<A, "_S2">;

package/_src/types/utility.ts

@@ -1,9 +1,7 @@
 export type Primitive = string | number | boolean | null | symbol;
-
-export type Constructor<A> = { new (...args: any[]): A };
-
+export type Constructor<A> = {
+  new (...args: any[]): A;
+};
 export type Nullable<A> = A | null | undefined;
-
 export type IsInt<N extends number> = N & (`${N}` extends `${bigint}` ? N : never);
-
 export interface Spreadable extends Record<PropertyKey, any> {}

package/_src/util/AnsiFormat.ts

@@ -62,128 +62,103 @@ export function bg_rgb(r: number, g: number, b: number): (s: string) => string {
  * Foreground color for ANSI black
  */
 export const BLACK = escape(30);
-
 /**
  * Foreground color for ANSI red
  */
 export const RED = escape(31);
-
 /**
  * Foreground color for ANSI green
  */
 export const GREEN = escape(32);
-
 /**
  * Foreground color for ANSI yellow
  */
 export const YELLOW = escape(33);
-
 /**
  * Foreground color for ANSI blue
  */
 export const BLUE = escape(34);
-
 /**
  * Foreground color for ANSI magenta
  */
 export const MAGENTA = escape(35);
-
 /**
  * Foreground color for ANSI cyan
  */
 export const CYAN = escape(36);
-
 /**
  * Foreground color for ANSI white
  */
 export const WHITE = escape(37);
-
 /**
  * Background color for ANSI black
  */
 export const BLACK_B = escape(40);
-
 /**
  * Background color for ANSI red
  */
 export const RED_B = escape(41);
-
 /**
  * Background color for ANSI green
  */
 export const GREEN_B = escape(42);
-
 /**
  * Background color for ANSI yellow
  */
 export const YELLOW_B = escape(43);
-
 /**
  * Background color for ANSI blue
  */
 export const BLUE_B = escape(44);
-
 /**
  * Background color for ANSI magenta
  */
 export const MAGENTA_B = escape(45);
-
 /**
  * Background color for ANSI cyan
  */
 export const CYAN_B = escape(46);
-
 /**
  * Background color for ANSI white
  */
 export const WHITE_B = escape(47);
-
 /**
  * Reset ANSI styles
  */
 export const RESET = escape(0);
-
 /**
  * ANSI bold
  */
 export const BOLD = escape(1);
-
 /**
  * ANSI underline
  */
 export const UNDERLINE = escape(4);
-
 /**
  * ANSI blink
  */
 export const BLINK = escape(5);
-
 /**
  * ANSI reversed
  */
 export const REVERSED = escape(7);
-
 /**
  * ANSI invisible
  */
 export const INVISIBLE = escape(8);
-
 /**
  * Reset ANSI foreground
  */
 export const RESET_FG = escape(39);
-
 /**
  * Reset ANSI background
  */
 export const RESET_BG = escape(49);
-
 /**
  * ANSI 24bit foreground
  */
 export const RGB = <r extends number, g extends number, b extends number>(r: r, g: g, b: b) =>
   `\u001b[38;2;${r};${g};${b}m` as const;
-
 /**
  * ANSI 24bit background
  */