@fncts/base 0.0.39 → 0.0.41

package/_src/data/Eq/api.ts

@@ -1,12 +1,192 @@
+import type { Literal } from "@fncts/typelevel/Any";
+
+import { deriveStruct } from "./derivations.js";
+
 /**
- * @tsplus pipeable fncts.Eq contramap
+ * @tsplus static fncts.EqOps never
+ * @tsplus implicit
  */
-export function contramap<A, B>(f: (b: B) => A) {
-  return (self: Eq<A>): Eq<B> => {
-    return Eq({ equals: (b2) => (b1) => self.equals(f(b2))(f(b1)) });
+export const never: Eq<never> = Eq({ equals: () => () => false });
+
+/**
+ * @tsplus static fncts.EqOps strict
+ * @tsplus implicit
+ */
+export const strict: Eq<any> = Eq({ equals: (y) => (x) => x === y });
+
+/**
+ * @tsplus static fncts.EqOps string
+ * @tsplus implicit
+ */
+export const string: Eq<string> = Eq.strict;
+
+/**
+ * @tsplus static fncts.EqOps number
+ * @tsplus implicit
+ */
+export const number: Eq<number> = Eq.strict;
+
+/**
+ * @tsplus static fncts.EqOps boolean
+ * @tsplus implicit
+ */
+export const boolean: Eq<boolean> = Eq.strict;
+
+/**
+ * @tsplus static fncts.EqOps symbol
+ * @tsplus implicit
+ */
+export const symbol: Eq<symbol> = Eq.strict;
+
+/**
+ * @tsplus getter fncts.Eq nullable
+ */
+export function nullable<A>(self: Eq<A>): Eq<A | null> {
+  return Eq({
+    equals: (y) => (x) => {
+      if (x === y) {
+        return true;
+      }
+      if (x === null) {
+        return false;
+      }
+      if (y === null) {
+        return false;
+      }
+      return self.equals(y)(x);
+    },
+  });
+}
+
+/**
+ * @tsplus getter fncts.Eq undefinable
+ */
+export function undefinable<A>(self: Eq<A>): Eq<A | undefined> {
+  return Eq({
+    equals: (y) => (x) => {
+      if (x === y) {
+        return true;
+      }
+      if (x === undefined) {
+        return false;
+      }
+      if (y === undefined) {
+        return false;
+      }
+      return self.equals(y)(x);
+    },
+  });
+}
+
+/**
+ * @tsplus static fncts.EqOps union
+ */
+export function union<A extends ReadonlyArray<any>>(eqs: { [K in keyof A]: Eq<A[K]> }): Eq<A[number]> {
+  return Eq({
+    equals: (y) => (x) => {
+      for (const eq of eqs) {
+        if (eq.equals(y)(x)) {
+          return true;
+        }
+      }
+      return false;
+    },
+  });
+}
+
+/**
+ * @tsplus static fncts.EqOps tuple
+ */
+export function tuple<A extends ReadonlyArray<any>>(eqs: { [K in keyof A]: Eq<A[K]> }): Eq<A> {
+  return Eq({
+    equals: (y) => (x) => {
+      for (let i = 0; i < eqs.length; i++) {
+        const eq = eqs[i];
+        const xi = x[i];
+        const yi = y[i];
+        if (!eq.equals(yi)(xi)) {
+          return false;
+        }
+      }
+      return true;
+    },
+  });
+}
+
+/**
+ * @tsplus static fncts.EqOps record
+ */
+export function record<K extends PropertyKey, V>(_key: Eq<K>, value: Eq<V>): Eq<Record<K, V>> {
+  return Eq({
+    equals: (y) => (x) => {
+      for (const k in x) {
+        if (!(k in y)) {
+          return false;
+        }
+        const xk = x[k];
+        const yk = y[k];
+        if (!value.equals(yk)(xk)) {
+          return false;
+        }
+      }
+      for (const k in y) {
+        if (!(k in x)) {
+          return false;
+        }
+      }
+      return true;
+    },
+  });
+}
+
+/**
+ * @tsplus pipeable fncts.Eq intersection
+ */
+export function intersection<B>(that: Eq<B>) {
+  return <A>(self: Eq<A>): Eq<A & B> => {
+    return Eq({
+      equals: (y) => (x) => self.equals(y)(x) && that.equals(y)(x),
+    });
   };
 }
 
+/**
+ * @tsplus static fncts.EqOps literal
+ */
+export function literal<A extends Literal | null>(_: A): Eq<A> {
+  return Eq.strict;
+}
+
+/**
+ * @tsplus static fncts.EqOps struct
+ */
+export function struct<Required extends Record<PropertyKey, any>, Optional extends Record<PropertyKey, any>>(
+  requiredFields: { [K in keyof Required]: Eq<Required[K]> },
+  optionalFields?: { [K in keyof Optional]: Eq<Optional[K]> },
+): Eq<Required & { [K in keyof Optional]?: Optional[K] }> {
+  return Eq({
+    equals: (y) => (x) => {
+      for (const field in requiredFields) {
+        if (!(requiredFields[field] as Eq<any>).equals(y[field])(x[field])) {
+          return false;
+        }
+      }
+
+      if (optionalFields) {
+        for (const field in optionalFields) {
+          if ((x[field] == null && y[field] != null) || (x[field] != null && y[field] == null)) {
+            return false;
+          }
+          if (!(optionalFields[field] as Eq<any>).equals(y[field])(x[field])) {
+            return false;
+          }
+        }
+      }
+      return true;
+    },
+  });
+}
+
 /**
  * @tsplus static fncts.EqOps all
  */
@@ -29,3 +209,12 @@ export function all<A>(collection: Iterable<Eq<A>>): Eq<ReadonlyArray<A>> {
     },
   });
 }
