@fncts/base 0.0.20 → 0.0.21

package/_src/typeclass/Equatable/fast-equals.ts

@@ -1,14 +1,10 @@
 /* Forked from https://github.com/planttheidea/fast-equals */
-
 const HAS_WEAKSET_SUPPORT = typeof WeakSet === "function";
-
-const { keys } = Object;
-
+const { keys }            = Object;
 type Cache = {
   add: (value: any) => void;
   has: (value: any) => boolean;
 };
-
 /**
  * @function addToCache
  *
@@ -22,9 +18,7 @@ export function addToCache(value: any, cache: Cache) {
     cache.add(value);
   }
 }
-
 export type EqualityComparator = (a: any, b: any, meta?: any) => boolean;
-
 /**
  * @function hasPair
  *
@@ -40,20 +34,15 @@ export type EqualityComparator = (a: any, b: any, meta?: any) => boolean;
  */
 export function hasPair(pairs: [any, any][], pairToMatch: [any, any], isEqual: EqualityComparator, meta: any) {
   const { length } = pairs;
-
   let pair: [any, any];
-
   for (let index = 0; index < length; index++) {
     pair = pairs[index]!;
-
     if (isEqual(pair[0], pairToMatch[0], meta) && isEqual(pair[1], pairToMatch[1], meta)) {
       return true;
     }
   }
-
   return false;
 }
-
 /**
  * @function hasValue
  *
@@ -69,16 +58,13 @@ export function hasPair(pairs: [any, any][], pairToMatch: [any, any], isEqual: E
  */
 export function hasValue(values: any[], valueToMatch: any, isEqual: EqualityComparator, meta: any) {
   const { length } = values;
-
   for (let index = 0; index < length; index++) {
     if (isEqual(values[index], valueToMatch, meta)) {
       return true;
     }
   }
-
   return false;
 }
-
 /**
  * @function sameValueZeroEqual
  *
@@ -92,7 +78,6 @@ export function hasValue(values: any[], valueToMatch: any, isEqual: EqualityComp
 export function sameValueZeroEqual(a: any, b: any) {
   return a === b || (a !== a && b !== b);
 }
-
 /**
  * @function isPlainObject
  *
@@ -105,7 +90,6 @@ export function sameValueZeroEqual(a: any, b: any) {
 export function isPlainObject(value: any) {
   return value.constructor === Object || value.constructor == null;
 }
-
 /**
  * @function isPromiseLike
  *
@@ -118,7 +102,6 @@ export function isPlainObject(value: any) {
 export function isPromiseLike(value: any) {
   return !!value && typeof value.then === "function";
 }
-
 /**
  * @function isReactElement
  *
@@ -131,7 +114,6 @@ export function isPromiseLike(value: any) {
 export function isReactElement(value: any) {
   return !!(value && value.$$typeof);
 }
-
 /**
  * @function getNewCacheFallback
  *
@@ -144,19 +126,16 @@ export function isReactElement(value: any) {
 export function getNewCacheFallback(): Cache {
   return Object.create({
     _values: [],
-
     add(value: any) {
       // @ts-expect-error
       this._values.push(value);
     },
-
     has(value: any) {
       // @ts-expect-error
       return this._values.indexOf(value) !== -1;
     },
   });
 }
-
 /**
  * @function getNewCache
  *
@@ -171,10 +150,8 @@ export const getNewCache = ((canUseWeakMap: boolean) => {
       return new WeakSet();
     };
   }
-
   return getNewCacheFallback;
 })(HAS_WEAKSET_SUPPORT);
-
 /**
  * @function createCircularEqualCreator
  *
@@ -187,23 +164,18 @@ export const getNewCache = ((canUseWeakMap: boolean) => {
 export function createCircularEqualCreator(isEqual?: EqualityComparatorCreator) {
   return function createCircularEqual(comparator: EqualityComparator) {
     const _comparator = isEqual ? isEqual(comparator) : comparator;
-
     return function circularEqual(a: any, b: any, cache: Cache = getNewCache()) {
       const hasA = cache.has(a);
       const hasB = cache.has(b);
-
       if (hasA || hasB) {
         return hasA && hasB;
       }
-
       addToCache(a, cache);
       addToCache(b, cache);
-
       return _comparator(a, b, cache);
     };
   };
 }
-
 /**
  * @function toPairs
  *
@@ -215,16 +187,12 @@ export function createCircularEqualCreator(isEqual?: EqualityComparatorCreator)
  */
 export function toPairs(map: Map<any, any>): [any, any][] {
   const pairs = new Array(map.size);
-
-  let index = 0;
-
+  let index   = 0;
   map.forEach((value, key) => {
     pairs[index++] = [key, value];
   });
-
   return pairs;
 }
