@fncts/base 0.0.1

package/_src/data/Exit/api.ts

@@ -0,0 +1,172 @@
+import { identity, tuple } from "../function.js";
+import { ExitTag } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.Exit ap
+ */
+export function ap_<E, A, G, B>(fab: Exit<G, (a: A) => B>, fa: Exit<E, A>): Exit<E | G, B> {
+  return flatMap_(fab, (f) => map_(fa, (a) => f(a)));
+}
+
+/**
+ * @tsplus fluent fncts.Exit apFirst
+ */
+export function apFirst_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, A> {
+  return fa.zipWithCause(fb, (a, _) => a, Cause.then);
+}
+
+/**
+ * @tsplus fluent fncts.Exit apSecond
+ */
+export function apSecond_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, B> {
+  return fa.zipWithCause(fb, (_, b) => b, Cause.then);
+}
+
+/**
+ * @tsplus fluent fncts.Exit apFirstC
+ */
+export function apFirstC_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, A> {
+  return fa.zipWithCause(fb, (a, _) => a, Cause.both);
+}
+
+/**
+ * @tsplus fluent fncts.Exit apSecondC
+ */
+export function apSecondC_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, B> {
+  return fa.zipWithCause(fb, (_, b) => b, Cause.both);
+}
+
+/**
+ * @tsplus fluent fncts.Exit flatMap
+ */
+export function flatMap_<E, A, G, B>(ma: Exit<E, A>, f: (a: A) => Exit<G, B>): Exit<E | G, B> {
+  return ma.isFailure() ? ma : f(ma.value);
+}
+
+/**
+ * @tsplus fluent fncts.Exit bimap
+ */
+export function bimap_<E1, A, E2, B>(self: Exit<E1, A>, f: (e: E1) => E2, g: (a: A) => B): Exit<E2, B> {
+  return self.isFailure() ? Exit.failCause(self.cause.map(f)) : Exit.succeed(g(self.value));
+}
+
+/**
+ * @tsplus static fncts.ExitOps collectAll
+ */
+export function collectAll<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.then)),
+  );
+}
+
+/**
+ * @tsplus static fncts.ExitOps collectAllC
+ */
+export function collectAllC<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)),
+  );
+}
+
+/**
+ * @tsplus getter fncts.Exit flatten
+ */
+export function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G, A> {
+  return flatMap_(mma, identity);
+}
+
+/**
+ * @tsplus fluent fncts.Exit map
+ */
+export function map_<E, A, B>(fa: Exit<E, A>, f: (a: A) => B): Exit<E, B> {
+  return fa.isFailure() ? fa : Exit.succeed(f(fa.value));
+}
+
+/**
+ * @tsplus fluent fncts.Exit mapError
+ */
+export function mapError_<E1, A, E2>(self: Exit<E1, A>, f: (e: E1) => E2): Exit<E2, A> {
+  return self.isFailure() ? Exit.failCause(self.cause.map(f)) : self;
+}
+
+/**
+ * @tsplus fluent fncts.Exit mapErrorCause
+ */
+export function mapErrorCause_<E1, A, E2>(self: Exit<E1, A>, f: (e: Cause<E1>) => Cause<E2>): Exit<E2, A> {
+  return self.isFailure() ? Exit.failCause(f(self.cause)) : self;
+}
+
+/**
+ * @tsplus fluent fncts.Exit match
+ */
+export function match_<E, A, B, C>(exit: Exit<E, A>, onFailure: (e: Cause<E>) => B, onSuccess: (a: A) => C): B | C {
+  switch (exit._tag) {
+    case ExitTag.Success: {
+      return onSuccess(exit.value);
+    }
+    case ExitTag.Failure: {
+      return onFailure(exit.cause);
+    }
+  }
+}
+
+/**
+ * @tsplus fluent fncts.Exit zipWith
+ */
+export function zipWith_<EA, A, EB, B, C>(fa: Exit<EA, A>, fb: Exit<EB, B>, f: (a: A, b: B) => C): Exit<EA | EB, C> {
+  return fa.zipWithCause(fb, f, Cause.then);
+}
+
+/**
+ * @tsplus fluent fncts.Exit zip
+ */
+export function zip<EA, A, EB, B>(self: Exit<EA, A>, that: Exit<EB, B>): Exit<EA | EB, readonly [A, B]> {
+  return self.zipWith(that, tuple);
+}
+
+/**
+ * @tsplus fluent fncts.Exit zipWithC
+ */
+export function zipWithC_<EA, A, EB, B, C>(fa: Exit<EA, A>, fb: Exit<EB, B>, f: (a: A, b: B) => C): Exit<EA | EB, C> {
+  return fa.zipWithCause(fb, f, Cause.both);
+}
+
+/**
+ * @tsplus fluent fncts.Exit zipC
+ */
+export function zipC<EA, A, EB, B>(self: Exit<EA, A>, that: Exit<EB, B>): Exit<EA | EB, readonly [A, B]> {
+  return self.zipWithC(that, tuple);
+}
+
+/**
+ * @tsplus fluent fncts.Exit zipWithCause
+ */
+export function zipWithCause_<E, A, G, B, C>(
+  fa: Exit<E, A>,
+  fb: Exit<G, B>,
+  f: (a: A, b: B) => C,
+  g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>,
+): Exit<E | G, C> {
+  switch (fa._tag) {
+    case ExitTag.Failure: {
+      switch (fb._tag) {
+        case ExitTag.Success: {
+          return fa;
+        }
+        case ExitTag.Failure: {
+          return Exit.failCause(g(fa.cause, fb.cause));
+        }
+      }
+    }
+    case ExitTag.Success: {
+      switch (fb._tag) {
+        case ExitTag.Success: {
+          return Exit.succeed(f(fa.value, fb.value));
+        }
+        case ExitTag.Failure: {
+          return fb;
+        }
+      }
+    }
+  }
+}

