@fncts/base 0.0.21 → 0.0.23

package/_src/{typeclass → data}/Showable/show.ts

@@ -1,9 +1,9 @@
-import type { StyleFunction } from "@fncts/base/typeclass/Showable/styles";
+import type { StyleFunction } from "@fncts/base/data/Showable/styles";
 import type { TypedArray } from "@fncts/base/util/predicates";
 
 import { tuple } from "@fncts/base/data/function";
-import { isShowable } from "@fncts/base/typeclass/Showable/definition";
-import { stylizeNoColor, stylizeWithColor } from "@fncts/base/typeclass/Showable/styles";
+import { isShowable } from "@fncts/base/data/Showable/definition";
+import { stylizeNoColor, stylizeWithColor } from "@fncts/base/data/Showable/styles";
 import {
   ARRAY_EXTRAS_TYPE,
   ARRAY_TYPE,
@@ -22,7 +22,7 @@ import {
   PROTO_TYPE,
   strEscape,
   strEscapeSequencesReplacer,
-} from "@fncts/base/typeclass/Showable/util";
+} from "@fncts/base/data/Showable/util";
 import {
   isAnyArrayBuffer,
   isArray,
@@ -41,6 +41,7 @@ import {
   isWeakMap,
   isWeakSet,
 } from "@fncts/base/util/predicates";
+
 export interface ShowContextArgs {
   readonly stylize: StyleFunction;
   readonly circular: HashMap<unknown, number>;
@@ -57,6 +58,7 @@ export interface ShowContextArgs {
   readonly recurseTimes: number;
   readonly budget: Record<number, number>;
 }
+
 export interface ShowOptions {
   readonly maxArrayLength: number;
   readonly maxStringLength: number;
@@ -67,20 +69,24 @@ export interface ShowOptions {
   readonly showHidden: boolean;
   readonly indentationLevel: number;
 }
+
 export class ShowContext extends CaseClass<ShowContextArgs> {}
 export type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, never, never, A>;
 export type ShowComputation = ShowComputationZ<string>;
 export type ShowComputationChunk = ShowComputationZ<Conc<string>>;
+
 export interface ShowComputationPrimitive {
   readonly _tag: "Primitive";
   readonly computation: ShowComputation;
 }
+
 export function showComputationPrimitive(computation: ShowComputation): ShowComputationPrimitive {
   return {
     _tag: "Primitive",
     computation,
   };
 }
+
 export interface ShowComputationComplex {
   readonly _tag: "Complex";
   extrasType?: number;
@@ -89,13 +95,16 @@ export interface ShowComputationComplex {
   keys?: ShowComputationChunk;
   braces?: [string, string];
 }
+
 export function showComputationComplex(args: Omit<ShowComputationComplex, "_tag">): ShowComputationComplex {
   return {
     _tag: "Complex",
     ...args,
   };
 }
+
 export type ShowComputationExternal = ShowComputationPrimitive | ShowComputationComplex;
+
 function getShowContext(options?: Partial<ShowOptions>) {
   return new ShowContext({
     maxArrayLength: 100,
@@ -105,7 +114,7 @@ function getShowContext(options?: Partial<ShowOptions>) {
     colors: false,
     depth: 3,
     showHidden: true,
-    circular: HashMap.makeDefault<unknown, number>(),
+    circular: HashMap.empty<unknown, number>(),
     seen: [],
     budget: {},
     indentationLevel: options?.indentationLevel ?? 0,
@@ -115,12 +124,15 @@ function getShowContext(options?: Partial<ShowOptions>) {
     ...(options || {}),
   });
 }
+
 export function show(value: unknown): string {
   return _show(value).unsafeRunStateResult(getShowContext());
 }
+
 export function showWithOptions(value: unknown, options: Partial<ShowOptions>): string {
   return _show(value).unsafeRunStateResult(getShowContext(options));
 }
+
 export function _show(value: unknown): ShowComputation {
   return Z.getsZ((context) => {
     if (value === undefined) {
@@ -135,6 +147,7 @@ export function _show(value: unknown): ShowComputation {
     return showValue(value);
   });
 }
+
 function showValue(value: object): ShowComputation {
   return Z.getsZ((context) => {
     if (context.seen.findIndex((v) => v === value) !== -1) {
@@ -151,6 +164,7 @@ function showValue(value: object): ShowComputation {
     return showRaw(value);
   });
 }
+
 interface InspectionInfo {
   readonly _tag: "InspectionInfo";
   readonly constructor: string | null;
@@ -163,33 +177,40 @@ interface InspectionInfo {
   readonly keys: ReadonlyArray<PropertyKey>;
   readonly protoProps: Conc<PropertyKey>;
 }
+
 function inspectionInfo(args: Omit<InspectionInfo, "_tag">): InspectionInfo {
   return {
     _tag: "InspectionInfo",
     ...args,
   };
 }
+
 interface InspectionEarlyReturn {
   readonly _tag: "InspectionEarlyReturn";
   readonly shown: string;
 }
+
 function inspectionEarlyReturn(shown: string): InspectionEarlyReturn {
   return {
     _tag: "InspectionEarlyReturn",
     shown,
   };
 }
+
 interface InspectionExternal {
   readonly _tag: "InspectionExternal";
   readonly computation: ShowComputationExternal;
 }
+
 function inspectionExternal(computation: ShowComputationExternal): InspectionExternal {
   return {
     _tag: "InspectionExternal",
     computation,
   };
 }
+
 type InspectionResult = InspectionInfo | InspectionEarlyReturn | InspectionExternal;
+
 /**
  * Determines the approximate type of the unknown value and collects information about
  * the structure of that value
@@ -342,6 +363,7 @@ function getInspectionInfo(context: ShowContext, value: object, typedArray?: str
     protoProps,
   });
 }
+
 /**
  * Retrieves information on the unknown value and processes that info to convert the value
  * into a human-readable, formatted string
@@ -359,7 +381,7 @@ function showRaw(value: object, typedArray?: string): ShowComputation {
             recurseTimes: context.recurseTimes - 1,
             currentDepth: context.currentDepth - 1,
           }),
-        ).apSecond(Z.succeedNow(context.stylize(constructorName, "special")));
+        ).zipRight(Z.succeedNow(context.stylize(constructorName, "special")));
       }
       if (info._tag === "InspectionEarlyReturn") {
         return Z.succeedNow(info.shown);
@@ -367,7 +389,7 @@ function showRaw(value: object, typedArray?: string): ShowComputation {
         return Z.update((context: ShowContext) => {
           context.seen.push(value);
           return context;
-        }).apSecond(
+        }).zipRight(
           Z.defer(() => {
             let keys: ShowComputationChunk;
             let indices: ShowComputationChunk;
@@ -423,7 +445,7 @@ function showRaw(value: object, typedArray?: string): ShowComputation {
                 currentDepth: _.recurseTimes + 1,
               }),
             )
-              .apSecond(output)
+              .zipRight(output)
               .cross(baseWithRef)
               .flatMap(([output, base]) =>
                 Z.modify((context) => {
@@ -440,7 +462,7 @@ function showRaw(value: object, typedArray?: string): ShowComputation {
                   return [res, newContext];
                 }),
               )
-              .apFirst(
+              .zipLeft(
                 Z.update((context: ShowContext) => {
                   context.seen.pop();
                   return context.copy({
@@ -454,6 +476,7 @@ function showRaw(value: object, typedArray?: string): ShowComputation {
     },
   );
 }
+
 /**
  * Converts a Chunk of strings containing the formatted keys/values of the original value
  * into a single formatted string
@@ -502,22 +525,25 @@ function isBelowBreakLength(context: ShowContext, input: Conc<string>, start: nu
   }
   return base === "" || !base.includes("\n");
 }
+
 function removeColors(str: string): string {
   return str.replace(colorRegExp, "");
 }
+
 function showSet(value: Set<unknown>): ShowComputationChunk {
   return Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel + 2 }))
-    .apSecond((value as Iterable<unknown>).traverseToConc(Z.Applicative)(_show))
-    .apFirst(Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel - 2 })));
+    .zipRight((value as Iterable<unknown>).traverseToConc(Z.Applicative)(_show))
+    .zipLeft(Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel - 2 })));
 }
+
 function showMap(value: Map<unknown, unknown>): ShowComputationChunk {
   return Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel + 2 }))
-    .apSecond(
+    .zipRight(
       (value as Iterable<[unknown, unknown]>).traverseToConc(Z.Applicative)(([k, v]) =>
         _show(k).crossWith(_show(v), (k, v) => `${k} => ${v}`),
       ),
     )
-    .apFirst(
+    .zipLeft(
       Z.update((_: ShowContext) =>
         _.copy({
           indentationLevel: _.indentationLevel - 2,
@@ -525,6 +551,7 @@ function showMap(value: Map<unknown, unknown>): ShowComputationChunk {
       ),
     );
 }
+
 function showTypedArray(value: TypedArray): ShowComputationChunk {
   return Z.getsZ((context) =>
     Z.defer(() => {
@@ -541,7 +568,7 @@ function showTypedArray(value: TypedArray): ShowComputationChunk {
       }
       if (context.showHidden) {
         return Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel + 2 }))
-          .apSecond(
+          .zipRight(
             Z.succeedNow(output).flatMap((output) =>
               Conc("BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset", "buffer")
                 .traverse(Z.Applicative)((key) =>
@@ -550,13 +577,14 @@ function showTypedArray(value: TypedArray): ShowComputationChunk {
                 .map((shownKeys) => output.concat(shownKeys)),
             ),
           )
-          .apFirst(Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel - 2 })));
+          .zipLeft(Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel - 2 })));
       } else {
         return Z.succeedNow(output);
       }
     }),
   );
 }
+
 function showArrayBuffer(value: ArrayBuffer | SharedArrayBuffer): ShowComputationChunk {
   return Z.gets((context: ShowContext) => {
     let buffer;
@@ -575,7 +603,9 @@ function showArrayBuffer(value: ArrayBuffer | SharedArrayBuffer): ShowComputatio
     return Conc.single(`[Uint8Contents]: <${str}>`);
   });
 }
+
 const maxEntries = 2 ** 32 - 2;
+
 function showSpecialArray(
   value: ReadonlyArray<unknown>,
   maxLength: number,
@@ -625,6 +655,7 @@ function showSpecialArray(
     return computation;
   });
 }
+
 function showArray(value: ReadonlyArray<unknown>): ShowComputationChunk {
   return Z.gets((context: ShowContext) => {
     let chunk       = Conc.from(value);
@@ -647,6 +678,7 @@ function showArray(value: ReadonlyArray<unknown>): ShowComputationChunk {
     return computation;
   });
 }
+
 function showChunk(value: Conc<unknown>): ShowComputationChunk {
   return Z.gets((context: ShowContext) => {
     const valLen    = value.length;
@@ -660,6 +692,7 @@ function showChunk(value: Conc<unknown>): ShowComputationChunk {
       .map((chunk) => (remaining > 0 ? chunk.append(`... ${remaining} more item${pluralize(remaining)}`) : chunk)),
   );
 }
+
 export function showProperty(
   value: object,
   key: PropertyKey,
@@ -676,7 +709,7 @@ export function showProperty(
       if (isDefined(descriptor.value)) {
         const diff = context.compact !== true || (type !== OBJECT_TYPE && type !== PROTO_TYPE) ? 2 : 3;
         return Z.update((_: ShowContext): ShowContext => _.copy({ indentationLevel: _.indentationLevel + diff }))
-          .apSecond(_show(descriptor.value))
+          .zipRight(_show(descriptor.value))
           .flatMap((shown: string) =>
             Z.gets((_: ShowContext) =>
               diff === 3 && _.breakLength < getStringWidth(shown, _.colors)
@@ -684,7 +717,7 @@ export function showProperty(
                 : tuple(descriptor, " ", shown),
             ),
           )
-          .apFirst(Z.update((_: ShowContext): ShowContext => _.copy({ indentationLevel: _.indentationLevel - diff })));
+          .zipLeft(Z.update((_: ShowContext): ShowContext => _.copy({ indentationLevel: _.indentationLevel - diff })));
       } else if (isDefined(descriptor.get)) {
         return Z.succeedNow(tuple(descriptor, " ", `[${descriptor.set ? "Getter/Settter" : "Getter"}]`));
       } else if (isDefined(descriptor.set)) {
@@ -717,6 +750,7 @@ export function showProperty(
     }),
   );
 }
+
 /**
  * Groups the formatted elements of an array-like structure into chunks limited by the
  * maximum character width set in the context
@@ -807,7 +841,9 @@ function groupElements(context: ShowContext, input: Conc<string>, value?: unknow
   }
   return output;
 }
+
 type Primitive = string | number | boolean | bigint | symbol;
+
 function _showPrimitive(context: ShowContext, value: Primitive): string {
   switch (typeof value) {
     case "string":
@@ -822,6 +858,7 @@ function _showPrimitive(context: ShowContext, value: Primitive): string {
       return _showSymbol(context, value);
   }
 }
+
 function _showString(context: ShowContext, value: string): string {
   let result  = value;
   let trailer = "";
@@ -844,15 +881,19 @@ function _showString(context: ShowContext, value: string): string {
   }
   return context.stylize(strEscape(value), "string") + trailer;
 }
+
 function _showNumber(context: ShowContext, value: number): string {
   return context.stylize(value.toString(10), "number");
 }
+
 function _showBoolean(context: ShowContext, value: boolean): string {
   return context.stylize(value === true ? "true" : "false", "boolean");
 }
+
 function _showBigInt(context: ShowContext, value: bigint): string {
   return context.stylize(`${value.toString()}n`, "bigint");
 }
+
 function _showSymbol(context: ShowContext, value: symbol): string {
   return context.stylize(value.toString(), "symbol");
 }

package/_src/data/Struct/api.ts

@@ -101,7 +101,7 @@ export function omit<A extends {}, N extends ReadonlyArray<keyof A>>(keys: [...N
   ): Struct<{
     readonly [P in Exclude<keyof A, N[number]>]: A[P];
   }> => {
-    const newKeys = keys.asImmutableArray.difference(self.keys.asImmutableArray, Eq({ equals: (x, y) => x === y }));
+    const newKeys = keys.asImmutableArray.difference(self.keys.asImmutableArray, Eq({ equals: (y) => (x) => x === y }));
     const out     = {} as any;
     for (const key of newKeys) {
       out[key] = self.getStruct[key];

package/_src/data/Tag/definition.ts

@@ -1,4 +1,5 @@
-import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
+export const TagVariance = Symbol.for("fncts.Tag.Variance");
+export type TagVariance = typeof TagVariance;
 
 export const TagTypeId = Symbol.for("fncts.Tag");
 export type TagTypeId = typeof TagTypeId;
@@ -12,8 +13,10 @@ const _tagHash = Hashable.string("fncts.Tag");
  * @tsplus companion fncts.TagOps
  */
 export class Tag<in out T> implements Hashable, Equatable {
-  declare _T: (_: T) => T;
-  readonly _typeId: TagTypeId = TagTypeId;
+  readonly [TagTypeId]: TagTypeId = TagTypeId;
+  declare [TagVariance]: {
+    readonly _T: (_: T) => T;
+  };
 
   constructor(readonly id: string) {}
 
@@ -27,5 +30,5 @@ export class Tag<in out T> implements Hashable, Equatable {
 }
 
 export function isTag(u: unknown): u is Tag<unknown> {
-  return hasTypeId(u, TagTypeId);
+  return isObject(u) && TagTypeId in u;
 }

package/_src/data/These/api.ts

@@ -80,11 +80,11 @@ export function zipWith<E, A, B, C>(that: These<E, B>, f: (a: A, b: B) => C, /**
       case TheseTag.Left:
         switch (that._tag) {
           case TheseTag.Left:
-            return These.left(S.combine(self.left, that.left));
+            return These.left(S.combine(that.left)(self.left));
           case TheseTag.Right:
             return self;
           case TheseTag.Both:
-            return These.left(S.combine(self.left, that.left));
+            return These.left(S.combine(that.left)(self.left));
         }
       case TheseTag.Right:
         switch (that._tag) {
@@ -98,11 +98,11 @@ export function zipWith<E, A, B, C>(that: These<E, B>, f: (a: A, b: B) => C, /**
       case TheseTag.Both:
         switch (that._tag) {
           case TheseTag.Left:
-            return These.left(S.combine(self.left, that.left));
+            return These.left(S.combine(that.left)(self.left));
           case TheseTag.Right:
             return These.both(self.left, f(self.right, that.right));
           case TheseTag.Both:
-            return These.both(S.combine(self.left, that.left), f(self.right, that.right));
+            return These.both(S.combine(that.left)(self.left), f(self.right, that.right));
         }
     }
   };
@@ -140,11 +140,11 @@ export function flatMap<E, A, B>(f: (a: A) => These<E, B>, /** @tsplus auto */ S
     const that = f(self.right);
     switch (that._tag) {
       case TheseTag.Left:
-        return These.left(S.combine(self.left, that.left));
+        return These.left(S.combine(that.left)(self.left));
       case TheseTag.Right:
         return These.both(self.left, that.right);
       case TheseTag.Both:
-        return These.both(S.combine(self.left, that.left), that.right);
+        return These.both(S.combine(that.left)(self.left), that.right);
     }
   };
 }

package/_src/data/These/definition.ts

@@ -11,8 +11,8 @@ export type TheseTypeId = typeof TheseTypeId;
  * @tsplus type fncts.These.Left
  */
 export class Left<E> {
-  readonly _typeId: TheseTypeId = TheseTypeId;
-  readonly _tag                 = TheseTag.Left;
+  readonly [TheseTypeId]: TheseTypeId = TheseTypeId;
+  readonly _tag = TheseTag.Left;
   constructor(readonly left: E) {}
 }
 
@@ -20,8 +20,8 @@ export class Left<E> {
  * @tsplus type fncts.These.Right
  */
 export class Right<A> {
-  readonly _typeId: TheseTypeId = TheseTypeId;
-  readonly _tag                 = TheseTag.Right;
+  readonly [TheseTypeId]: TheseTypeId = TheseTypeId;
+  readonly _tag = TheseTag.Right;
   constructor(readonly right: A) {}
 }
 
@@ -29,8 +29,8 @@ export class Right<A> {
  * @tsplus type fncts.These.Both
  */
 export class Both<E, A> {
-  readonly _typeId: TheseTypeId = TheseTypeId;
-  readonly _tag                 = TheseTag.Both;
+  readonly [TheseTypeId]: TheseTypeId = TheseTypeId;
+  readonly _tag = TheseTag.Both;
   constructor(readonly left: E, readonly right: A) {}
 }
 
@@ -50,5 +50,5 @@ export const These: TheseOps = {};
  * @tsplus static fncts.TheseOps isThese
  */
 export function isThese(u: unknown): u is These<unknown, unknown> {
-  return hasTypeId(u, TheseTypeId);
+  return isObject(u) && TheseTypeId in u;
 }

package/_src/data/bigint/instances.ts

@@ -3,6 +3,7 @@ import { isBigInt } from "@fncts/base/util/predicates";
 
 /**
  * @tsplus static fncts.BigIntOps Guard
+ * @tsplus static fncts.GuardOps bigint
  * @tsplus implicit
  */
 export const Guard: P.Guard<bigint> = P.Guard(isBigInt);

package/_src/data/boolean/instances.ts

@@ -3,6 +3,7 @@ import { isBoolean } from "@fncts/base/util/predicates";
 
 /**
  * @tsplus static fncts.BooleanOps Guard
+ * @tsplus static fncts.GuardOps boolean
  * @tsplus implicit
  */
 export const Guard: P.Guard<boolean> = P.Guard(isBoolean);

package/_src/data/exceptions/InterruptedException.ts

@@ -1,13 +1,11 @@
-import { hasTypeId } from "../../util/predicates.js";
-
 export const InterruptedExceptionTypeId = Symbol.for("fncts.InterruptedException");
 export type InterruptedExceptionTypeId = typeof InterruptedExceptionTypeId;
 
 export class InterruptedException {
-  readonly _typeId: InterruptedExceptionTypeId = InterruptedExceptionTypeId;
+  readonly [InterruptedExceptionTypeId]: InterruptedExceptionTypeId = InterruptedExceptionTypeId;
   constructor(readonly message?: string) {}
 }
 
 export function isInterruptedException(u: unknown): u is InterruptedException {
-  return hasTypeId(u, InterruptedExceptionTypeId);
+  return isObject(u) && InterruptedExceptionTypeId in u;
 }

package/_src/data/number/instances.ts

@@ -1,25 +1,25 @@
+import { EQ, GT, LT } from "@fncts/base/data/Ordering";
 import { isNumber } from "@fncts/base/util/predicates";
 
 import * as P from "../../typeclass.js";
-import { EQ, GT, LT } from "../../typeclass.js";
 
 /**
  * @tsplus static fncts.NumberOps Eq
  * @tsplus implicit
  */
-export const Eq: P.Eq<number> = P.Eq({ equals: (x, y) => x === y });
+export const Eq: P.Eq<number> = P.Eq({ equals: (y) => (x) => x === y });
 
 /**
  * @tsplus static fncts.NumberOps Ord
  * @tsplus implicit
  */
 export const Ord: P.Ord<number> = P.Ord({
-  compare: (x, y) => (x < y ? LT : x > y ? GT : EQ),
-  equals: (x, y) => x === y,
+  compare: (y) => (x) => x < y ? LT : x > y ? GT : EQ,
+  equals: (y) => (x) => x === y,
 });
 
 /**
  * @tsplus static fncts.NumberOps Guard
- * @tsplus implicit
+ * @tsplus static fncts.GuardOps number
  */
 export const Guard: P.Guard<number> = P.Guard(isNumber);

package/_src/data/object/instances.ts

@@ -1,17 +1,6 @@
-import type { Check } from "@fncts/typelevel/Check";
-
 import * as P from "@fncts/base/typeclass";
 
 /**
  * @tsplus static fncts.globalOps Guard
  */
 export const Guard: P.Guard<{}> = P.Guard(isObject);
-
-/**
- * @tsplus derive fncts.Guard<_> 10
- */
-export function deriveGuard<A extends {}>(
-  ..._: Check<Check.IsEqual<A, {}>> extends Check.True ? [] : never
-): P.Guard<A> {
-  return P.Guard((u): u is A => typeof u === "object" && u !== null);
-}

package/_src/data/string/api.ts

@@ -1,5 +1,3 @@
-import { Ord } from "../../typeclass.js";
-
 /**
  * Capitalize the first letter of the string
  *
@@ -81,7 +79,7 @@ export function surround(x: string) {
  */
 export function take(n: number) {
   return (s: string): string => {
-    return s.slice(0, Ord.max(Number.Ord)(0, n));
+    return s.slice(0, Ord.max(Number.Ord)(n)(0));
   };
 }
 
@@ -99,7 +97,7 @@ export function take(n: number) {
  */
 export function takeLast(n: number) {
   return (s: string): string => {
-    return s.slice(Ord.max(Number.Ord)(0, s.length - Math.floor(n)), Infinity);
+    return s.slice(Ord.max(Number.Ord)(s.length - Math.floor(n))(0), Infinity);
   };
 }
 

package/_src/data/string/instances.ts

@@ -6,19 +6,19 @@ import * as P from "../../typeclass.js";
  * @tsplus static fncts.StringOps Eq
  * @tsplus implicit
  */
-export const Eq: P.Eq<string> = P.Eq({ equals: (x, y) => x === y });
+export const Eq: P.Eq<string> = P.Eq({ equals: (y) => (x) => x === y });
 
 /**
  * @tsplus static fncts.StringOps Semigroup
  * @tsplus implicit
  */
-export const Semigroup: P.Semigroup<string> = P.Semigroup({ combine: (x, y) => x + y });
+export const Semigroup: P.Semigroup<string> = P.Semigroup({ combine: (y) => (x) => x + y });
 
 /**
  * @tsplus static fncts.StringOps Monoid
  * @tsplus implicit
  */
-export const Monoid: P.Monoid<string> = P.Monoid({ combine: (x, y) => x + y, nat: "" });
+export const Monoid: P.Monoid<string> = P.Monoid({ combine: (y) => (x) => x + y, nat: "" });
 
 /**
  * @tsplus static fncts.StringOps Ord
@@ -26,7 +26,7 @@ export const Monoid: P.Monoid<string> = P.Monoid({ combine: (x, y) => x + y, nat
  */
 export const Ord: P.Ord<string> = P.Ord({
   ...Eq,
-  compare: (x, y) => (x < y ? -1 : x > y ? 1 : 0),
+  compare: (y) => (x) => x < y ? -1 : x > y ? 1 : 0,
 });
 
 /**

package/_src/data.ts

@@ -6,6 +6,7 @@ export type {} from "./data/Byte.js";
 export type {} from "./data/CaseClass.js";
 export type {} from "./data/Cause.js";
 export type {} from "./data/Const.js";
+export type {} from "./data/DatumEither.js";
 export type {} from "./data/DecodeError.js";
 export type {} from "./data/Decoder.js";
 export type {} from "./data/Duration.js";
@@ -13,11 +14,17 @@ export type {} from "./data/Either.js";
 export type {} from "./data/Encoder.js";
 export type {} from "./data/Environment.js";
 export type {} from "./data/EnvironmentPatch.js";
+export type {} from "./data/Eq.js";
+export type {} from "./data/Equatable.js";
 export type {} from "./data/exceptions.js";
 export type {} from "./data/ExecutionStrategy.js";
 export type {} from "./data/Exit.js";
 export type {} from "./data/FiberId.js";
 export type {} from "./data/function.js";
+export type {} from "./data/Guard.js";
+export type {} from "./data/Hash.js";
+export type {} from "./data/Hashable.js";
+export type {} from "./data/HashEq.js";
 export type {} from "./data/Identity.js";
 export type {} from "./data/Interval.js";
 export type {} from "./data/Intervals.js";
@@ -25,8 +32,11 @@ export type {} from "./data/Maybe.js";
 export type {} from "./data/Newtype.js";
 export type {} from "./data/number.js";
 export type {} from "./data/object.js";
+export type {} from "./data/Ord.js";
+export type {} from "./data/Ordering.js";
 export type {} from "./data/Predicate.js";
 export type {} from "./data/Refinement.js";
+export type {} from "./data/Showable.js";
 export type {} from "./data/string.js";
 export type {} from "./data/Tag.js";
 export type {} from "./data/These.js";