@fncts/base 0.0.21 → 0.0.23

package/_src/{typeclass → data}/Equatable/fast-equals.ts

@@ -1,10 +1,13 @@
 /* Forked from https://github.com/planttheidea/fast-equals */
 const HAS_WEAKSET_SUPPORT = typeof WeakSet === "function";
-const { keys }            = Object;
+
+const { keys } = Object;
+
 type Cache = {
   add: (value: any) => void;
   has: (value: any) => boolean;
 };
+
 /**
  * @function addToCache
  *
@@ -18,7 +21,9 @@ export function addToCache(value: any, cache: Cache) {
     cache.add(value);
   }
 }
+
 export type EqualityComparator = (a: any, b: any, meta?: any) => boolean;
+
 /**
  * @function hasPair
  *
@@ -43,6 +48,7 @@ export function hasPair(pairs: [any, any][], pairToMatch: [any, any], isEqual: E
   }
   return false;
 }
+
 /**
  * @function hasValue
  *
@@ -65,6 +71,7 @@ export function hasValue(values: any[], valueToMatch: any, isEqual: EqualityComp
   }
   return false;
 }
+
 /**
  * @function sameValueZeroEqual
  *
@@ -78,6 +85,7 @@ export function hasValue(values: any[], valueToMatch: any, isEqual: EqualityComp
 export function sameValueZeroEqual(a: any, b: any) {
   return a === b || (a !== a && b !== b);
 }
+
 /**
  * @function isPlainObject
  *
@@ -90,6 +98,7 @@ export function sameValueZeroEqual(a: any, b: any) {
 export function isPlainObject(value: any) {
   return value.constructor === Object || value.constructor == null;
 }
+
 /**
  * @function isPromiseLike
  *
@@ -102,6 +111,7 @@ export function isPlainObject(value: any) {
 export function isPromiseLike(value: any) {
   return !!value && typeof value.then === "function";
 }
+
 /**
  * @function isReactElement
  *
@@ -114,6 +124,7 @@ export function isPromiseLike(value: any) {
 export function isReactElement(value: any) {
   return !!(value && value.$$typeof);
 }
+
 /**
  * @function getNewCacheFallback
  *
@@ -136,6 +147,7 @@ export function getNewCacheFallback(): Cache {
     },
   });
 }
+
 /**
  * @function getNewCache
  *
@@ -152,6 +164,7 @@ export const getNewCache = ((canUseWeakMap: boolean) => {
   }
   return getNewCacheFallback;
 })(HAS_WEAKSET_SUPPORT);
+
 /**
  * @function createCircularEqualCreator
  *
@@ -176,6 +189,7 @@ export function createCircularEqualCreator(isEqual?: EqualityComparatorCreator)
     };
   };
 }
+
 /**
  * @function toPairs
  *
@@ -193,6 +207,7 @@ export function toPairs(map: Map<any, any>): [any, any][] {
   });
   return pairs;
 }
+
 /**
  * @function toValues
  *
@@ -210,6 +225,7 @@ export function toValues(set: Set<any>) {
   });
   return values;
 }
+
 /**
  * @function areArraysEqual
  *
@@ -234,6 +250,7 @@ export function areArraysEqual(a: any[], b: any[], isEqual: EqualityComparator,
   }
   return true;
 }
+
 /**
  * @function areMapsEqual
  *
@@ -260,12 +277,16 @@ export function areMapsEqual(a: Map<any, any>, b: Map<any, any>, isEqual: Equali
   }
   return true;
 }
+
 type Dictionary<Type> = {
   [key: string]: Type;
   [index: number]: Type;
 };
-const OWNER          = "_owner";
+
+const OWNER = "_owner";
+
 const hasOwnProperty = Function.prototype.bind.call(Function.prototype.call, Object.prototype.hasOwnProperty);
+
 /**
  * @function areObjectsEqual
  *
@@ -300,6 +321,7 @@ export function areObjectsEqual(a: Dictionary<any>, b: Dictionary<any>, isEqual:
   }
   return true;
 }
+
 /**
  * @function areRegExpsEqual
  *
@@ -321,6 +343,7 @@ export function areRegExpsEqual(a: RegExp, b: RegExp) {
     a.lastIndex === b.lastIndex
   );
 }
+
 /**
  * @function areSetsEqual
  *
@@ -347,11 +370,17 @@ export function areSetsEqual(a: Set<any>, b: Set<any>, isEqual: EqualityComparat
   }
   return true;
 }
-const { isArray }     = Array;
+
+const { isArray } = Array;
+
 const HAS_MAP_SUPPORT = typeof Map === "function";
+
 const HAS_SET_SUPPORT = typeof Set === "function";
-const OBJECT_TYPEOF   = "object";
+
+const OBJECT_TYPEOF = "object";
+
 type EqualityComparatorCreator = (fn: EqualityComparator) => EqualityComparator;
+
 export function createComparator(createIsEqual?: EqualityComparatorCreator) {
   const isEqual: EqualityComparator =
     /* eslint-disable no-use-before-define */

