@fncts/base 0.0.1 → 0.0.4

package/_src/typeclass/Functor.ts

@@ -1,11 +1,11 @@
 /**
  * @tsplus type fncts.Functor
  */
-export interface Functor<F extends HKT, C = HKT.None> extends HKT.Typeclass<F, C> {
-  readonly map_: map_<F, C>;
-  readonly map: map<F, C>;
-  readonly as_: as_<F, C>;
-  readonly as: as<F, C>;
+export interface Functor<F extends HKT> extends HKT.Typeclass<F> {
+  map<K, Q, W, X, I, S, R, E, A, B>(
+    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    f: (a: A) => B,
+  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
 }
 
 /**
@@ -15,62 +15,24 @@ export interface FunctorOps {}
 
 export const Functor: FunctorOps = {};
 
-export type FunctorMin<F extends HKT, C = HKT.None> = {
-  readonly map_: map_<F, C>;
-};
-
 /**
- * @tsplus static fncts.FunctorOps __call
+ * @tsplus fluent fncts.Kind map
  */
-export function mkFunctor<F extends HKT, C = HKT.None>(F: FunctorMin<F, C>): Functor<F, C> {
-  return HKT.instance<Functor<F, C>>({
-    map_: F.map_,
-    map: (f) => (fa) => F.map_(fa, f),
-    as_: (fa, b) => F.map_(fa, () => b()),
-    as: (b) => (fa) => F.map_(fa, () => b()),
-  });
-}
-
-export interface map_<F extends HKT, C = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (a: A) => B): HKT.Kind<
-    F,
-    C,
-    K,
-    Q,
-    W,
-    X,
-    I,
-    S,
-    R,
-    E,
-    B
-  >;
-}
-
-export interface map<F extends HKT, C = HKT.None> {
-  <A, B>(f: (a: A) => B): <K, Q, W, X, I, S, R, E>(
-    fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>,
-  ) => HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
+export function map<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
+  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+  f: (a: A) => B,
+  /** @tsplus auto */ F: Functor<F>,
+): HKT.Kind<F, K, Q, W, X, I, S, R, E, B> {
+  return F.map(fa, f);
 }
 
-export interface as_<F extends HKT, C = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, b: Lazy<B>): HKT.Kind<
-    F,
-    C,
-    K,
-    Q,
-    W,
-    X,
-    I,
-    S,
-    R,
-    E,
-    B
-  >;
-}
-
-export interface as<F extends HKT, C = HKT.None> {
-  <B>(b: Lazy<B>): <K, Q, W, X, I, S, R, E, A>(
-    fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>,
-  ) => HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
+/**
+ * @tsplus fluent fncts.Kind as
+ */
+export function as<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(
+  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+  b: Lazy<B>,
+  /** @tsplus auto */ F: Functor<F>,
+): HKT.Kind<F, K, Q, W, X, I, S, R, E, B> {
+  return fa.map(() => b(), F);
 }

package/_src/typeclass/FunctorWithIndex.ts

@@ -1,43 +1,15 @@
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
+import type { Functor } from "@fncts/base/typeclass/Functor";
 
-import { Functor } from "@fncts/base/typeclass/Functor";
-
-export interface FunctorWithIndex<F extends HKT, C = HKT.None> extends Functor<F, C> {
-  readonly mapWithIndex_: mapWithIndex_<F, C>;
-  readonly mapWithIndex: mapWithIndex<F, C>;
+export interface FunctorWithIndex<F extends HKT> extends Functor<F> {
+  mapWithIndex<K, W, Q, X, I, S, R, E, A, B>(
+    fa: HKT.Kind<F, K, W, Q, X, I, S, R, E, A>,
+    f: (i: HKT.IndexFor<F, K>, a: A) => B,
+  ): HKT.Kind<F, K, W, Q, X, I, S, R, E, B>;
 }
 
-export type FunctorWithIndexMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
-  readonly mapWithIndex_: mapWithIndex_<F, FC>;
-};
-
 /**
  * @tsplus type fncts.FunctorWithIndexOps
  */
 export interface FunctorWithIndexOps {}
 
 export const FunctorWithIndex: FunctorWithIndexOps = {};
-
-/**
- * @tsplus static fncts.FunctorWithIndexOps __call
- */
-export function mkFunctorWithIndex<F extends HKT, C = HKT.None>(F: FunctorWithIndexMin<F, C>): FunctorWithIndex<F, C> {
-  return HKT.instance<FunctorWithIndex<F, C>>({
-    ...Functor(F),
-    mapWithIndex_: F.mapWithIndex_,
-    mapWithIndex: (f) => (fa) => F.mapWithIndex_(fa, f),
-  });
-}
-
-export interface mapWithIndex_<F extends HKT, C = HKT.None> {
-  <K, W, Q, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, C, K, W, Q, X, I, S, R, E, A>,
-    f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => B,
-  ): HKT.Kind<F, C, K, W, Q, X, I, S, R, E, B>;
-}
-
-export interface mapWithIndex<F extends HKT, C = HKT.None> {
-  <K, A, B>(f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => B): <W, Q, X, I, S, R, E>(
-    fa: HKT.Kind<F, C, K, W, Q, X, I, S, R, E, A>,
-  ) => HKT.Kind<F, C, K, W, Q, X, I, S, R, E, B>;
-}