package/_src/data/Exit/constructors.ts

@@ -0,0 +1,55 @@
+import { Failure, Success } from "./definition.js";
+
+/**
+ * @tsplus static fncts.ExitOps halt
+ */
+export function halt(defect: unknown): Exit<never, never> {
+  return failCause(Cause.halt(defect));
+}
+
+/**
+ * @tsplus static fncts.ExitOps fail
+ */
+export function fail<E = never, A = never>(e: E): Exit<E, A> {
+  return failCause(Cause.fail(e));
+}
+
+/**
+ * @tsplus static fncts.ExitOps fromEither
+ */
+export function fromEither<E = never, A = never>(e: Either<E, A>): Exit<E, A> {
+  return e.match(fail, succeed);
+}
+
+/**
+ * @tsplus static fncts.ExitOps fromMaybe
+ */
+export function fromMaybe_<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A> {
+  return fa.match(() => fail(onNothing()), succeed);
+}
+
+/**
+ * @tsplus static fncts.ExitOps failCause
+ */
+export function failCause<E = never, A = never>(cause: Cause<E>): Exit<E, A> {
+  return new Failure(cause);
+}
+
+/**
+ * @tsplus static fncts.ExitOps interrupt
+ */
+export function interrupt(id: FiberId) {
+  return failCause(Cause.interrupt(id));
+}
+
+/**
+ * @tsplus static fncts.ExitOps succeed
+ */
+export function succeed<E = never, A = never>(value: A): Exit<E, A> {
+  return new Success(value);
+}
+
+/**
+ * @tsplus static fncts.ExitOps unit
+ */
+export const unit: Exit<never, void> = Exit.succeed(undefined);

package/_src/data/Exit/definition.ts

