@fncts/base 0.0.20 → 0.0.22

package/_src/data/Interval.ts

@@ -33,49 +33,57 @@ export function isEmpty(self: Interval): boolean {
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval intersect
+ * @tsplus pipeable fncts.io.Schedule.Interval intersect
  */
-export function intersect_(self: Interval, that: Interval): Interval {
-  const start = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const end   = Math.min(self.endMilliseconds, that.endMilliseconds);
-  return Interval(start, end);
+export function intersect_(that: Interval) {
+  return (self: Interval): Interval => {
+    const start = Math.max(self.startMilliseconds, that.startMilliseconds);
+    const end   = Math.min(self.endMilliseconds, that.endMilliseconds);
+    return Interval(start, end);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval lt
- * @tsplus operator fncts.io.Schedule.Interval <
+ * @tsplus pipeable fncts.io.Schedule.Interval lt
+ * @tsplus pipeable-operator fncts.io.Schedule.Interval <
  */
-export function lt_(self: Interval, that: Interval): boolean {
-  return self.min(that) === self;
+export function lt(that: Interval) {
+  return (self: Interval): boolean => {
+    return self.min(that) === self;
+  };
 }
 
 /**
  * @tsplus static fncts.io.Schedule.IntervalOps __call
  */
 export function makeInterval(start: number, end: number): Interval {
-  if (start <= end) return Interval(start, end);
+  if (start <= end) return new Interval(start, end);
   else return Interval.empty;
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval max
+ * @tsplus pipeable fncts.io.Schedule.Interval max
  */
-export function max_(self: Interval, that: Interval): Interval {
-  const m = self.min(that);
-  if (m === self) return that;
-  else return self;
+export function max(that: Interval) {
+  return (self: Interval): Interval => {
+    const m = self.min(that);
+    if (m === self) return that;
+    else return self;
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval min
+ * @tsplus pipeable fncts.io.Schedule.Interval min
  */
-export function min_(self: Interval, that: Interval): Interval {
-  if (self.endMilliseconds <= that.startMilliseconds) return self;
-  if (that.endMilliseconds <= self.startMilliseconds) return that;
-  if (self.startMilliseconds < that.startMilliseconds) return self;
-  if (that.startMilliseconds < self.startMilliseconds) return that;
-  if (self.endMilliseconds <= that.endMilliseconds) return self;
-  return that;
+export function min(that: Interval) {
+  return (self: Interval): Interval => {
+    if (self.endMilliseconds <= that.startMilliseconds) return self;
+    if (that.endMilliseconds <= self.startMilliseconds) return that;
+    if (self.startMilliseconds < that.startMilliseconds) return self;
+    if (that.startMilliseconds < self.startMilliseconds) return that;
+    if (self.endMilliseconds <= that.endMilliseconds) return self;
+    return that;
+  };
 }
 
 /**
@@ -88,16 +96,18 @@ export function isNonEmpty(self: Interval): boolean {
 /**
  * @tsplus getter fncts.io.Schedule.Interval size
  */
-export function size(self: Interval): number {
-  return self.endMilliseconds - self.startMilliseconds;
+export function size(self: Interval): Duration {
+  return Duration.fromInterval(self.startMilliseconds, self.endMilliseconds);
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval union
+ * @tsplus pipeable fncts.io.Schedule.Interval union
  */
-export function union_(self: Interval, that: Interval): Maybe<Interval> {
-  const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const iend   = Math.min(self.endMilliseconds, that.endMilliseconds);
-  if (istart <= iend) return Nothing();
-  else return Just(Interval(istart, iend));
+export function union(that: Interval) {
+  return (self: Interval): Maybe<Interval> => {
+    const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
+    const iend   = Math.min(self.endMilliseconds, that.endMilliseconds);
+    if (istart <= iend) return Nothing();
+    else return Just(Interval(istart, iend));
+  };
 }

package/_src/data/Intervals.ts

@@ -14,19 +14,21 @@ export function make(intervals: List<Interval>): Intervals {
 }
 
 /**
- * @tsplus fluent fncts.Intervals union
- * @tsplus operator fncts.Intervals ||
+ * @tsplus pipeable fncts.Intervals union
+ * @tsplus pipeable-operator fncts.Intervals ||
  */
-export function union(self: Intervals, that: Intervals): Intervals {
-  if (that.intervals.isEmpty()) {
-    return self;
-  } else if (self.intervals.isEmpty()) {
-    return that;
-  } else if (self.intervals.head.startMilliseconds < that.intervals.head.startMilliseconds) {
-    return unionLoop(self.intervals.tail, that.intervals, self.intervals.head, Nil());
-  } else {
-    return unionLoop(self.intervals, that.intervals.tail, that.intervals.head, Nil());
-  }
+export function union(that: Intervals) {
+  return (self: Intervals): Intervals => {
+    if (that.intervals.isEmpty()) {
+      return self;
+    } else if (self.intervals.isEmpty()) {
+      return that;
+    } else if (self.intervals.head.startMilliseconds < that.intervals.head.startMilliseconds) {
+      return unionLoop(self.intervals.tail, that.intervals, self.intervals.head, Nil());
+    } else {
+      return unionLoop(self.intervals, that.intervals.tail, that.intervals.head, Nil());
+    }
+  };
 }
 
 /**
@@ -64,11 +66,13 @@ function unionLoop(left: List<Interval>, right: List<Interval>, interval: Interv
 }
 
 /**
- * @tsplus fluent fncts.Intervals intersect
- * @tsplus operator fncts.Intervals &&
+ * @tsplus pipeable fncts.Intervals intersect
+ * @tsplus pipeable-operator fncts.Intervals &&
  */
-export function intersect(self: Intervals, that: Intervals): Intervals {
-  return intersectLoop(self.intervals, that.intervals, Nil());
+export function intersect(that: Intervals) {
+  return (self: Intervals): Intervals => {
+    return intersectLoop(self.intervals, that.intervals, Nil());
+  };
 }
 
 /**
@@ -104,18 +108,22 @@ export function end(self: Intervals): number {
 }
 
 /**
- * @tsplus fluent fncts.Intervals lt
- * @tsplus operator fncts.Intervals <
+ * @tsplus pipeable fncts.Intervals lt
+ * @tsplus pipeable-operator fncts.Intervals <
  */
-export function lt(self: Intervals, that: Intervals): boolean {
-  return self.start < that.start;
+export function lt(that: Intervals) {
+  return (self: Intervals): boolean => {
+    return self.start < that.start;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Intervals max
+ * @tsplus pipeable fncts.Intervals max
  */
-export function max(self: Intervals, that: Intervals): Intervals {
-  return self < that ? that : self;
+export function max(that: Intervals) {
+  return (self: Intervals): Intervals => {
+    return self < that ? that : self;
+  };
 }
 
 /**

package/_src/data/Maybe/api.ts

@@ -5,57 +5,68 @@ import { identity } from "../function.js";
 import { MaybeTag } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.Maybe ap
+ * @tsplus pipeable fncts.Maybe ap
  */
-export function ap_<A, B>(self: Maybe<(a: A) => B>, fa: Maybe<A>): Maybe<B> {
-  self.concrete();
-  fa.concrete();
-  return self._tag === MaybeTag.Just && fa._tag === MaybeTag.Just ? Just(self.value(fa.value)) : Nothing();
+export function ap<A>(fa: Maybe<A>) {
+  return <B>(self: Maybe<(a: A) => B>): Maybe<B> => {
+    self.concrete();
+    fa.concrete();
+    return self._tag === MaybeTag.Just && fa._tag === MaybeTag.Just ? Just(self.value(fa.value)) : Nothing();
+  };
 }
 
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
  * otherwise returns `Nothing`.
  *
- * @tsplus fluent fncts.Maybe flatMap
+ * @tsplus pipeable fncts.Maybe flatMap
  */
-export function flatMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B> {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? f(self.value) : (self as Nothing);
+export function flatMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: Maybe<A>): Maybe<B> => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? f(self.value) : (self as Nothing);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe elem
+ * @tsplus pipeable fncts.Maybe elem
  */
-export function elem_<A>(self: Maybe<A>, elem: A, E: Eq<A>): boolean {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? E.equals(self.value, elem) : false;
+export function elem<A>(elem: A, /** @tsplus auto */ E: Eq<A>) {
+  return (self: Maybe<A>): boolean => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? E.equals(elem)(self.value) : false;
+  };
 }
 
 /**
- * @constrained
- * @tsplus fluent fncts.Maybe exists
+ * @tsplus pipeable fncts.Maybe some
  */
-export function exists_<A>(self: Maybe<A>, p: Predicate<A>): boolean {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? p(self.value) : false;
+export function some<A>(p: Predicate<A>) {
+  return (self: Maybe<A>): boolean => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? p(self.value) : false;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe filter
+ * @tsplus pipeable fncts.Maybe filter
  */
-export function filter_<A, B>(self: Maybe<A>, p: Predicate<A>): Maybe<A>;
-export function filter_<A, B extends A>(self: Maybe<A>, p: Refinement<A, B>): Maybe<B>;
-export function filter_<A, B>(self: Maybe<A>, p: Predicate<A>): Maybe<A> {
-  self.concrete();
-  return self._tag === MaybeTag.Just && p(self.value) ? self : Nothing();
+export function filter<A>(p: Predicate<A>): <B>(self: Maybe<A>) => Maybe<A>;
+export function filter<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => Maybe<B>;
+export function filter<A>(p: Predicate<A>) {
+  return <B>(self: Maybe<A>): Maybe<A> => {
+    self.concrete();
+    return self._tag === MaybeTag.Just && p(self.value) ? self : Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe filter
+ * @tsplus pipeable fncts.Maybe filter
  */
-export function filterMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B> {
-  return self.flatMap(f);
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: Maybe<A>): Maybe<B> => {
+    return self.flatMap(f);
+  };
 }
 
 /**
@@ -66,89 +77,107 @@ export function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A> {
 }
 
 /**
- * @tsplus fluent fncts.Maybe partition
+ * @tsplus pipeable fncts.Maybe partition
  */
-export function partition_<A>(self: Maybe<A>, p: Predicate<A>): readonly [Maybe<A>, Maybe<A>];
-export function partition_<A, B extends A>(self: Maybe<A>, p: Refinement<A, B>): readonly [Maybe<A>, Maybe<B>];
-export function partition_<A>(self: Maybe<A>, p: Predicate<A>): readonly [Maybe<A>, Maybe<A>] {
-  self.concrete();
-  return self._tag === MaybeTag.Just && p(self.value) ? [Nothing(), self] : [self, Nothing()];
+export function partition<A>(p: Predicate<A>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<A>];
+export function partition<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<B>];
+export function partition<A>(p: Predicate<A>) {
+  return (self: Maybe<A>): readonly [Maybe<A>, Maybe<A>] => {
+    self.concrete();
+    return self._tag === MaybeTag.Just && p(self.value) ? [Nothing(), self] : [self, Nothing()];
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe partitionMap
+ * @tsplus pipeable fncts.Maybe partitionMap
  */
-export function partitionMap_<A, B, C>(self: Maybe<A>, f: (a: A) => Either<B, C>): readonly [Maybe<B>, Maybe<C>] {
-  self.concrete();
-  if (self._tag === MaybeTag.Just) {
-    return f(self.value).match(
-      (b) => [Just(b), Nothing()],
-      (c) => [Nothing(), Just(c)],
-    );
-  } else {
-    return [Nothing(), Nothing()];
-  }
+export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
+  return (self: Maybe<A>): readonly [Maybe<B>, Maybe<C>] => {
+    self.concrete();
+    if (self._tag === MaybeTag.Just) {
+      return f(self.value).match(
+        (b) => [Just(b), Nothing()],
+        (c) => [Nothing(), Just(c)],
+      );
+    } else {
+      return [Nothing(), Nothing()];
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe foldLeft
+ * @tsplus pipeable fncts.Maybe foldLeft
  */
-export function foldLeft_<A, B>(self: Maybe<A>, b: B, f: (b: B, a: A) => B): B {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? f(b, self.value) : b;
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: Maybe<A>): B => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? f(b, self.value) : b;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe foldRight
+ * @tsplus pipeable fncts.Maybe foldRight
  */
-export function foldRight_<A, B>(self: Maybe<A>, b: B, f: (a: A, b: B) => B): B {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? f(self.value, b) : b;
+export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return (self: Maybe<A>): B => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? f(self.value, b) : b;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe foldMap
+ * @tsplus pipeable fncts.Maybe foldMap
  */
-export function foldMap_<A, M>(self: Maybe<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? f(self.value) : M.nat;
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
+  return (self: Maybe<A>): M => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? f(self.value) : M.nat;
+  };
 }
 
 /**
  * Extracts the value from `Maybe` if it exists, or returns the result of `orElse`.
  *
- * @tsplus fluent fncts.Maybe getOrElse
+ * @tsplus pipeable fncts.Maybe getOrElse
  */
-export function getOrElse_<A, B>(self: Maybe<A>, orElse: Lazy<B>): A | B {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? self.value : orElse();
+export function getOrElse<B>(orElse: Lazy<B>) {
+  return <A>(self: Maybe<A>): A | B => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? self.value : orElse();
+  };
 }
 
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just`, otherwise returns `Nothing`.
  *
- * @tsplus fluent fncts.Maybe map
+ * @tsplus pipeable fncts.Maybe map
  */
-export function map_<A, B>(self: Maybe<A>, f: (a: A) => B): Maybe<B> {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? Just(f(self.value)) : (self as Nothing);
+export function map<A, B>(f: (a: A) => B) {
+  return (self: Maybe<A>): Maybe<B> => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? Just(f(self.value)) : (self as Nothing);
+  };
 }
 
 /**
  * `chain` + `fromNullable`
  *
- * @tsplus fluent fncts.Maybe mapNullable
+ * @tsplus pipeable fncts.Maybe mapNullable
  */
-export function mapNullable_<A, B>(self: Maybe<A>, f: (a: A) => Nullable<B>): Maybe<NonNullable<B>> {
-  return self.flatMap(Maybe.fromNullableK(f));
+export function mapNullable<A, B>(f: (a: A) => Nullable<B>) {
+  return (self: Maybe<A>): Maybe<NonNullable<B>> => {
+    return self.flatMap(Maybe.fromNullableK(f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe orElse
+ * @tsplus pipeable fncts.Maybe orElse
  */
-export function orElse_<A, B>(self: Maybe<A>, fb: Lazy<Maybe<B>>): Maybe<A | B> {
-  self.concrete();
-  return self._tag === MaybeTag.Nothing ? fb() : self;
+export function orElse<B>(fb: Lazy<Maybe<B>>) {
+  return <A>(self: Maybe<A>): Maybe<A | B> => {
+    self.concrete();
+    return self._tag === MaybeTag.Nothing ? fb() : self;
+  };
 }
 
 /**
@@ -161,17 +190,21 @@ export function toUndefined<A>(self: Maybe<A>): A | undefined {
 }
 
 /**
- * @tsplus fluent fncts.Maybe zipWith
+ * @tsplus pipeable fncts.Maybe zipWith
  */
-export function zipWith_<A, B, C>(self: Maybe<A>, fb: Maybe<B>, f: (a: A, b: B) => C): Maybe<C> {
-  self.concrete();
-  fb.concrete();
-  return self._tag === MaybeTag.Just && fb._tag === MaybeTag.Just ? Just(f(self.value, fb.value)) : Nothing();
+export function zipWith<A, B, C>(fb: Maybe<B>, f: (a: A, b: B) => C) {
+  return (self: Maybe<A>): Maybe<C> => {
+    self.concrete();
+    fb.concrete();
+    return self._tag === MaybeTag.Just && fb._tag === MaybeTag.Just ? Just(f(self.value, fb.value)) : Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.Maybe zip
+ * @tsplus pipeable fncts.Maybe zip
  */
-export function zip_<A, B>(self: Maybe<A>, that: Maybe<B>): Maybe<Zipped.Make<A, B>> {
-  return self.zipWith(that, (a, b) => Zipped(a, b));
+export function zip<B>(that: Maybe<B>) {
+  return <A>(self: Maybe<A>): Maybe<Zipped.Make<A, B>> => {
+    return self.zipWith(that, (a, b) => Zipped(a, b));
+  };
 }

package/_src/data/Maybe/constructors.ts

@@ -35,9 +35,9 @@ export function fromNullableK<P extends ReadonlyArray<unknown>, A>(f: (...params
 /**
  * @tsplus static fncts.MaybeOps fromPredicate
  */
-export function fromPredicate_<A>(a: A, p: Predicate<A>): Maybe<A>;
-export function fromPredicate_<A, B extends A>(a: A, p: Refinement<A, B>): Maybe<A>;
-export function fromPredicate_<A>(a: A, p: Predicate<A>): Maybe<A> {
+export function fromPredicate<A>(a: A, p: Predicate<A>): Maybe<A>;
+export function fromPredicate<A, B extends A>(a: A, p: Refinement<A, B>): Maybe<A>;
+export function fromPredicate<A>(a: A, p: Predicate<A>): Maybe<A> {
   return p(a) ? Just(a) : Nothing();
 }
 

package/_src/data/Maybe/definition.ts

@@ -61,7 +61,17 @@ export class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{ _A: () => infer A }] ? A : never> {
+export function unifyMaybe<X extends Maybe<any>>(
+  self: X,
+): Maybe<
+  [X] extends [
+    {
+      _A: () => infer A;
+    },
+  ]
+    ? A
+    : never
+> {
   return self;
 }
 

package/_src/data/Maybe/destructors.ts

@@ -4,9 +4,11 @@ import { MaybeTag } from "./definition.js";
  * Matches on each case of a `Maybe`, returning the result of `nothing` if the `Maybe`
  * is `Nothing`, or returning the result of `just` if it is `Just`
  *
- * @tsplus fluent fncts.Maybe match
+ * @tsplus pipeable fncts.Maybe match
  */
-export function match_<A, B, C>(self: Maybe<A>, nothing: () => B, just: (a: A) => C): B | C {
-  self.concrete();
-  return self._tag === MaybeTag.Just ? just(self.value) : nothing();
+export function match<A, B, C>(nothing: () => B, just: (a: A) => C) {
+  return (self: Maybe<A>): B | C => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? just(self.value) : nothing();
+  };
 }

package/_src/data/Maybe/instances.ts

@@ -3,23 +3,12 @@ import type { MaybeF } from "@fncts/base/data/Maybe/definition";
 
 import { MaybeJson } from "@fncts/base/json/MaybeJson";
 
-import {
-  filter_,
-  filterMap_,
-  flatMap_,
-  foldLeft_,
-  foldRight_,
-  map_,
-  partition_,
-  partitionMap_,
-  zip_,
-  zipWith_,
-} from "./api.js";
+import { filter, filterMap, flatMap, foldLeft, foldRight, map, partition, partitionMap, zip, zipWith } from "./api.js";
 import { just } from "./constructors.js";
 
-export const Functor = HKT.instance<P.Functor<MaybeF>>({ map: map_ });
+export const Functor = HKT.instance<P.Functor<MaybeF>>({ map });
 
-export const Apply = HKT.instance<P.Apply<MaybeF>>({ ...Functor, zip: zip_, zipWith: zipWith_ });
+export const Apply = HKT.instance<P.Apply<MaybeF>>({ ...Functor, zip, zipWith });
 
 export const Applicative = HKT.instance<P.Applicative<MaybeF>>({
   ...Apply,
@@ -28,20 +17,20 @@ export const Applicative = HKT.instance<P.Applicative<MaybeF>>({
 
 export const Monad = HKT.instance<P.Monad<MaybeF>>({
   ...Applicative,
-  flatMap: flatMap_,
+  flatMap,
 });
 
 export const Foldable = HKT.instance<P.Foldable<MaybeF>>({
-  foldLeft: foldLeft_,
-  foldRight: foldRight_,
+  foldLeft,
+  foldRight,
 });
 
 export const Filterable = HKT.instance<P.Filterable<MaybeF>>({
   ...Functor,
-  filter: filter_,
-  filterMap: filterMap_,
-  partition: partition_,
-  partitionMap: partitionMap_,
+  filter,
+  filterMap,
+  partition,
+  partitionMap,
 });
 
 /**
@@ -78,3 +67,24 @@ export function deriveDecoder<A extends Maybe<any>>(
     label,
   );
 }
+
+/**
+ * @tsplus derive fncts.Encoder[fncts.Maybe]<_> 10
+ */
+export function deriveEncoder<A extends Maybe<any>>(
+  ...[value]: [A] extends [Maybe<infer A>] ? [value: Encoder<A>] : never
+): Encoder<A> {
+  return Encoder((input) => {
+    Maybe.concrete(input);
+    if (input.isJust()) {
+      return {
+        _tag: "Just",
+        value: value.encode(input.value),
+      };
+    } else {
+      return {
+        _tag: "Nothing",
+      };
+    }
+  });
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @tsplus pipeable fncts.Ord contramap
+ */
+export function contramap<A, B>(f: (b: B) => A) {
+  return (self: Ord<A>): Ord<B> => {
+    return {
+      compare: (y) => (x) => self.compare(f(y))(f(x)),
+      equals: (y) => (x) => self.equals(f(y))(f(x)),
+    };
+  };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * @tsplus static fncts.OrdOps max
+ * @tsplus getter fncts.Ord max
+ */
+export function max<A>(O: Ord<A>): (y: A) => (x: A) => A {
+  return (y) => (x) => x === y || O.compare(y)(x) > -1 ? x : y;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * @tsplus static fncts.OrdOps min
+ * @tsplus getter fncts.Ord min
+ */
+export function min<A>(O: Ord<A>): (y: A) => (x: A) => A {
+  return (y) => (x) => x === y || O.compare(y)(x) < 1 ? x : y;
+}

package/_src/{typeclass → data}/Ord/definition.ts

@@ -1,12 +1,8 @@
-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;
+  readonly compare: (y: A) => (x: A) => Ordering;
 }
 
 /**
@@ -19,7 +15,7 @@ export const Ord: OrdOps = {};
 /**
  * @tsplus static fncts.OrdOps __call
  */
-export function mkOrd<A>(O: Ord<A>): Ord<A> {
+export function makeOrd<A>(O: Ord<A>): Ord<A> {
   return {
     ...Eq(O),
     compare: O.compare,