package/_src/data/Exit/api.ts

@@ -4,45 +4,45 @@ import { ExitTag } from "./definition.js";
 /**
  * @tsplus pipeable fncts.Exit ap
  */
-export function ap<E, A>(fa: Exit<E, A>) {
-  return <G, B>(fab: Exit<G, (a: A) => B>): Exit<E | G, B> => {
-    return fab.flatMap((f) => fa.map((a) => f(a)));
+export function ap<E, A>(that: Exit<E, A>) {
+  return <G, B>(self: Exit<G, (a: A) => B>): Exit<E | G, B> => {
+    return self.flatMap((f) => that.map((a) => f(a)));
   };
 }
 
 /**
- * @tsplus pipeable fncts.Exit apFirst
+ * @tsplus pipeable fncts.Exit zipLeft
  */
-export function apFirst<G, B>(fb: Exit<G, B>) {
-  return <E, A>(fa: Exit<E, A>): Exit<E | G, A> => {
-    return fa.zipWithCause(fb, (a, _) => a, Cause.then);
+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.then);
   };
 }
 
 /**
- * @tsplus pipeable fncts.Exit apSecond
+ * @tsplus pipeable fncts.Exit zipRight
  */
-export function apSecond<G, B>(fb: Exit<G, B>) {
-  return <E, A>(fa: Exit<E, A>): Exit<E | G, B> => {
-    return fa.zipWithCause(fb, (_, b) => b, Cause.then);
+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.then);
   };
 }
 
 /**
- * @tsplus pipeable fncts.Exit apFirstC
+ * @tsplus pipeable fncts.Exit zipLeftConcurrent
  */
-export function apFirstC<G, B>(fb: Exit<G, B>) {
-  return <E, A>(fa: Exit<E, A>): Exit<E | G, A> => {
-    return fa.zipWithCause(fb, (a, _) => a, Cause.both);
+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.both);
   };
 }
 
 /**
- * @tsplus pipeable fncts.Exit apSecondC
+ * @tsplus pipeable fncts.Exit zipRightConcurrent
  */
-export function apSecondC<G, B>(fb: Exit<G, B>) {
-  return <E, A>(fa: Exit<E, A>): Exit<E | G, B> => {
-    return fa.zipWithCause(fb, (_, b) => b, Cause.both);
+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.both);
   };
 }
 
@@ -74,9 +74,9 @@ export function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>
 }
 
 /**
- * @tsplus static fncts.ExitOps collectAllC
+ * @tsplus static fncts.ExitOps collectAllConcurrent
  */
-export function collectAllC<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>> {
+export function collectAllConcurrent<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>> {
   return exits.head.map((head) =>
     exits.drop(1).foldLeft(head.map(Conc.single), (acc, el) => acc.zipWithCause(el, (c, a) => c.append(a), Cause.both)),
   );
@@ -151,20 +151,20 @@ export function zip<EB, B>(that: Exit<EB, B>) {
 }
 
 /**
- * @tsplus pipeable fncts.Exit zipWithC
+ * @tsplus pipeable fncts.Exit zipWithConcurrent
  */
-export function zipWithC<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
+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.both);
   };
 }
 
 /**
- * @tsplus pipeable fncts.Exit zipC
+ * @tsplus pipeable fncts.Exit zipConcurrent
  */