+
+/**
+ * @tsplus pipeable fncts.Eq contramap
+ */
+export function contramap<A, B>(f: (b: B) => A) {
+  return (self: Eq<A>): Eq<B> => {
+    return Eq({ equals: (b2) => (b1) => self.equals(f(b2))(f(b1)) });
+  };
+}

package/_src/data/Eq/derivations.ts

@@ -40,23 +40,16 @@ export function deriveStruct<A extends Record<string, any>>(
       ]
     : never
 ): Eq<A> {
-  return Eq({
-    equals: (y) => (x) => {
-      for (const field in requiredFields) {
-        // @ts-expect-error
-        if (!(requiredFields[field] as Eq<any>).equals(y[field])(x[field])) {
-          return false;
-        }
-      }
-      for (const field in optionalFields) {
-        if ((field in x && !(field in y)) || (field in y && !(field in x))) {
-          return false;
-        }
-        if (!(optionalFields[field] as Eq<any>).equals(y[field])(x[field])) {
-          return false;
-        }
-      }
-      return true;
-    },
-  });
+  return Eq.struct<any, any>(requiredFields, optionalFields);
+}
+
+/**
+ * @tsplus derive fncts.Eq<|> 30
+ */
+export function deriveUnion<A extends ReadonlyArray<unknown>>(
+  ...members: {
+    [K in keyof A]: Eq<A[K]>;
+  }
+): Eq<A[number]> {
+  return Eq.union(members);
 }

package/_src/data/Exit/api.ts

@@ -13,57 +13,23 @@ export function ap<E, A>(that: Exit<E, A>) {
 }
 
 /**
- * @tsplus pipeable fncts.Exit zipLeft
- */
-export function zipLeft<G, B>(that: Exit<G, B>) {
-  return <E, A>(self: Exit<E, A>): Exit<E | G, A> => {
-    return self.zipWithCause(that, (a, _) => a, Cause.sequential);
-  };
-}
-
-/**
- * @tsplus pipeable fncts.Exit zipRight
- */
-export function zipRight<G, B>(that: Exit<G, B>) {
-  return <E, A>(self: Exit<E, A>): Exit<E | G, B> => {
-    return self.zipWithCause(that, (_, b) => b, Cause.sequential);
-  };
-}
-
-/**
- * @tsplus pipeable fncts.Exit zipLeftConcurrent
- */
-export function zipLeftConcurrent<G, B>(that: Exit<G, B>) {
-  return <E, A>(self: Exit<E, A>): Exit<E | G, A> => {
-    return self.zipWithCause(that, (a, _) => a, Cause.parallel);
-  };
-}
-
-/**
- * @tsplus pipeable fncts.Exit zipRightConcurrent
+ * @tsplus pipeable fncts.Exit bimap
  */