package/_src/typeclass/Guard/api.ts

@@ -0,0 +1,32 @@
+import type { Check } from "@fncts/typelevel/Check";
+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
+ */
+export function is<A>(self: Guard<A>, u: unknown): u is A {
+  return self.is(u);
+}
+
+/**
+ * @tsplus fluent 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);
+}
+
+/**
+ * @tsplus fluent 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");
+  }
+}

package/_src/typeclass/Guard/definition.ts

@@ -0,0 +1,23 @@
+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
+ */
+export class Guard<A> {
+  readonly _typeId: GuardTypeId = GuardTypeId;
+  readonly [HKT.F]!: GuardF;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Guard<HKT._A<this>>;
+  constructor(readonly is: Refinement<unknown, A>) {}
+}
+
+/**
+ * @tsplus static fncts.GuardOps __call
+ */
+export function makeGuard<A>(refinement: Refinement<unknown, A>): Guard<A> {
+  return new Guard(refinement);
+}

package/_src/typeclass/Guard/derivations.ts

@@ -0,0 +1,80 @@
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+
+/**
+ * @tsplus derive fncts.Guard lazy
+ */
+export function deriveLazy<A>(
+  f: (_: Guard<A>) => Guard<A>
+): Guard<A> {
+  let cached: Guard<A> | undefined;
+  const guard: Guard<A> = Guard((u: unknown): u is A => {
+    if (!cached) {
+      cached = f(guard);
+    }
+    return cached.is(u);
+  });
+  return guard;
+}
+
+/**
+ * @tsplus derive fncts.Guard<_> 20
+ */
+export function deriveLiteral<A extends string | number | boolean>(
+  ...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never
+): Guard<A> {
+  return Guard((u): u is A => u === value);
+}
+
+/**
+ * @tsplus derive fncts.Guard<_> 20
+ */
+export function deriveStruct<A extends Record<string, any>>(
+  ...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+      requiredFields: {
+        [k in RequiredKeys<A>]: Guard<A[k]>;
+      }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [] : [
+      optionalFields: {
+        [k in OptionalKeys<A>]: Guard<NonNullable<A[k]>>;
+      }
+    ])
+  ]
+    : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (!isObject(u)) {
+      return false;
+    }
+
+    for (const key in requiredFields) {
+      if (!(key in u) || !(requiredFields[key] as Guard<any>).is(u[key])) {
+        return false;
+      }
+    }
+    if (optionalFields) {
+      for (const key in optionalFields) {
+        if (key in u && typeof u[key] !== "undefined" && !(optionalFields[key] as Guard<any>).is(u[key])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Guard<|> 30
+ */
+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)) {
+        return true;
+      }
+    }
+    return false;
+  });
+}

package/_src/typeclass/Guard.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: ./Guard/*.ts, exclude: ./Guard/derivations.ts }
+export * from "./Guard/api.js";
+export * from "./Guard/definition.js";
+// codegen:end
+

package/_src/typeclass/HashEq.ts

@@ -1,4 +1,3 @@
-import type { EqMin } from "./Eq.js";
 import type { Hash } from "./Hash.js";
 
 import { Eq } from "./Eq.js";
@@ -15,7 +14,7 @@ export interface HashEqOps {}
 
 export const HashEq: HashEqOps = {};
 
-export type HashEqMin<A> = Hash<A> & EqMin<A>;
+export type HashEqMin<A> = Hash<A> & Eq<A>;
 
 /**
  * @tsplus static fncts.HashEqOps __call
@@ -32,7 +31,7 @@ export function mkHashEq<A>(F: HashEqMin<A>): HashEq<A> {
  */
 export const StructuralStrict = HashEq({
   hash: Hashable.unknown,
-  equals_: Equatable.strictEquals,
+  equals: Equatable.strictEquals,
 });
 
 /**
@@ -40,5 +39,5 @@ export const StructuralStrict = HashEq({
  */
 export const StructuralDeep = HashEq({
   hash: Hashable.unknown,
-  equals_: Equatable.deepEquals,
+  equals: Equatable.deepEquals,
 });

