@fncts/base 0.0.20 → 0.0.21

package/_src/typeclass/Guard/derivations.ts

@@ -1,6 +1,5 @@
 import type { Check } from "@fncts/typelevel/Check";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
-
 /**
  * @tsplus derive fncts.Guard lazy
  */
@@ -14,7 +13,6 @@ export function deriveLazy<A>(f: (_: Guard<A>) => Guard<A>): Guard<A> {
   });
   return guard;
 }
-
 /**
  * @tsplus derive fncts.Guard<_> 20
  */
@@ -23,7 +21,6 @@ export function deriveLiteral<A extends string | number | boolean>(
 ): Guard<A> {
   return Guard((u): u is A => u === value);
 }
-
 /**
  * @tsplus derive fncts.Guard<_> 20
  */
@@ -49,7 +46,6 @@ export function deriveStruct<A extends Record<string, any>>(
     if (!isObject(u)) {
       return false;
     }
-
     for (const key in requiredFields) {
       if (!(key in u) || !(requiredFields[key] as Guard<any>).is(u[key])) {
         return false;
@@ -65,11 +61,14 @@ export function deriveStruct<A extends Record<string, any>>(
     return true;
   });
 }
-
 /**
  * @tsplus derive fncts.Guard<|> 30
  */
-export function deriveUnion<A extends unknown[]>(...members: { [K in keyof A]: Guard<A[K]> }): Guard<A[number]> {
+export function deriveUnion<A extends unknown[]>(
+  ...members: {
+    [K in keyof A]: Guard<A[K]>;
+  }
+): Guard<A[number]> {
   return Guard((u): u is A[number] => {
     for (const member of members) {
       if (member.is(u)) {

package/_src/typeclass/Has.ts

@@ -11,9 +11,11 @@ export interface Has<T> {
 }
 
 /**
- * @tsplus operator fncts.Has &
- * @tsplus fluent fncts.Has merge
+ * @tsplus pipeable-operator fncts.Has &
+ * @tsplus pipeable fncts.Has merge
  */
-export function merge<A extends Has<any>, B extends Has<any>>(self: A, that: B): A & B {
-  return { ...self, ...that };
+export function merge<B extends Has<any>>(that: B) {
+  return <A extends Has<any>>(self: A): A & B => {
+    return { ...self, ...that };
+  };
 }

package/_src/typeclass/HashEq.ts

@@ -1,21 +1,16 @@
 import type { Hash } from "./Hash.js";
 
 import { Eq } from "./Eq.js";
-
 /**
  * @tsplus type fncts.HashEq
  */
 export interface HashEq<A> extends Hash<A>, Eq<A> {}
-
 /**
  * @tsplus type fncts.HashEqOps
  */
 export interface HashEqOps {}
-
 export const HashEq: HashEqOps = {};
-
 export type HashEqMin<A> = Hash<A> & Eq<A>;
-
 /**
  * @tsplus static fncts.HashEqOps __call
  */
@@ -25,7 +20,6 @@ export function mkHashEq<A>(F: HashEqMin<A>): HashEq<A> {
     hash: F.hash,
   };
 }
-
 /**
  * @tsplus static fncts.HashEqOps StructuralStrict
  */
@@ -33,7 +27,6 @@ export const StructuralStrict = HashEq({
   hash: Hashable.unknown,
   equals: Equatable.strictEquals,
 });
-
 /**
  * @tsplus static fncts.HashEqOps StructuralDeep
  */

package/_src/typeclass/Hashable/definition.ts

@@ -2,21 +2,17 @@
  * @tsplus static fncts.builtin.SymbolOps hash
  */
 export const hashSymbol: unique symbol = Symbol.for("fncts.Hashable");
-
 /**
  * @tsplus type fncts.Hashable
  */
 export interface Hashable {
   [hashSymbol]: number;
 }
-
 export function isHashable(u: unknown): u is Hashable {
   return isObject(u) && Symbol.hash in u;
 }
-
 /**
  * @tsplus type fncts.HashableOps
  */
 export interface HashableOps {}
-
 export const Hashable: HashableOps = {};

package/_src/typeclass/Hashable/hash.ts

@@ -1,33 +1,27 @@
 import { isHashable } from "@fncts/base/typeclass/Hashable/definition";
 import { PCGRandom } from "@fncts/base/util/PCGRandom";
 import { isArray, isDefined, isIterable, isPlain } from "@fncts/base/util/predicates";
-
 const CACHE  = new WeakMap<any, number>();
 const RANDOM = new PCGRandom((Math.random() * 4294967296) >>> 0);
-
 let _current = 0;
-
 /**
  * @tsplus static fncts.HashableOps string
  */
 export function hashString(str: string) {
   return optimize(_hashString(str));
 }
-
 function _hashString(str: string) {
   let h = 5381;
   let i = str.length;
   while (i) h = (h * 33) ^ str.charCodeAt(--i);
   return h;
 }
-
 /**
  * @tsplus static fncts.HashableOps number
  */
 export function hashNumber(n: number): number {
   return optimize(_hashNumber(n));
 }
-
 function _hashNumber(n: number): number {
   if (n !== n || n === Infinity) return 0;
   let h = n | 0;
@@ -36,14 +30,12 @@ function _hashNumber(n: number): number {
   while (n > 0xffffffff) h ^= n /= 0xffffffff;
   return n;
 }
-
 /**
  * @tsplus static fncts.HashableOps object
  */
 export function hashObject(value: object): number {
   return optimize(_hashObject(value));
 }
-
 function _hashObject(value: object): number {
   let h = CACHE.get(value);
   if (isDefined(h)) return h;
@@ -61,14 +53,12 @@ function _hashObject(value: object): number {
   CACHE.set(value, h);
   return h;
 }
-
 /**
  * @tsplus static fncts.HashableOps plainObject
  */
 export function hashPlainObject(o: any) {
   return optimize(_hashPlainObject(o));
 }
-
 function _hashPlainObject(o: any): number {
   CACHE.set(o, randomInt());
   const keys = Object.keys(o);
@@ -80,14 +70,12 @@ function _hashPlainObject(o: any): number {
   }
   return h;
 }
-
 /**
  * @tsplus static fncts.HashableOps miscRef
  */
 export function hashMiscRef(o: any) {
   return optimize(_hashMiscRef(o));
 }
-
 function _hashMiscRef(o: any): number {
   let h = CACHE.get(o);
   if (isDefined(h)) return h;
@@ -95,14 +83,12 @@ function _hashMiscRef(o: any): number {
   CACHE.set(o, h);
   return h;
 }
-
 /**
  * @tsplus static fncts.HashableOps array
  */
 export function hashArray(arr: Array<any> | ReadonlyArray<any>): number {
   return optimize(_hashArray(arr));
 }
-
 function _hashArray(arr: Array<any> | ReadonlyArray<any>): number {
   let h = 6151;
   for (let i = 0; i < arr.length; i++) {
@@ -110,14 +96,12 @@ function _hashArray(arr: Array<any> | ReadonlyArray<any>): number {
   }
   return h;
 }
-
 /**
  * @tsplus static fncts.HashableOps iterator
  */
 export function hashIterator(it: Iterator<any>): number {
   return optimize(_hashIterator(it));
 }
-
 function _hashIterator(it: Iterator<any>): number {
   let res: IteratorResult<any>;
   let h = 6151;
@@ -126,18 +110,15 @@ function _hashIterator(it: Iterator<any>): number {
   }
   return h;
 }
-
 /**
  * @tsplus static fncts.HashableOps unknown
  */
 export function hashUnknown(value: unknown): number {
   return optimize(_hash(value));
 }
-
 function isZero(value: unknown): boolean {
   return value === null || value === void 0 || value === false;
 }
-
 function _hash(arg: any): number {
   let x = arg;
   if (isZero(x)) return 0;
@@ -165,27 +146,22 @@ function _hash(arg: any): number {
     }
   }
 }
-
 /**
  * @tsplus static fncts.HashableOps combine
  */
 export function combineHash(x: number, y: number): number {
   return optimize(_combineHash(x, y));
 }
-
 function _combineHash(x: number, y: number): number {
   return (x * 53) ^ y;
 }
-
 /**
  * @tsplus static fncts.HashableOps symbol
  */
 export function hashUniqueSymbol(sym: symbol): number {
   return optimize(_hashUniqueSymbol(sym));
 }
-
 const SYMBOL_CACHE = new Map<symbol, number>();
-
 function _hashUniqueSymbol(sym: symbol): number {
   let h = SYMBOL_CACHE.get(sym);
   if (isDefined(h)) {
@@ -195,14 +171,12 @@ function _hashUniqueSymbol(sym: symbol): number {
   SYMBOL_CACHE.set(sym, h);
   return h;
 }
-
 /**
  * @tsplus static fncts.HashableOps optimize
  */
 export function optimize(n: number): number {
   return (n & 0xbfffffff) | ((n >>> 1) & 0x40000000);
 }
-
 function randomInt(): number {
   return RANDOM.integer(0x7fffffff);
 }

package/_src/typeclass/MonadExcept.ts

@@ -24,5 +24,5 @@ export function absolve<F extends HKT, FC = HKT.None>(
 export function absolve<F>(
   F: MonadExcept<HKT.F<F>>,
 ): <E, A, E1>(fa: HKT.FK2<F, E, Either<E1, A>>) => HKT.FK2<F, HKT.Mix<HKT.F<F>, "E", [E, E1]>, A> {
-  return (fa) => F.flatMap(fa, (r) => r.match(F.fail, F.pure));
+  return F.flatMap((r) => r.match(F.fail, F.pure));
 }

package/_src/typeclass/Ord/api/contramap.ts

@@ -1,11 +1,12 @@
 import type { Ord } from "@fncts/base/typeclass/Ord/definition";
-
 /**
- * @tsplus fluent fncts.Ord contramap
+ * @tsplus pipeable fncts.Ord contramap
  */
-export function contramap<A, B>(self: Ord<A>, f: (b: B) => A): Ord<B> {
-  return {
-    compare: (x, y) => self.compare(f(x), f(y)),
-    equals: (x, y) => self.equals(f(x), f(y)),
+export function contramap<A, B>(f: (b: B) => A) {
+  return (self: Ord<A>): Ord<B> => {
+    return {
+      compare: (x, y) => self.compare(f(x), f(y)),
+      equals: (x, y) => self.equals(f(x), f(y)),
+    };
   };
 }

package/_src/typeclass/Ord/api/max.ts

@@ -1,5 +1,4 @@
 import type { Ord } from "@fncts/base/typeclass/Ord/definition";
-
 /**
  * @tsplus static fncts.OrdOps max
  * @tsplus getter fncts.Ord max

package/_src/typeclass/Ord/api/min.ts

@@ -1,5 +1,4 @@
 import type { Ord } from "@fncts/base/typeclass/Ord/definition";
-
 /**
  * @tsplus static fncts.OrdOps min
  * @tsplus getter fncts.Ord min

package/_src/typeclass/Ord/definition.ts

@@ -1,21 +1,17 @@
 import type { Ordering } from "@fncts/base/typeclass/Ordering";
 
 import { Eq } from "@fncts/base/typeclass/Eq";
-
 /**
  * @tsplus type fncts.Ord
  */
 export interface Ord<A> extends Eq<A> {
   readonly compare: (x: A, y: A) => Ordering;
 }
-
 /**
  * @tsplus type fncts.OrdOps
  */
 export interface OrdOps {}
-
 export const Ord: OrdOps = {};
-
 /**
  * @tsplus static fncts.OrdOps __call
  */

package/_src/typeclass/Ord/instances.ts

@@ -2,7 +2,6 @@ import { Monoid } from "@fncts/base/typeclass/Monoid";
 import { Ord } from "@fncts/base/typeclass/Ord/definition";
 import { Ordering } from "@fncts/base/typeclass/Ordering";
 import { Semigroup } from "@fncts/base/typeclass/Semigroup";
-
 /**
  * @tsplus static fncts.OrdOps getSemigroup
  */
@@ -18,7 +17,6 @@ export function getSemigroup<A = never>(): Semigroup<Ord<A>> {
       }),
   });
 }
-
 /**
  * @tsplus static fncts.OrdOps getMonoid
  */

package/_src/typeclass/Ordering.ts

@@ -4,10 +4,12 @@ export type Ordering = -1 | 0 | 1;
  * @tsplus static fncts.Ordering LT
  */
 export const LT = -1;
+
 /**
  * @tsplus static fncts.Ordering EQ
  */
 export const EQ = 0;
+
 /**
  * @tsplus static fncts.Ordering GT
  */

package/_src/typeclass/Semialign.ts

@@ -18,8 +18,7 @@ export interface SemialignOps {}
 export const Semialign: SemialignOps = {};
 
 export interface align<F extends HKT, FC = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
     fb: HKT.Kind<
       F,
       FC,
@@ -33,7 +32,9 @@ export interface align<F extends HKT, FC = HKT.None> {
       HKT.Intro<F, "E", E, E1>,
       B
     >,
-  ): HKT.Kind<
+  ): <A>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -53,8 +54,7 @@ export interface align<F extends HKT, FC = HKT.None> {
  */
 export function align<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
   fb: HKT.Kind<
     F,
     FC,
@@ -68,6 +68,8 @@ export function align<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E, E1>,
     B
   >,
+) => <A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -81,12 +83,11 @@ export function align<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   These<A, B>
 > {
-  return (fa, fb) => F.alignWith(fa, fb, identity);
+  return (fb) => F.alignWith(fb, identity);
 }
 
 export interface alignWith<F extends HKT, FC = 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, FC, K, Q, W, X, I, S, R, E, A>,
     fb: HKT.Kind<
       F,
       FC,
@@ -101,7 +102,9 @@ export interface alignWith<F extends HKT, FC = HKT.None> {
       B
     >,
     f: (th: These<A, B>) => C,
-  ): HKT.Kind<
+  ): (
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -122,7 +125,6 @@ export interface alignWith<F extends HKT, FC = HKT.None> {
 export function alignWith<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
 ): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   fb: HKT.Kind<
     F,
     FC,
@@ -137,6 +139,8 @@ export function alignWith<F extends HKT, FC = HKT.None>(
     B
   >,
   f: (th: These<A, B>) => C,
+) => (
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -150,12 +154,11 @@ export function alignWith<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   C
 > {
-  return (fa, fb, f) => F.alignWith(fa, fb, f);
+  return (fb, f) => F.alignWith(fb, f);
 }
 
 export interface alignCombine<F extends HKT, FC = HKT.None> {
   <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1>(
-    self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     that: HKT.Kind<
       F,
       FC,
@@ -170,7 +173,9 @@ export interface alignCombine<F extends HKT, FC = HKT.None> {
       A
     >,
     S: Semigroup<A>,
-  ): HKT.Kind<
+  ): (
+    self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -191,7 +196,6 @@ export interface alignCombine<F extends HKT, FC = HKT.None> {
 export function alignCombine<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
 ): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   that: HKT.Kind<
     F,
     FC,
@@ -206,6 +210,8 @@ export function alignCombine<F extends HKT, FC = HKT.None>(
     A
   >,
   /** @tsplus auto */ S: Semigroup<A>,
+) => (
+  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -219,12 +225,11 @@ export function alignCombine<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   A
 > {
-  return (self, that, S) => F.alignWith(self, that, (th) => th.match(identity, identity, S.combine));
+  return (that, S) => F.alignWith(that, (th) => th.match(identity, identity, S.combine));
 }
 
 export interface padZip<F extends HKT, FC = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
     fb: HKT.Kind<
       F,
       FC,
@@ -238,7 +243,9 @@ export interface padZip<F extends HKT, FC = HKT.None> {
       HKT.Intro<F, "E", E, E1>,
       B
     >,
-  ): HKT.Kind<
+  ): <A>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -254,12 +261,11 @@ export interface padZip<F extends HKT, FC = HKT.None> {
 }
 
 /**
- * @tsplus fluent fncts.Kind padZip
+ * @tsplus pipeable fncts.Kind padZip
  */
 export function padZip<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
   fb: HKT.Kind<
     F,
     FC,
@@ -273,6 +279,8 @@ export function padZip<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E, E1>,
     B
   >,
+) => <A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -286,12 +294,11 @@ export function padZip<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   readonly [Maybe<A>, Maybe<B>]
 > {
-  return (fa, fb) => Semialign.padZipWith(F)(fa, fb, identity);
+  return (fb) => Semialign.padZipWith(F)(fb, identity);
 }
 
 export interface padZipWith<F extends HKT, FC = 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, FC, K, Q, W, X, I, S, R, E, A>,
     fb: HKT.Kind<
       F,
       FC,
@@ -306,7 +313,9 @@ export interface padZipWith<F extends HKT, FC = HKT.None> {
       B
     >,
     f: (_: readonly [Maybe<A>, Maybe<B>]) => D,
-  ): HKT.Kind<
+  ): (
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -327,7 +336,6 @@ export interface padZipWith<F extends HKT, FC = HKT.None> {
 export function padZipWith<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
 ): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, D>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   fb: HKT.Kind<
     F,
     FC,
@@ -342,6 +350,8 @@ export function padZipWith<F extends HKT, FC = HKT.None>(
     B
   >,
   f: (_: readonly [Maybe<A>, Maybe<B>]) => D,
+) => (
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -355,8 +365,8 @@ export function padZipWith<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   D
 > {
-  return (fa, fb, f) =>
-    F.alignWith(fa, fb, (th) =>
+  return (fb, f) =>
+    F.alignWith(fb, (th) =>
       th.match(
         (a) => f([Just(a), Nothing()]),
         (b) => f([Nothing(), Just(b)]),
@@ -364,10 +374,8 @@ export function padZipWith<F extends HKT, FC = HKT.None>(
       ),
     );
 }
-
 export interface zipAll<F extends HKT, FC = HKT.None> {
   <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     fb: HKT.Kind<
       F,
       FC,
@@ -383,7 +391,9 @@ export interface zipAll<F extends HKT, FC = HKT.None> {
     >,
     a: A,
     b: B,
-  ): HKT.Kind<
+  ): (
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -404,7 +414,6 @@ export interface zipAll<F extends HKT, FC = HKT.None> {
 export function zipAll<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
 ): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   fb: HKT.Kind<
     F,
     FC,
@@ -420,6 +429,8 @@ export function zipAll<F extends HKT, FC = HKT.None>(
   >,
   a: A,
   b: B,
+) => (
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -433,8 +444,8 @@ export function zipAll<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   readonly [A, B]
 > {
-  return (fa, fb, a, b) =>
-    F.alignWith(fa, fb, (th) =>
+  return (fb, a, b) =>
+    F.alignWith(fb, (th) =>
       th.match(
         (x) => [x, b],
         (x) => [a, x],

package/_src/typeclass/Semigroup/api.ts

@@ -1,7 +1,6 @@
 import type { Ord } from "@fncts/base/typeclass/Ord";
 
 import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
-
 /**
  * @tsplus static fncts.SemigroupOps min
  */
@@ -10,7 +9,6 @@ export function min<A>(O: Ord<A>): Semigroup<A> {
     combine: O.min,
   });
 }
-
 /**
  * @tsplus static fncts.SemigroupOps max
  */

package/_src/typeclass/Semigroup/definition.ts

@@ -1,19 +1,15 @@
 import type { Closure } from "@fncts/base/typeclass/Closure";
 
 import { mkClosure } from "@fncts/base/typeclass/Closure";
-
 /**
  * @tsplus type fncts.Semigroup
  */
 export interface Semigroup<A> extends Closure<A> {}
-
 /**
  * @tsplus type fncts.SemigroupOps
  */
 export interface SemigroupOps {}
-
 export const Semigroup: SemigroupOps = {};
-
 /**
  * @tsplus static fncts.SemigroupOps __call
  */