-export function zipRightConcurrent<G, B>(that: Exit<G, B>) {
-  return <E, A>(self: Exit<E, A>): Exit<E | G, B> => {
-    return self.zipWithCause(that, (_, b) => b, Cause.parallel);
+export function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B) {
+  return (self: Exit<E1, A>): Exit<E2, B> => {
+    return self.isFailure() ? Exit.failCause(self.cause.map(f)) : Exit.succeed(g(self.value));
   };
 }
 
 /**
- * @tsplus pipeable fncts.Exit flatMap
+ * @tsplus getter fncts.Exit causeOrNull
  */
-export function flatMap<A, G, B>(f: (a: A) => Exit<G, B>) {
-  return <E>(ma: Exit<E, A>): Exit<E | G, B> => {
-    return ma.isFailure() ? ma : f(ma.value);
-  };
-}
+export function causeOrNull<E, A>(self: Exit<E, A>): Cause<E> | null {
+  if (self.isFailure()) {
+    return self.cause;
+  }
 
-/**
- * @tsplus pipeable fncts.Exit bimap
- */
-export function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B) {
-  return (self: Exit<E1, A>): Exit<E2, B> => {
-    return self.isFailure() ? Exit.failCause(self.cause.map(f)) : Exit.succeed(g(self.value));
-  };
+  return null;
 }
 
 /**
@@ -78,6 +44,7 @@ export function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>
 }
 
 /**
+ * @tsplus getter fncts.Conc collectAllConcurrent
  * @tsplus static fncts.ExitOps collectAllConcurrent
  */
 export function collectAllConcurrent<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>> {
@@ -88,6 +55,15 @@ export function collectAllConcurrent<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<
   );
 }
 
+/**
+ * @tsplus pipeable fncts.Exit flatMap
+ */
+export function flatMap<A, G, B>(f: (a: A) => Exit<G, B>) {
+  return <E>(ma: Exit<E, A>): Exit<E | G, B> => {
+    return ma.isFailure() ? ma : f(ma.value);
+  };
+}
+
 /**
  * @tsplus getter fncts.Exit flatten
  */
@@ -95,6 +71,18 @@ export function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G, A> {
   return mma.flatMap(identity);
 }
 
+/**
+ * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
+ *
+ * @tsplus getter fncts.Exit getOrThrow
+ */
+export function getOrThrow<E, A>(self: Exit<E, A>): A {
+  if (self.isFailure()) {
+    throw new IOError(self.cause);
+  }
+  return self.value;
+}
+
 /**
  * @tsplus pipeable fncts.Exit map
  */