package/_src/typeclass/Monad.ts

@@ -1,10 +1,7 @@
-import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
-import type { ChainMin } from "@fncts/base/typeclass/Chain";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { FlatMap } from "@fncts/base/typeclass/Chain";
 
-import { Applicative } from "@fncts/base/typeclass/Applicative";
-import { FlatMap } from "@fncts/base/typeclass/Chain";
-
-export interface Monad<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, FlatMap<F, FC> {}
+export interface Monad<F extends HKT> extends Applicative<F>, FlatMap<F> {}
 
 /**
  * @tsplus type fncts.MonadOps
@@ -12,15 +9,3 @@ export interface Monad<F extends HKT, FC = HKT.None> extends Applicative<F, FC>,
 export interface MonadOps {}
 
 export const Monad: MonadOps = {};
-
-export type MonadMin<F extends HKT, FC = HKT.None> = ApplicativeMin<F, FC> & ChainMin<F, FC>;
-
-/**
- * @tsplus static fncts.MonadOps __call
- */
-export function mkMonad<F extends HKT, FC = HKT.None>(F: MonadMin<F, FC>): Monad<F, FC> {
-  return HKT.instance<Monad<F, FC>>({
-    ...Applicative(F),
-    ...FlatMap(F),
-  });
-}

package/_src/typeclass/MonadExcept.ts

@@ -1,15 +1,10 @@
-import type { ApplicativeExceptMin } from "@fncts/base/typeclass/ApplicativeExcept";
-import type { MonadMin } from "@fncts/base/typeclass/Monad";
-
-import { ApplicativeExcept } from "@fncts/base/typeclass/ApplicativeExcept";
-import { Monad } from "@fncts/base/typeclass/Monad";
+import type { ApplicativeExcept } from "@fncts/base/typeclass/ApplicativeExcept";
+import type { Monad } from "@fncts/base/typeclass/Monad";
 
 /**
  * @tsplus type fncts.MonadExcept
  */
-export interface MonadExcept<F extends HKT.CovariantE, FC = HKT.None> extends Monad<F, FC>, ApplicativeExcept<F, FC> {
-  readonly absolve: absolve<F, FC>;
-}
+export interface MonadExcept<F> extends Monad<F>, ApplicativeExcept<F> {}
 
 /**
  * @tsplus type fncts.MonadExceptOps
@@ -18,30 +13,12 @@ export interface MonadExceptOps {}
 
 export const MonadExcept: MonadExceptOps = {};
 
-export type MonadExceptMin<F extends HKT.CovariantE, FC = HKT.None> = MonadMin<F, FC> & ApplicativeExceptMin<F, FC>;
-
-/**
- * @tsplus static fncts.MonadExceptOps __call
- */
-export function mkMonadExcept<F extends HKT.CovariantE, FC = HKT.None>(F: MonadExceptMin<F, FC>): MonadExcept<F, FC>;
-export function mkMonadExcept<F>(F: MonadExceptMin<HKT.FCoE<F>>): MonadExcept<HKT.FCoE<F>> {
-  return HKT.instance<MonadExcept<HKT.FCoE<F>>>({
-    ...Monad(F),
-    ...ApplicativeExcept(F),
-    absolve: absolveF(F),
-  });
-}
-
-export interface absolve<F extends HKT, FC = HKT.None> {
-  <K, Q, W, X, I, S, R, E, E1, A>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, Either<HKT.OrFix<FC, "E", E1>, A>>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, HKT.Mix<F, "E", [E, E1]>, A>;
-}
-
 /**
- * @tsplus static fncts.MonadExceptOps absolveF
+ * @tsplus fluent fncts.Kind absolve
  */