-export function zipC<EB, B>(that: Exit<EB, B>) {
+export function zipConcurrent<EB, B>(that: Exit<EB, B>) {
   return <EA, A>(self: Exit<EA, A>): Exit<EA | EB, readonly [A, B]> => {
-    return self.zipWithC(that, tuple);
+    return self.zipWithConcurrent(that, tuple);
   };
 }
 

package/_src/data/Exit/definition.ts

@@ -1,5 +1,7 @@
 import * as P from "../../typeclass.js";
-import { hasTypeId } from "../../util/predicates.js";
+
+export const ExitVariance = Symbol.for("fncts.Exit");
+export type ExitVariance = typeof ExitVariance;
 
 export const ExitTypeId = Symbol.for("fncts.Exit");
 export type ExitTypeId = typeof ExitTypeId;
@@ -29,11 +31,12 @@ const _successHash = Hashable.string("fncts.Exit.Success");
  * @tsplus companion fncts.Exit.FailureOps
  */
 export class Failure<E> {
-  readonly _E!: () => E;
-  readonly _A!: () => never;
-
-  readonly _typeId: ExitTypeId = ExitTypeId;
-  readonly _tag                = ExitTag.Failure;
+  readonly [ExitTypeId]: ExitTypeId = ExitTypeId;
+  declare [ExitVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => never;
+  };
+  readonly _tag = ExitTag.Failure;
   constructor(readonly cause: Cause<E>) {}
 
   get [Symbol.hash](): number {
@@ -49,11 +52,12 @@ export class Failure<E> {
  * @tsplus companion fncts.Exit.SuccessOps
  */
 export class Success<A> implements P.Hashable, P.Equatable {
-  readonly _E!: () => never;
-  readonly _A!: () => A;
-
-  readonly _typeId: ExitTypeId = ExitTypeId;
-  readonly _tag                = ExitTag.Success;
+  readonly [ExitTypeId]: ExitTypeId = ExitTypeId;
+  declare [ExitVariance]: {
+    readonly _E: (_: never) => never;
+    readonly _A: (_: never) => A;
+  };
+  readonly _tag = ExitTag.Success;
   constructor(readonly value: A) {}
 
   get [Symbol.hash](): number {
@@ -68,7 +72,7 @@ export class Success<A> implements P.Hashable, P.Equatable {
  * @tsplus static fncts.ExitOps isExit
  */
 export function isExit(u: unknown): u is Exit<unknown, unknown> {
-  return hasTypeId(u, ExitTypeId);
+  return isObject(u) && ExitTypeId in u;
 }
 
 /**

package/_src/data/FiberId/api.ts

@@ -21,7 +21,7 @@ export function combine(id1: FiberId) {
     if (isComposite(id1)) {
       return new Composite(id1.fiberIds.add(id0));
     }
-    return new Composite(HashSet.fromDefault(id0, id1));
+    return new Composite(HashSet.make(id0, id1));
   };
 }
 
@@ -31,9 +31,9 @@ export function combine(id1: FiberId) {
 export function ids(self: FiberId): HashSet<number> {
   switch (self._tag) {
     case "None":
-      return HashSet.makeDefault();
+      return HashSet.empty();
     case "Runtime":
-      return HashSet.fromDefault(self.id);
+      return HashSet.make(self.id);
     case "Composite":
       return self.fiberIds.map((id) => id.id);
   }

package/_src/data/FiberId/constructors.ts

@@ -10,11 +10,11 @@ const _fiberCounter = new AtomicNumber(0);
 /**
  * @tsplus static fncts.FiberIdOps unsafeMake
  */
-export function unsafeMake(location: TraceElement): Runtime {
-  return new Runtime(_fiberCounter.getAndIncrement(), new Date().getTime(), location);
+export function unsafeMake(__tsplusTrace?: string): Runtime {
+  return new Runtime(_fiberCounter.getAndIncrement(), new Date().getTime(), __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.FiberIdOps synthetic
  */
-export const synthetic = new Runtime(-1, -1, TraceElement.NoLocation);
+export const synthetic = new Runtime(-1, -1, undefined);

package/_src/data/FiberId/definition.ts

@@ -1,13 +1,11 @@
-import { hasTypeId } from "../../util/predicates.js";
-
 export const FiberIdTypeId = Symbol.for("fncts.FiberId");
 export type FiberIdTypeId = typeof FiberIdTypeId;
 
 const _hashNone = Hashable.string("fncts.FiberId.None");
 
 export class None implements Hashable, Equatable {
-  readonly _typeId: FiberIdTypeId = FiberIdTypeId;
-  readonly _tag                   = "None";
+  readonly [FiberIdTypeId]: FiberIdTypeId = FiberIdTypeId;
+  readonly _tag = "None";
   [Symbol.equals](that: unknown) {
     return isFiberId(that) && isNone(that);
   }
@@ -19,9 +17,9 @@ export class None implements Hashable, Equatable {
 const _hashRuntime = Hashable.string("fncts.FiberId.Runtime");
 
 export class Runtime implements Hashable, Equatable {
-  readonly _typeId: FiberIdTypeId = FiberIdTypeId;
-  readonly _tag                   = "Runtime";
-  constructor(readonly id: number, readonly startTime: number, readonly location: TraceElement) {}
+  readonly [FiberIdTypeId]: FiberIdTypeId = FiberIdTypeId;
+  readonly _tag = "Runtime";
+  constructor(readonly id: number, readonly startTime: number, readonly location?: string) {}
   get [Symbol.hash]() {
     return Hashable.combine(Hashable.combine(_hashRuntime, Hashable.number(this.id)), Hashable.unknown(this.location));
   }
@@ -33,8 +31,8 @@ export class Runtime implements Hashable, Equatable {
 const _hashComposite = Hashable.string("fncts.FiberId.Composite");
 
 export class Composite implements Hashable, Equatable {
-  readonly _typeId: FiberIdTypeId = FiberIdTypeId;
-  readonly _tag                   = "Composite";
+  readonly [FiberIdTypeId]: FiberIdTypeId = FiberIdTypeId;
+  readonly _tag = "Composite";
   constructor(readonly fiberIds: HashSet<Runtime>) {}
   [Symbol.equals](that: unknown) {
     return isFiberId(that) && isComposite(that) && this.fiberIds == that.fiberIds;
@@ -66,11 +64,12 @@ export declare namespace FiberId {
  * @tsplus static fncts.FiberIdOps isFiberId
  */
 export function isFiberId(u: unknown): u is FiberId {
-  return hasTypeId(u, FiberIdTypeId);
+  return isObject(u) && FiberIdTypeId in u;
 }
 
 /**
  * @tsplus static fncts.FiberIdOps isNone
+ * @tsplus fluent fncts.FiberId isNone
  */
 export function isNone(fiberId: FiberId): fiberId is None {
   return fiberId._tag === "None";
@@ -78,6 +77,7 @@ export function isNone(fiberId: FiberId): fiberId is None {
 
 /**
  * @tsplus static fncts.FiberIdOps isRuntime
+ * @tsplus fluent fncts.FiberId isRuntime
  */
 export function isRuntime(fiberId: FiberId): fiberId is Runtime {
   return fiberId._tag === "Runtime";
@@ -85,6 +85,7 @@ export function isRuntime(fiberId: FiberId): fiberId is Runtime {
 
 /**
  * @tsplus static fncts.FiberIdOps isComposite
+ * @tsplus fluent fncts.FiberId isComposite
  */
 export function isComposite(fiberId: FiberId): fiberId is Composite {
   return fiberId._tag === "Composite";