@@ -139,12 +127,15 @@ export function match<E, A, B, C>(onFailure: (e: Cause<E>) => B, onSuccess: (a:
 }
 
 /**
- * @tsplus pipeable fncts.Exit zipWith
+ * Returns the Exit's Success value if it exists
+ *
+ * @tsplus getter fncts.Exit value
  */
-export function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
-  return <EA>(fa: Exit<EA, A>): Exit<EA | EB, C> => {
-    return fa.zipWithCause(fb, f, Cause.sequential);
-  };
+export function value<E, A>(self: Exit<E, A>): A | undefined {
+  if (self.isFailure()) {
+    return undefined;
+  }
+  return self.value;
 }
 
 /**
@@ -157,20 +148,56 @@ export function zip<EB, B>(that: Exit<EB, B>) {
 }
 
 /**
- * @tsplus pipeable fncts.Exit zipWithConcurrent
+ * @tsplus pipeable fncts.Exit zipConcurrent
  */
-export function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
-  return <EA>(fa: Exit<EA, A>): Exit<EA | EB, C> => {
-    return fa.zipWithCause(fb, f, Cause.parallel);
+export function zipConcurrent<EB, B>(that: Exit<EB, B>) {
+  return <EA, A>(self: Exit<EA, A>): Exit<EA | EB, readonly [A, B]> => {
+    return self.zipWithConcurrent(that, tuple);
   };
 }
 
 /**
- * @tsplus pipeable fncts.Exit zipConcurrent
+ * @tsplus pipeable fncts.Exit zipLeft
  */
-export function zipConcurrent<EB, B>(that: Exit<EB, B>) {
-  return <EA, A>(self: Exit<EA, A>): Exit<EA | EB, readonly [A, B]> => {
-    return self.zipWithConcurrent(that, tuple);
+export function zipLeft<G, B>(that: Exit<G, B>) {
+  return <E, A>(self: Exit<E, A>): Exit<E | G, A> => {
+    return self.zipWithCause(that, (a, _) => a, Cause.sequential);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Exit zipLeftConcurrent
+ */
+export function zipLeftConcurrent<G, B>(that: Exit<G, B>) {
+  return <E, A>(self: Exit<E, A>): Exit<E | G, A> => {
+    return self.zipWithCause(that, (a, _) => a, Cause.parallel);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Exit zipRight
+ */
+export function zipRight<G, B>(that: Exit<G, B>) {
+  return <E, A>(self: Exit<E, A>): Exit<E | G, B> => {
+    return self.zipWithCause(that, (_, b) => b, Cause.sequential);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Exit zipRightConcurrent
+ */
+export function zipRightConcurrent<G, B>(that: Exit<G, B>) {
+  return <E, A>(self: Exit<E, A>): Exit<E | G, B> => {
+    return self.zipWithCause(that, (_, b) => b, Cause.parallel);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Exit zipWith
+ */
+export function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
+  return <EA>(fa: Exit<EA, A>): Exit<EA | EB, C> => {
+    return fa.zipWithCause(fb, f, Cause.sequential);
   };
 }
 
@@ -209,25 +236,10 @@ export function zipWithCause<E, A, G, B, C>(
 }
 
 /**
- * Returns the Exit's Success value if it exists
- *
- * @tsplus getter fncts.Exit value
- */
-export function value<E, A>(self: Exit<E, A>): A | undefined {
-  if (self.isFailure()) {
-    return undefined;
-  }
-  return self.value;
-}
-
-/**
- * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
- *
- * @tsplus getter fncts.Exit getOrThrow
+ * @tsplus pipeable fncts.Exit zipWithConcurrent
  */
-export function getOrThrow<E, A>(self: Exit<E, A>): A {
-  if (self.isFailure()) {
-    throw new IOError(self.cause);
-  }
-  return self.value;
+export function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
+  return <EA>(fa: Exit<EA, A>): Exit<EA | EB, C> => {
+    return fa.zipWithCause(fb, f, Cause.parallel);
+  };
 }

package/_src/data/Guard/api.ts

@@ -335,14 +335,14 @@ export function record<A>(codomain: Guard<A>): Guard<Record<string, A>> {
 }
 
 /**
- * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
+ * @tsplus derive fncts.Guard[fncts.ReadonlyArray]<_> 10
  */
-export function deriveImmutableArray<A extends ImmutableArray<any>>(
-  ...[element]: [A] extends [ImmutableArray<infer A>] ? [element: Guard<A>] : never
+export function deriveImmutableArray<A extends ReadonlyArray<any>>(
+  ...[element]: [A] extends [ReadonlyArray<infer A>] ? [element: Guard<A>] : never
 ): Guard<A> {
   return Guard((u): u is A => {
-    if (ImmutableArray.is(u)) {
-      return u._array.every(element.is);
+    if (Array.isArray(u)) {
+      return u.every(element.is);
     }
     return false;
   });
@@ -351,18 +351,18 @@ export function deriveImmutableArray<A extends ImmutableArray<any>>(
 /**
  * @tsplus static fncts.GuardOps immutableArray
  */
-export function immutableArray<A>(base: Guard<A>): Guard<ImmutableArray<A>> {
+export function immutableArray<A>(base: Guard<A>): Guard<ReadonlyArray<A>> {
   return Derive();
 }
 
 /**
- * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus derive fncts.Guard[fncts.ReadonlyNonEmptyArray]<_> 10
  */
-export function deriveImmutableNonEmptyArray<A extends ImmutableNonEmptyArray<any>>(
-  ...[elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never
+export function deriveImmutableNonEmptyArray<A extends ReadonlyNonEmptyArray<any>>(
+  ...[elem]: [A] extends [ReadonlyNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never
 ): Guard<A> {
   return Guard((u): u is A => {
-    if (ImmutableNonEmptyArray.is(u)) {
+    if (Array.isArray(u)) {
       return u.every(elem.is);
     }
     return false;
@@ -372,7 +372,7 @@ export function deriveImmutableNonEmptyArray<A extends ImmutableNonEmptyArray<an
 /**
  * @tsplus static fncts.GuardOps immutableNonEmptyArray
  */
-export function immutableNonEmptyArray<A>(base: Guard<A>): Guard<ImmutableNonEmptyArray<A>> {
+export function immutableNonEmptyArray<A>(base: Guard<A>): Guard<ReadonlyNonEmptyArray<A>> {
   return Derive();
 }