-export function absolveF<F extends HKT.CovariantE, FC = HKT.None>(F: MonadExceptMin<F, FC>): absolve<F, FC>;
-export function absolveF<F>(F: MonadExceptMin<HKT.FCoE<F>>): absolve<HKT.FCoE<F>> {
-  return (fa) => F.flatMap_(fa, (r) => r.match(F.fail, F.pure));
+export function absolve<F extends HKT, K, Q, W, X, I, S, R, E, E1, A>(
+  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, Either<E1, A>>,
+  /** @tsplus auto */ F: MonadExcept<F>,
+): HKT.Kind<F, K, Q, W, X, I, S, R, HKT.Mix<"E", [E, E1]>, A> {
+  return fa.flatMap((r) => r.match(F.fail, F.pure), F);
 }

package/_src/typeclass/Monoid.ts

@@ -1,4 +1,5 @@
-import type { SemigroupMin } from "@fncts/base/typeclass/Semigroup";
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 
 import { Semigroup } from "@fncts/base/typeclass/Semigroup";
 
@@ -16,7 +17,7 @@ export interface MonoidOps {}
 
 export const Monoid: MonoidOps = {};
 
-export type MonoidMin<A> = SemigroupMin<A> & {
+export type MonoidMin<A> = Semigroup<A> & {
   readonly nat: A;
 };
 
@@ -29,3 +30,60 @@ export function mkMonoid<A>(F: MonoidMin<A>): Monoid<A> {
     nat: F.nat,
   };
 }
+
+/**
+ * @tsplus derive fncts.Monoid lazy
+ */
+export function deriveLazy<A>(fn: (_: Monoid<A>) => Monoid<A>): Monoid<A> {
+  let cached: Monoid<A> | undefined;
+  const M: Monoid<A> = Monoid({
+    combine: (x, y) => {
+      if (!cached) {
+        cached = fn(M);
+      }
+      return cached.combine(x, y);
+    },
+    get nat() {
+      if (!cached) {
+        cached = fn(M);
+      }
+      return cached.nat;
+    }
+  });
+  return M;
+}
+
+/**
+ * @tsplus derive fncts.Monoid<_> 20
+ */
+export function deriveStruct<A extends Record<string, any>>(
+  ...args: Check<Check.IsStruct<A>> extends Check.True
+    ? [
+        ...[
+          requiredFields: {
+            [K in RequiredKeys<A>]: Monoid<A[K]>;
+          },
+        ],
+        ...([OptionalKeys<A>] extends [never]
+          ? []
+          : [
+              optionalFields: {
+                [K in OptionalKeys<A>]: Monoid<NonNullable<A[K]>>;
+              },
+            ]),
+      ]
+    : never
+): Monoid<A> {
+  const [ requiredFields, optionalFields ] = args;
+  const nat: Record<string, unknown>       = {};
+  for (const field in requiredFields) {
+    nat[field] = (requiredFields[field] as Monoid<any>).nat;
+  }
+  for (const field in optionalFields) {
+    nat[field] = (optionalFields[field] as Monoid<any>).nat;
+  }
+  return Monoid({
+    ...Semigroup.deriveStruct<A>(...args),
+    nat: nat as A
+  });
+}

package/_src/typeclass/Nil.ts

@@ -1,23 +1,32 @@
 /**
  * @tsplus type fncts.Nil
  */
-export interface Nil<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
-  readonly nil: nil<F, FC>;
+export interface Nil<F extends HKT> extends HKT.Typeclass<F> {
+  nil<
+    K = HKT.Low<"K">,
+    Q = HKT.Low<"Q">,
+    W = HKT.Low<"W">,
+    X = HKT.Low<"X">,
+    I = HKT.Low<"I">,
+    S = HKT.Low<"S">,
+    R = HKT.Low<"R">,
+    E = HKT.Low<"E">,
+  >(): HKT.Kind<F, K, Q, W, X, I, S, R, E, never>;
 }
 
-export type NilMin<F extends HKT, FC = HKT.None> = {
-  readonly nil: nil<F, FC>;
-};
-
-export interface nil<F extends HKT, FC = HKT.None> {
-  <
-    K = HKT.Low<F, "K">,
-    Q = HKT.Low<F, "Q">,
-    W = HKT.Low<F, "W">,
-    X = HKT.Low<F, "X">,
-    I = HKT.Low<F, "I">,
-    S = HKT.Low<F, "S">,
-    R = HKT.Low<F, "R">,
-    E = HKT.Low<F, "E">,
-  >(): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, never>;
+/**
+ * @tsplus fluent fncts.Kind nil
+ */
+export function nil<
+  F extends HKT,
+  K = HKT.Low<"K">,
+  Q = HKT.Low<"Q">,
+  W = HKT.Low<"W">,
+  X = HKT.Low<"X">,
+  I = HKT.Low<"I">,
+  S = HKT.Low<"S">,
+  R = HKT.Low<"R">,
+  E = HKT.Low<"E">,
+>(/** @tsplus auto */ F: Nil<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, never> {
+  return F.nil();
 }

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

@@ -5,9 +5,7 @@ import type { Ord } from "@fncts/base/typeclass/Ord/definition";
  */
 export function contramap<A, B>(self: Ord<A>, f: (b: B) => A): Ord<B> {
   return {
-    compare_: (x, y) => self.compare_(f(x), f(y)),
-    compare: (y) => (x) => self.compare_(f(x), f(y)),
-    equals_: (x, y) => self.equals_(f(x), f(y)),
-    equals: (y) => (x) => self.equals_(f(x), f(y)),
+    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

@@ -5,5 +5,5 @@ import type { Ord } from "@fncts/base/typeclass/Ord/definition";
  * @tsplus getter fncts.Ord max
  */
 export function max_<A>(O: Ord<A>): (x: A, y: A) => A {
-  return (x, y) => (x === y || O.compare_(x, y) > -1 ? x : y);
+  return (x, y) => (x === y || O.compare(x, y) > -1 ? x : y);
 }

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

@@ -5,5 +5,5 @@ import type { Ord } from "@fncts/base/typeclass/Ord/definition";
  * @tsplus getter fncts.Ord min
  */
 export function min_<A>(O: Ord<A>): (x: A, y: A) => A {
-  return (x, y) => (x === y || O.compare_(x, y) < 1 ? x : y);
+  return (x, y) => (x === y || O.compare(x, y) < 1 ? x : y);
 }

package/_src/typeclass/Ord/definition.ts

@@ -1,4 +1,3 @@
-import type { equals_ } from "@fncts/base/typeclass/Eq";
 import type { Ordering } from "@fncts/base/typeclass/Ordering";
 
 import { Eq } from "@fncts/base/typeclass/Eq";
@@ -7,8 +6,7 @@ import { Eq } from "@fncts/base/typeclass/Eq";
  * @tsplus type fncts.Ord
  */
 export interface Ord<A> extends Eq<A> {
-  readonly compare_: compare_<A>;
-  readonly compare: compare<A>;
+  readonly compare: (x: A, y: A) => Ordering;
 }
 
 /**
@@ -18,26 +16,12 @@ export interface OrdOps {}
 
 export const Ord: OrdOps = {};
 
-export type OrdMin<A> = {
-  compare_: compare_<A>;
-  equals_: equals_<A>;
-};
-
 /**
  * @tsplus static fncts.OrdOps __call
  */
-export function mkOrd<A>(O: OrdMin<A>): Ord<A> {
+export function mkOrd<A>(O: Ord<A>): Ord<A> {
   return {
     ...Eq(O),
-    compare_: O.compare_,
-    compare: (y) => (x) => O.compare_(x, y),
+    compare: O.compare,
   };
 }
-
-export interface compare_<A> {
-  (x: A, y: A): Ordering;
-}
-
-export interface compare<A> {
-  (y: A): (x: A) => Ordering;
-}

package/_src/typeclass/Ord/instances.ts

@@ -8,13 +8,13 @@ import { Semigroup } from "@fncts/base/typeclass/Semigroup";
  */
 export function getSemigroup<A = never>(): Semigroup<Ord<A>> {
   return Semigroup({
-    combine_: (x, y) =>
+    combine: (x, y) =>
       Ord({
-        compare_: (a1, a2) => {
-          const ox = x.compare_(a1, a2);
-          return ox !== 0 ? ox : y.compare_(a1, a2);
+        compare: (a1, a2) => {
+          const ox = x.compare(a1, a2);
+          return ox !== 0 ? ox : y.compare(a1, a2);
         },
-        equals_: (a1, a2) => x.equals_(a1, a2) && y.equals_(a1, a2),
+        equals: (a1, a2) => x.equals(a1, a2) && y.equals(a1, a2),
       }),
   });
 }
@@ -25,6 +25,6 @@ export function getSemigroup<A = never>(): Semigroup<Ord<A>> {
 export function getMonoid<A = never>(): Monoid<Ord<A>> {
   return Monoid({
     ...Ord.getSemigroup<A>(),
-    nat: Ord({ compare_: () => Ordering.EQ, equals_: () => true }),
+    nat: Ord({ compare: () => Ordering.EQ, equals: () => true }),
   });
 }