@@ -0,0 +1,102 @@
+import * as P from "../../typeclass.js";
+import { hasTypeId } from "../../util/predicates.js";
+
+export const ExitTypeId = Symbol.for("fncts.Exit");
+export type ExitTypeId = typeof ExitTypeId;
+
+/**
+ * @tsplus type fncts.Exit
+ */
+export type Exit<E, A> = Success<A> | Failure<E>;
+
+/**
+ * @tsplus type fncts.ExitOps
+ */
+export interface ExitOps {}
+
+export const Exit: ExitOps = {};
+
+export const enum ExitTag {
+  Success = "Success",
+  Failure = "Failure",
+}
+
+const _failureHash = Hashable.string("fncts.Exit.Failure");
+const _successHash = Hashable.string("fncts.Exit.Success");
+
+/**
+ * @tsplus type fncts.Exit.Failure
+ * @tsplus companion fncts.Exit.FailureOps
+ */
+export class Failure<E> {
+  readonly _E!: () => E;
+  readonly _A!: () => never;
+
+  readonly _typeId: ExitTypeId = ExitTypeId;
+  readonly _tag                = ExitTag.Failure;
+  constructor(readonly cause: Cause<E>) {}
+
+  get [Symbol.hash](): number {
+    return Hashable.combine(_failureHash, Hashable.unknown(this.cause));
+  }
+  [Symbol.equals](that: unknown): boolean {
+    return isExit(that) && isFailure(that) && P.Equatable.strictEquals(this.cause, that.cause);
+  }
+}
+
+/**
+ * @tsplus type fncts.Exit.Success
+ * @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;
+  constructor(readonly value: A) {}
+
+  get [Symbol.hash](): number {
+    return Hashable.combine(_successHash, Hashable.unknown(this.value));
+  }
+  [Symbol.equals](that: unknown): boolean {
+    return isExit(that) && isSuccess(that) && P.Equatable.strictEquals(this.value, that.value);
+  }
+}
+
+/**
+ * @tsplus static fncts.ExitOps isExit
+ */
+export function isExit(u: unknown): u is Exit<unknown, unknown> {
+  return hasTypeId(u, ExitTypeId);
+}
+
+/**
+ * @tsplus fluent fncts.Exit isFailure
+ */
+export function isFailure<E, A>(exit: Exit<E, A>): exit is Failure<E> {
+  return exit._tag === ExitTag.Failure;
+}
+
+/**
+ * @tsplus fluent fncts.Exit isInterrupt
+ */
+export function isInterrupt<E, A>(exit: Exit<E, A>): exit is Failure<E> {
+  return exit.isFailure() ? exit.cause.interrupted : false;
+}
+
+/**
+ * @tsplus fluent fncts.Exit isSuccess
+ */
+export function isSuccess<E, A>(exit: Exit<E, A>): exit is Success<A> {
+  return exit._tag === ExitTag.Success;
+}
+
+/**
+ * @tsplus unify fncts.Exit
+ */
+export function unifyExit<X extends Exit<any, any>>(
+  _: X,
+): Exit<[X] extends [Exit<infer E, any>] ? E : never, [X] extends [Exit<any, infer A>] ? A : never> {
+  return _;
+}

package/_src/data/Exit.ts

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

package/_src/data/FiberId/api.ts

@@ -0,0 +1,45 @@
+import { Composite, isComposite, isNone } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.FiberId combine
+ */
+export function combine_(id0: FiberId, id1: FiberId): FiberId {
+  if (isNone(id0)) {
+    return id1;
+  }
+  if (isNone(id1)) {
+    return id0;
+  }
+  if (isComposite(id0)) {
+    if (isComposite(id1)) {
+      return new Composite(id0.fiberIds.union(id1.fiberIds));
+    } else {
+      return new Composite(id0.fiberIds.add(id1));
+    }
+  }
+  if (isComposite(id1)) {
+    return new Composite(id1.fiberIds.add(id0));
+  }
+  return new Composite(HashSet.fromDefault(id0, id1));
+}
+
+/**
+ * @tsplus getter fncts.FiberId ids
+ */
+export function ids(self: FiberId): HashSet<number> {
+  switch (self._tag) {
+    case "None":
+      return HashSet.makeDefault();
+    case "Runtime":
+      return HashSet.fromDefault(self.id);
+    case "Composite":
+      return self.fiberIds.map((id) => id.id);
+  }
+}
+
+/**
+ * @tsplus getter fncts.FiberId threadName
+ */
+export function threadName(self: FiberId): string {
+  return `fncts-fiber-${self.ids.map((n) => n.toString()).join(",")}`;
+}

package/_src/data/FiberId/constructors.ts

@@ -0,0 +1,21 @@
+import { AtomicNumber } from "../../internal/AtomicNumber.js";
+import { None, Runtime } from "./definition.js";
+
+/**
+ * @tsplus static fncts.FiberIdOps none
+ */
+export const none = new None();
+
+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);
+}
+
+/**
+ * @tsplus static fncts.FiberIdOps synthetic
+ */
+export const synthetic = new Runtime(-1, -1, TraceElement.NoLocation);

package/_src/data/FiberId/definition.ts