-
 /**
  * @function toValues
  *
@@ -236,16 +204,12 @@ export function toPairs(map: Map<any, any>): [any, any][] {
  */
 export function toValues(set: Set<any>) {
   const values = new Array(set.size);
-
-  let index = 0;
-
+  let index    = 0;
   set.forEach((value) => {
     values[index++] = value;
   });
-
   return values;
 }
-
 /**
  * @function areArraysEqual
  *
@@ -260,20 +224,16 @@ export function toValues(set: Set<any>) {
  */
 export function areArraysEqual(a: any[], b: any[], isEqual: EqualityComparator, meta: any) {
   const { length } = a;
-
   if (b.length !== length) {
     return false;
   }
-
   for (let index = 0; index < length; index++) {
     if (!isEqual(a[index], b[index], meta)) {
       return false;
     }
   }
-
   return true;
 }
-
 /**
  * @function areMapsEqual
  *
@@ -290,30 +250,22 @@ export function areMapsEqual(a: Map<any, any>, b: Map<any, any>, isEqual: Equali
   if (a.size !== b.size) {
     return false;
   }
-
-  const pairsA = toPairs(a);
-  const pairsB = toPairs(b);
-
+  const pairsA     = toPairs(a);
+  const pairsB     = toPairs(b);
   const { length } = pairsA;
-
   for (let index = 0; index < length; index++) {
     if (!hasPair(pairsB, pairsA[index]!, isEqual, meta) || !hasPair(pairsA, pairsB[index]!, isEqual, meta)) {
       return false;
     }
   }
-
   return true;
 }
-
 type Dictionary<Type> = {
   [key: string]: Type;
   [index: number]: Type;
 };
-
-const OWNER = "_owner";
-
+const OWNER          = "_owner";
 const hasOwnProperty = Function.prototype.bind.call(Function.prototype.call, Object.prototype.hasOwnProperty);
-
 /**
  * @function areObjectsEqual
  *
@@ -327,23 +279,17 @@ const hasOwnProperty = Function.prototype.bind.call(Function.prototype.call, Obj
  * @returns are the objects equal
  */
 export function areObjectsEqual(a: Dictionary<any>, b: Dictionary<any>, isEqual: EqualityComparator, meta: any) {
-  const keysA = keys(a);
-
+  const keysA      = keys(a);
   const { length } = keysA;
-
   if (keys(b).length !== length) {
     return false;
   }
-
   let key: string;
-
   for (let index = 0; index < length; index++) {
     key = keysA[index]!;
-
     if (!hasOwnProperty(b, key)) {
       return false;
     }
-
     if (key === OWNER && isReactElement(a)) {
       if (!isReactElement(b)) {
         return false;
@@ -352,10 +298,8 @@ export function areObjectsEqual(a: Dictionary<any>, b: Dictionary<any>, isEqual:
       return false;
     }
   }
-
   return true;
 }
-
 /**
  * @function areRegExpsEqual
  *
@@ -377,7 +321,6 @@ export function areRegExpsEqual(a: RegExp, b: RegExp) {
     a.lastIndex === b.lastIndex
   );
 }
-
 /**
  * @function areSetsEqual
  *
@@ -394,36 +337,26 @@ export function areSetsEqual(a: Set<any>, b: Set<any>, isEqual: EqualityComparat
   if (a.size !== b.size) {
     return false;
   }
-
-  const valuesA = toValues(a);
-  const valuesB = toValues(b);
-
+  const valuesA    = toValues(a);
+  const valuesB    = toValues(b);
   const { length } = valuesA;
-
   for (let index = 0; index < length; index++) {
     if (!hasValue(valuesB, valuesA[index], isEqual, meta) || !hasValue(valuesA, valuesB[index], isEqual, meta)) {
       return false;
     }
   }
-
   return true;
 }
-
-const { isArray } = Array;
-
+const { isArray }     = Array;
 const HAS_MAP_SUPPORT = typeof Map === "function";
 const HAS_SET_SUPPORT = typeof Set === "function";
-
-const OBJECT_TYPEOF = "object";
-
+const OBJECT_TYPEOF   = "object";
 type EqualityComparatorCreator = (fn: EqualityComparator) => EqualityComparator;
-
 export function createComparator(createIsEqual?: EqualityComparatorCreator) {
   const isEqual: EqualityComparator =
     /* eslint-disable no-use-before-define */
     typeof createIsEqual === "function" ? createIsEqual(comparator) : comparator;
   /* eslint-enable */
-
   /**
    * @function comparator
    *
@@ -439,60 +372,45 @@ export function createComparator(createIsEqual?: EqualityComparatorCreator) {
     if (sameValueZeroEqual(a, b)) {
       return true;
     }
-
     if (a && b && typeof a === OBJECT_TYPEOF && typeof b === OBJECT_TYPEOF) {
       if (isPlainObject(a) && isPlainObject(b)) {
         return areObjectsEqual(a, b, isEqual, meta);
       }
-
       const arrayA = isArray(a);
       const arrayB = isArray(b);
-
       if (arrayA || arrayB) {
         return arrayA === arrayB && areArraysEqual(a, b, isEqual, meta);
       }
-
       const aDate = a instanceof Date;
       const bDate = b instanceof Date;
-
       if (aDate || bDate) {
         return aDate === bDate && sameValueZeroEqual(a.getTime(), b.getTime());
       }
-
       const aRegExp = a instanceof RegExp;
       const bRegExp = b instanceof RegExp;
-
       if (aRegExp || bRegExp) {
         return aRegExp === bRegExp && areRegExpsEqual(a, b);
       }
-
       if (isPromiseLike(a) || isPromiseLike(b)) {
         return a === b;
       }
-
       if (HAS_MAP_SUPPORT) {
         const aMap = a instanceof Map;
         const bMap = b instanceof Map;
-
         if (aMap || bMap) {
           return aMap === bMap && areMapsEqual(a, b, isEqual, meta);
         }
       }
-
       if (HAS_SET_SUPPORT) {
         const aSet = a instanceof Set;
         const bSet = b instanceof Set;
-
         if (aSet || bSet) {
           return aSet === bSet && areSetsEqual(a, b, isEqual, meta);
         }
       }
-
       return areObjectsEqual(a, b, isEqual, meta);
     }
-
     return false;
   }
-
   return comparator;
 }

package/_src/typeclass/Filterable.ts

@@ -4,30 +4,36 @@ import type { Functor } from "@fncts/base/typeclass/Functor";
  * @tsplus type fncts.Filterable
  */
 export interface Filterable<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-  filter<K, Q, W, X, I, S, R, E, A, B extends A>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  filter<A, B extends A>(
     refinement: Refinement<A, B>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-  filter<K, Q, W, X, I, S, R, E, A>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
+  filter<A>(
     predicate: Predicate<A>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
-  filterMap<K, Q, W, X, I, S, R, E, A, B>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
+  filterMap<A, B>(
     f: (a: A) => Maybe<B>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-  partition<K, Q, W, X, I, S, R, E, A, B extends A>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
+  partition<A, B extends A>(
     refinement: Refinement<A, B>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
-  partition<K, Q, W, X, I, S, R, E, A>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
+  partition<A>(
     predicate: Predicate<A>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
-  partitionMap<K, Q, W, X, I, S, R, E, A, B, B1>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
+  partitionMap<A, B, B1>(
     f: (a: A) => Either<B, B1>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
+  ): <K, Q, W, X, I, S, R, E>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
 }
 
 /**

package/_src/typeclass/FilterableWithIndex.ts

@@ -5,30 +5,36 @@ import type { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
  * @tsplus type fncts.FilterableWithIndex
  */
 export interface FilterableWithIndex<F extends HKT, FC = HKT.None> extends FunctorWithIndex<F, FC>, Filterable<F, FC> {
-  filterWithIndex<K, Q, W, X, I, S, R, E, A, B extends A>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  filterWithIndex<K, A, B extends A>(
     refinement: RefinementWithIndex<HKT.IndexFor<F, K>, A, B>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-  filterWithIndex<K, Q, W, X, I, S, R, E, A>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
+  filterWithIndex<K, A>(
     predicate: PredicateWithIndex<HKT.IndexFor<F, K>, A>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
-  filterMapWithIndex<K, Q, W, X, I, S, R, E, A, B>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
+  filterMapWithIndex<K, A, B>(
     f: (i: HKT.IndexFor<F, K>, a: A) => Maybe<B>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-  partitionWithIndex<K, Q, W, X, I, S, R, E, A, B extends A>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
+  partitionWithIndex<K, A, B extends A>(
     refinement: RefinementWithIndex<HKT.IndexFor<F, K>, A, B>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
-  partitionWithIndex<K, Q, W, X, I, S, R, E, A>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
+  partitionWithIndex<K, A>(
     predicate: PredicateWithIndex<HKT.IndexFor<F, K>, A>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
-  partitionMapWithIndex<K, Q, W, X, I, S, R, E, A, B, B1>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
+  partitionMapWithIndex<K, A, B, B1>(
     f: (i: HKT.IndexFor<F, K>, a: A) => Either<B, B1>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
+  ): <Q, W, X, I, S, R, E>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
 }
 
 /**

package/_src/typeclass/Foldable.ts

@@ -4,16 +4,14 @@ 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> {
-  foldLeft: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  foldLeft: <A, B>(
     b: B,
     f: (b: B, a: A) => B,
-  ) => B;
-  foldRight: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => B;
+  foldRight: <A, B>(
     b: Eval<B>,
     f: (a: A, b: Eval<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>;
 }
 
 /**
@@ -28,10 +26,9 @@ export const Foldable: FoldableOps = {};
  */
 export function foldMap<F extends HKT, FC = HKT.None>(
   F: Foldable<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, M>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <A, M>(
   f: (a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
-) => M {
-  return (fa, f, M) => F.foldLeft(fa, M.nat, (b, a) => M.combine(b, f(a)));
+) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => M {
+  return (f, M) => F.foldLeft(M.nat, (b, a) => M.combine(b, f(a)));
 }

package/_src/typeclass/FoldableWithIndex.ts

@@ -5,16 +5,14 @@ import type { Monoid } from "@fncts/base/typeclass/Monoid";
  * @tsplus type fncts.FoldableWithIndex
  */
 export interface FoldableWithIndex<F extends HKT, FC = HKT.None> extends Foldable<F, FC> {
-  foldLeftWithIndex: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  foldLeftWithIndex: <K, A, B>(
     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, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => B;
+  foldRightWithIndex: <K, A, B>(
     b: Eval<B>,
     f: (i: HKT.IndexFor<F, K>, a: A, b: Eval<B>) => Eval<B>,
-  ) => Eval<B>;
+  ) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => Eval<B>;
 }
 
 /**
@@ -29,10 +27,9 @@ export const FoldableWithIndex: FoldableWithIndexOps = {};
  */
 export function foldMapWithIndex<F extends HKT, FC = HKT.None>(
   F: FoldableWithIndex<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, M>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <K, A, M>(
   f: (k: HKT.IndexFor<F, K>, a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
-) => M {
-  return (fa, f, M) => F.foldLeftWithIndex(fa, M.nat, (i, b, a) => M.combine(b, f(i, a)));
+) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => M {
+  return (f, M) => F.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }

package/_src/typeclass/Functor.ts

@@ -2,9 +2,10 @@
  * @tsplus type fncts.Functor
  */
 export interface Functor<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
-  readonly map: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  readonly map: <A, B>(
     f: (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>,
   ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
 }
 
@@ -20,9 +21,10 @@ export const Functor: FunctorOps = {};
  */
 export function as<F extends HKT, FC = HKT.None>(
   F: Functor<F, FC>,
-): <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: Lazy<B>,
+) => <K, Q, W, X, I, S, R, E, A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B> {
   return F.map;
 }

package/_src/typeclass/FunctorWithIndex.ts

@@ -1,9 +1,10 @@
 import type { Functor } from "@fncts/base/typeclass/Functor";
 
 export interface FunctorWithIndex<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-  readonly mapWithIndex: <K, W, Q, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, W, Q, X, I, S, R, E, A>,
+  readonly mapWithIndex: <K, A, B>(
     f: (i: HKT.IndexFor<F, K>, a: A) => B,
+  ) => <W, Q, X, I, S, R, E>(
+    fa: HKT.Kind<F, FC, K, W, Q, X, I, S, R, E, A>,
   ) => HKT.Kind<F, FC, K, W, Q, X, I, S, R, E, B>;
 }
 

package/_src/typeclass/Guard/api.ts

@@ -4,29 +4,34 @@ import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 import { Guard } from "@fncts/base/typeclass/Guard/definition";
 import { AssertionError } from "@fncts/base/util/assert";
 import { isObject } from "@fncts/base/util/predicates";
-
 /**
- * @tsplus fluent fncts.Guard __call
+ * @tsplus pipeable fncts.Guard __call
  */
-export function is<A>(self: Guard<A>, u: unknown): u is A {
-  return self.is(u);
+export function is(u: unknown) {
+  // @ts-expect-error
+  return <A>(self: Guard<A>): u is A => {
+    return self.is(u);
+  };
 }
-
 /**
- * @tsplus fluent fncts.Guard refine
+ * @tsplus pipeable fncts.Guard refine
  * @tsplus operator fncts.Guard &&
  */
-export function refine<A, B extends A>(self: Guard<A>, refinement: Refinement<A, B>): Guard<B>;
-export function refine<A>(self: Guard<A>, predicate: Predicate<A>): Guard<A>;
-export function refine<A>(self: Guard<A>, predicate: Predicate<A>): Guard<A> {
-  return Guard(self.is && predicate);
+export function refine<A, B extends A>(refinement: Refinement<A, B>): (self: Guard<A>) => Guard<B>;
+export function refine<A>(predicate: Predicate<A>): (self: Guard<A>) => Guard<A>;
+export function refine<A>(predicate: Predicate<A>) {
+  return (self: Guard<A>): Guard<A> => {
+    return Guard(self.is && predicate);
+  };
 }
-
 /**
- * @tsplus fluent fncts.Guard assert
+ * @tsplus pipeable fncts.Guard assert
  */
-export function assert<A>(self: Guard<A>, u: unknown): asserts u is A {
-  if (!self.is(u)) {
-    throw new AssertionError("Guard failed check failed");
-  }
+export function assert(u: unknown) {
+  // @ts-expect-error
+  return <A>(self: Guard<A>): asserts u is A => {
+    if (!self.is(u)) {
+      throw new AssertionError("Guard failed check failed");
+    }
+  };
 }

package/_src/typeclass/Guard/definition.ts

@@ -1,8 +1,6 @@
 export interface GuardF extends Guard<any> {}
-
 export const GuardTypeId = Symbol.for("fncts.Guard");
 export type GuardTypeId = typeof GuardTypeId;
-
 /**
  * @tsplus type fncts.Guard
  * @tsplus companion fncts.GuardOps
@@ -12,7 +10,6 @@ export class Guard<A> {
   declare _A: () => A;
   constructor(readonly is: Refinement<unknown, A>) {}
 }
-
 /**
  * @tsplus static fncts.GuardOps __call
  */