@@ -0,0 +1,91 @@
+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";
+  [Symbol.equals](that: unknown) {
+    return isFiberId(that) && isNone(that);
+  }
+  get [Symbol.hash]() {
+    return _hashNone;
+  }
+}
+
+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) {}
+  get [Symbol.hash]() {
+    return Hashable.combine(Hashable.combine(_hashRuntime, Hashable.number(this.id)), Hashable.unknown(this.location));
+  }
+  [Symbol.equals](that: unknown): boolean {
+    return isFiberId(that) && isRuntime(that) && this.id === that.id && this.startTime === that.startTime;
+  }
+}
+
+const _hashComposite = Hashable.string("fncts.FiberId.Composite");
+
+export class Composite implements Hashable, Equatable {
+  readonly _typeId: FiberIdTypeId = FiberIdTypeId;
+  readonly _tag                   = "Composite";
+  constructor(readonly fiberIds: HashSet<Runtime>) {}
+  [Symbol.equals](that: unknown) {
+    return isFiberId(that) && isComposite(that) && this.fiberIds == that.fiberIds;
+  }
+  get [Symbol.hash]() {
+    return Hashable.combine(_hashComposite, Hashable.unknown(this.fiberIds));
+  }
+}
+
+/**
+ * @tsplus type fncts.FiberId
+ */
+export type FiberId = None | Runtime | Composite;
+
+/**
+ * @tsplus type fncts.FiberIdOps
+ */
+export interface FiberIdOps {}
+
+export const FiberId: FiberIdOps = {};
+
+type RuntimeFiberId = Runtime;
+
+export declare namespace FiberId {
+  type Runtime = RuntimeFiberId;
+}
+
+/**
+ * @tsplus static fncts.FiberIdOps isFiberId
+ */
+export function isFiberId(u: unknown): u is FiberId {
+  return hasTypeId(u, FiberIdTypeId);
+}
+
+/**
+ * @tsplus static fncts.FiberIdOps isNone
+ */
+export function isNone(fiberId: FiberId): fiberId is None {
+  return fiberId._tag === "None";
+}
+
+/**
+ * @tsplus static fncts.FiberIdOps isRuntime
+ */
+export function isRuntime(fiberId: FiberId): fiberId is Runtime {
+  return fiberId._tag === "Runtime";
+}
+
+/**
+ * @tsplus static fncts.FiberIdOps isComposite
+ */
+export function isComposite(fiberId: FiberId): fiberId is Composite {
+  return fiberId._tag === "Composite";
+}

package/_src/data/FiberId.ts

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

package/_src/data/Identity/api.ts

@@ -0,0 +1,28 @@
+/**
+ * @tsplus fluent fncts.Identity ap
+ */
+export function ap_<A, B>(fab: Identity<(a: A) => B>, fa: Identity<A>): Identity<B> {
+  return fab(fa);
+}
+
+/**
+ * @tsplus fluent fncts.Identity map
+ */
+export function map_<A, B>(fa: Identity<A>, f: (a: A) => B): Identity<B> {
+  return f(fa);
+}
+
+/**
+ * @tsplus static fncts.IdentityOps pure
+ * @tsplus static fncts.IdentityOps __call
+ */
+export function pure<A>(a: A): Identity<A> {
+  return a;
+}
+
+/**
+ * @tsplus fluent fncts.Identity zipWith
+ */
+export function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (a: A, b: B) => C): Identity<C> {
+  return f(fa, fb);
+}

package/_src/data/Identity/definition.ts

@@ -0,0 +1,11 @@
+/**
+ * @tsplus type fncts.Identity
+ */
+export type Identity<A> = A;
+
+/**
+ * @tsplus type fncts.IdentityOps
+ */
+export interface IdentityOps {}
+
+export const Identity: IdentityOps = {};

package/_src/data/Identity/instances.ts

@@ -0,0 +1,21 @@
+import * as P from "../../typeclass.js";
+import { ap_, map_, pure, zipWith_ } from "./api.js";
+
+export interface IdentityF extends HKT {
+  readonly type: Identity<this["A"]>;
+}
+
+/**
+ * @tsplus static fncts.IdentityOps Functor
+ */
+export const Functor = P.Functor<IdentityF>({ map_ });
+
+/**
+ * @tsplus static fncts.IdentityOps Apply
+ */
+export const Apply = P.Apply<IdentityF>({ map_, ap_, zipWith_ });
+
+/**
+ * @tsplus static fncts.IdentityOps Applicative
+ */
+export const Applicative = P.Applicative<IdentityF>({ map_, ap_, zipWith_, pure });

package/_src/data/Identity.ts

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