@fncts/base 0.0.1

package/_src/data/Either/api/alignWith.ts

@@ -0,0 +1,21 @@
+import type { Either } from "../definition.js";
+
+import { These } from "../../These.js";
+import { EitherTag, Right } from "../definition.js";
+
+/**
+ * @tsplus fluent fncts.Either alignWith
+ */
+export function alignWith_<E1, A, E2, B, C>(
+  self: Either<E1, A>,
+  fb: Either<E2, B>,
+  f: (_: These<A, B>) => C,
+): Either<E1 | E2, C> {
+  return self._tag === EitherTag.Left
+    ? fb._tag === EitherTag.Left
+      ? self
+      : Right(f(These.right(fb.right)))
+    : fb._tag === EitherTag.Left
+    ? Right(f(These.left(self.right)))
+    : Right(f(These.both(self.right, fb.right)));
+}

package/_src/data/Either/api.ts

@@ -0,0 +1,200 @@
+import type * as P from "../../typeclass.js";
+import type { EitherF } from "./instances.js";
+
+import { hasTypeId } from "../../util/predicates.js";
+import { identity } from "../function.js";
+import { EitherTag, EitherTypeId, Left, Right } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.Either ap
+ */
+export function ap_<E1, A, E2, B>(self: Either<E1, (a: A) => B>, fa: Either<E2, A>): Either<E1 | E2, B> {
+  return self._tag === EitherTag.Left ? self : fa._tag === EitherTag.Left ? fa : Right(self.right(fa.right));
+}
+
+/**
+ * @tsplus fluent fncts.Either bimap
+ */
+export function bimap_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => E2, g: (a: A) => B): Either<E2, B> {
+  return self._tag === EitherTag.Left ? Left(f(self.left)) : Right(g(self.right));
+}
+
+/**
+ * @tsplus fluent fncts.Either catchAll
+ */
+export function catchAll_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => Either<E2, B>): Either<E2, A | B> {
+  return self._tag === EitherTag.Left ? f(self.left) : self;
+}
+
+/**
+ * @tsplus fluent fncts.Either catchJust
+ */
+export function catchJust_<E1, A, E2, B>(
+  self: Either<E1, A>,
+  f: (e: E1) => Maybe<Either<E2, B>>,
+): Either<E1 | E2, A | B> {
+  return self.catchAll((e): Either<E1 | E2, A | B> => f(e).getOrElse(self));
+}
+
+/**
+ * @tsplus fluent fncts.Either catchMap
+ */
+export function catchMap_<E, A, B>(self: Either<E, A>, f: (e: E) => B): Either<never, A | B> {
+  return self.catchAll((e) => Right(f(e)));
+}
+
+/**
+ * @tsplus fluent fncts.Either flatMap
+ */
+export function flatMap_<E1, A, E2, B>(self: Either<E1, A>, f: (a: A) => Either<E2, B>): Either<E1 | E2, B> {
+  return self._tag === EitherTag.Left ? self : f(self.right);
+}
+
+/**
+ * @tsplus fluent fncts.Either foldLeft
+ */
+export function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a: A) => B): B {
+  return self._tag === EitherTag.Left ? b : f(b, self.right);
+}
+
+/**
+ * @tsplus fluent fncts.Either foldRight
+ */
+export function foldRight_<E, A, B>(self: Either<E, A>, b: B, f: (a: A, b: B) => B): B {
+  return self._tag === EitherTag.Left ? b : f(self.right, b);
+}
+
+/**
+ * @constrained
+ */
+export function foldMap_<M>(M: P.Monoid<M>) {
+  return <E, A>(self: Either<E, A>, f: (a: A) => M): M => (self._tag === EitherTag.Left ? M.nat : f(self.right));
+}
+
+/**
+ * @tsplus getter fncts.Either foldMap
+ */
+export function foldMapSelf<E, A>(self: Either<E, A>) {
+  return <M>(M: P.Monoid<M>) =>
+    (f: (a: A) => M): M =>
+      foldMap_(M)(self, f);
+}
+
+/**
+ * @tsplus getter fncts.Either getLeft
+ */
+export function getLeft<E, A>(self: Either<E, A>): Maybe<E> {
+  return self.match(
+    (e) => Just(e),
+    (_a) => Nothing(),
+  );
+}
+
+/**
+ * @tsplus getter fncts.Either getRight
+ */
+export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
+  return self.match(
+    (_e) => Nothing(),
+    (a) => Just(a),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.Either getOrElse
+ */
+export function getOrElse_<E, A, B>(self: Either<E, A>, orElse: (e: E) => B): A | B {
+  return self.match(orElse, identity);
+}
+
+/**
+ * @tsplus static fncts.EitherOps isEither
+ */
+export function isEither(u: unknown): u is Either<unknown, unknown> {
+  return hasTypeId(u, EitherTypeId);
+}
+
+/**
+ * @tsplus fluent fncts.Either isLeft
+ * @tsplus static fncts.EitherOps isLeft
+ */
+export function isLeft<E, A>(self: Either<E, A>): self is Left<E> {
+  return self._tag === EitherTag.Left;
+}
+
+/**
+ * @tsplus fluent fncts.Either isRight
+ * @tsplus static fncts.EitherOps isRight
+ */
+export function isRight<E, A>(self: Either<E, A>): self is Right<A> {
+  return self._tag === EitherTag.Right;
+}
+
+/**
+ * @tsplus fluent fncts.Either map
+ */
+export function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B> {
+  return self._tag === EitherTag.Left ? self : Right(f(self.right));
+}
+
+/**
+ * @tsplus fluent fncts.Either mapLeft
+ */
+export function mapLeft_<E1, A, E2>(self: Either<E1, A>, f: (e: E1) => E2): Either<E2, A> {
+  return self._tag === EitherTag.Left ? Left(f(self.left)) : self;
+}
+
+/**
+ * @tsplus getter fncts.Either value
+ */
+export function merge<E, A>(self: Either<E, A>): E | A {
+  return self.match(identity, identity);
+}
+
+/**
+ * @tsplus fluent fncts.Either orElse
+ */
+export function orElse_<E1, A, E2, B>(self: Either<E1, A>, that: Lazy<Either<E2, B>>): Either<E1 | E2, A | B> {
+  return self._tag === EitherTag.Left ? that() : self;
+}
+
+export const sequence: P.sequence<EitherF> = (A) => (self) => traverse_(A)(self, identity);
+
+/**
+ * @tsplus getter fncts.Either sequence
+ */
+export const sequenceSelf: P.sequenceSelf<EitherF> = (self) => (A) =>
+  unsafeCoerce(traverse_(A)(self, unsafeCoerce(identity)));
+
+/**
+ * @tsplus getter fncts.Either swap
+ */
+export function swap<E, A>(self: Either<E, A>): Either<A, E> {
+  return self._tag === EitherTag.Left ? Right(self.left) : Left(self.right);
+}
+
+export const traverse_: P.traverse_<EitherF> = (A) => (self, f) =>
+  self.match(
+    (e) => A.pure(Left(e)),
+    (a) => f(a).via(A.map((b) => Right(b))),
+  );
+
+export const traverse: P.traverse<EitherF> = (A) => (f) => (self) => traverse_(A)(self, f);
+
+/**
+ * @tsplus getter fncts.Either traverse
+ */
+export const traverseSelf: P.traverseSelf<EitherF> = (self) => (A) => (f) => traverse_(A)(self, f);
+
+export function zipWith_<E1, A, E2, B, C>(
+  self: Either<E1, A>,
+  fb: Either<E2, B>,
+  f: (a: A, b: B) => C,
+): Either<E1 | E2, C> {
+  return self._tag === EitherTag.Left ? self : fb._tag === EitherTag.Left ? fb : Right(f(self.right, fb.right));
+}
+
+// codegen:start { preset: barrel, include: api/*.ts }
+export * from "./api/align.js";
+export * from "./api/alignWith.js";
+// codegen:end

package/_src/data/Either/constructors.ts

@@ -0,0 +1,77 @@
+import type { Nullable } from "@fncts/base/types";
+
+import { Either, Left, Right } from "./definition.js";
+
+/**
+ * @tsplus static fncts.EitherOps left
+ * @tsplus static fncts.Either.LeftOps __call
+ */
+export function left<E = never, A = never>(e: E): Either<E, A> {
+  return new Left(e);
+}
+
+/**
+ * @tsplus static fncts.EitherOps right
+ * @tsplus static fncts.Either.RightOps __call
+ */
+export function right<E = never, A = never>(a: A): Either<E, A> {
+  return new Right(a);
+}
+
+/**
+ * @tsplus static fncts.EitherOps fromMaybe
+ * @tsplus fluent fncts.Maybe toEither
+ */
+export function fromMaybe_<E, A>(self: Maybe<A>, nothing: Lazy<E>): Either<E, A> {
+  return self.match(
+    () => Left(nothing()),
+    (a) => Right(a),
+  );
+}
+
+/**
+ * @tsplus static fncts.EitherOps fromNullable
+ */
+export function fromNullable_<E, A>(value: A, nullable: Lazy<E>): Either<E, NonNullable<A>> {
+  return value == null ? Left(nullable()) : Right(value as NonNullable<A>);
+}
+
+/**
+ * @tsplus static fncts.EitherOps fromNullableK
+ */
+export function fromNullableK<E, P extends ReadonlyArray<unknown>, A>(
+  f: (...params: P) => Nullable<A>,
+  nullable: Lazy<E>,
+): (...params: P) => Either<E, NonNullable<A>> {
+  return (...params) => Either.fromNullable(f(...params), nullable);
+}
+
+/**
+ * @tsplus static fncts.EitherOps fromPredicate
+ */
+export function fromPredicate_<E, A, B extends A>(value: A, p: Refinement<A, B>, otherwise: (a: A) => E): Either<E, B>;
+export function fromPredicate_<E, A>(value: A, p: Predicate<A>, otherwise: (a: A) => E): Either<E, A>;
+export function fromPredicate_<E, A>(value: A, p: Predicate<A>, otherwise: (a: A) => E): Either<E, A> {
+  return p(value) ? Right(value) : left(otherwise(value));
+}
+
+/**
+ * @tsplus static fncts.EitherOps tryCatch
+ */
+export function tryCatch<E, A>(thunk: () => A, exception: (e: unknown) => E): Either<E, A> {
+  try {
+    return Right(thunk());
+  } catch (e) {
+    return Left(exception(e));
+  }
+}
+
+/**
+ * @tsplus static fncts.EitherOps tryCatchK
+ */
+export function tryCatchK<P extends ReadonlyArray<unknown>, E, A>(
+  f: (...params: P) => A,
+  exception: (e: unknown) => E,
+): (...params: P) => Either<E, A> {
+  return (...params) => Either.tryCatch(() => f(...params), exception);
+}

package/_src/data/Either/definition.ts

@@ -0,0 +1,48 @@
+export const enum EitherTag {
+  Left = "Left",
+  Right = "Right",
+}
+
+export const EitherTypeId = Symbol.for("fncts.base.data.Either");
+export type EitherTypeId = typeof EitherTypeId;
+
+/**
+ * @tsplus type fncts.Either.Left
+ * @tsplus companion fncts.Either.LeftOps
+ */
+export class Left<E> {
+  readonly _typeId: EitherTypeId = EitherTypeId;
+  readonly _tag                  = EitherTag.Left;
+  constructor(readonly left: E) {}
+}
+
+/**
+ * @tsplus type fncts.Either.Right
+ * @tsplus companion fncts.Either.RightOps
+ */
+export class Right<A> {
+  readonly _typeId: EitherTypeId = EitherTypeId;
+  readonly _tag                  = EitherTag.Right;
+  constructor(readonly right: A) {}
+}
+
+/**
+ * @tsplus type fncts.Either
+ */
+export type Either<E, A> = Left<E> | Right<A>;
+
+/**
+ * @tsplus type fncts.EitherOps
+ */
+export interface EitherOps {}
+
+export const Either: EitherOps = {};
+
+/**
+ * @tsplus unify fncts.Either
+ */
+export function unifyEither<X extends Either<any, any>>(
+  self: X,
+): Either<[X] extends [Either<infer E, any>] ? E : never, [X] extends [Either<any, infer A>] ? A : never> {
+  return self;
+}

package/_src/data/Either/destructors.ts

@@ -0,0 +1,13 @@
+import { EitherTag } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.Either match
+ */
+export function match_<E, A, B, C>(self: Either<E, A>, left: (e: E) => B, right: (a: A) => C): B | C {
+  switch (self._tag) {
+    case EitherTag.Left:
+      return left(self.left);
+    case EitherTag.Right:
+      return right(self.right);
+  }
+}

package/_src/data/Either/instances.ts

@@ -0,0 +1,80 @@
+import * as P from "../../typeclass.js";
+import { map_ } from "./api.js";
+import { EitherTag, Left, Right } from "./definition.js";
+
+export interface EitherF extends HKT {
+  readonly type: Either<this["E"], this["A"]>;
+  readonly variance: {
+    E: "+";
+    A: "+";
+  };
+}
+
+/**
+ * @tsplus static fncts.EitherOps getEq
+ */
+export function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>> {
+  return P.Eq({
+    equals_: (x, y) =>
+      x === y ||
+      x.match(
+        (e1) =>
+          y.match(
+            (e2) => EE.equals_(e1, e2),
+            () => false,
+          ),
+        (a1) =>
+          y.match(
+            () => false,
+            (a2) => EA.equals_(a1, a2),
+          ),
+      ),
+  });
+}
+
+/**
+ * @tsplus static fncts.EitherOps getEq
+ */
+export function getFilerable<E>(ME: P.Monoid<E>) {
+  type FixE = HKT.Fix<"E", E>;
+
+  const empty = Left(ME.nat);
+
+  const partitionMap_: P.partitionMap_<EitherF, FixE> = (fa, f) => {
+    if (fa._tag === EitherTag.Left) {
+      return [fa, fa];
+    }
+    const fb = f(fa.right);
+    switch (fb._tag) {
+      case EitherTag.Left:
+        return [Right(fb.left), empty];
+      case EitherTag.Right:
+        return [empty, fb];
+    }
+  };
+
+  const partition_: P.partition_<EitherF, FixE> = <A>(
+    fa: Either<E, A>,
+    p: Predicate<A>,
+  ): readonly [Either<E, A>, Either<E, A>] =>
+    fa._tag === EitherTag.Left ? [fa, fa] : p(fa.right) ? [empty, fa] : [fa, empty];
+
+  const filterMap_: P.filterMap_<EitherF, FixE> = (fa, f) =>
+    fa._tag === EitherTag.Left
+      ? fa
+      : f(fa.right).match(
+          () => empty,
+          (b) => Right(b),
+        );
+
+  const filter_: P.filter_<EitherF, FixE> = <A>(fa: Either<E, A>, p: Predicate<A>): Either<E, A> =>
+    fa._tag === EitherTag.Left ? fa : p(fa.right) ? fa : empty;
+
+  return P.Filterable<EitherF, FixE>({
+    map_,
+    filter_,
+    filterMap_,
+    partition_,
+    partitionMap_,
+  });
+}

package/_src/data/Either.ts

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

package/_src/data/Environment/api.ts

@@ -0,0 +1,78 @@
+/**
+ * @tsplus fluent fncts.Environment add
+ */
+export function add<R, S, H extends S = S>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R & Has<S>> {
+  return new Environment(self.map.set(tag, [service, self.index]), self.index + 1);
+}
+
+/**
+ * @tsplus static fncts.EnvironmentOps empty
+ */
+export const empty = Environment();
+
+/**
+ * @tsplus fluent fncts.Environment get
+ */
+export function get<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>): S {
+  return self.unsafeGet(tag);
+}
+
+/**
+ * @tsplus fluent fncts.Environment getMaybe
+ */
+export function getMaybe<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>): Maybe<S> {
+  return self.cache.get(tag) as Maybe<S>;
+}
+
+/**
+ * @tsplus static fncts.EnvironmentOps __call
+ */
+export function make(): Environment<unknown> {
+  return new Environment(HashMap.makeDefault(), 0, HashMap.makeDefault());
+}
+
+/**
+ * @tsplus operator fncts.Environment +
+ * @tsplus fluent fncts.Environment union
+ */
+export function union<R, R1>(self: Environment<R>, that: Environment<R1>): Environment<R & R1> {
+  return new Environment(
+    self.map.union(that.map.map(([service, index]) => [service, self.index + index] as const)),
+    self.index + that.index,
+  );
+}
+
+/**
+ * @tsplus fluent fncts.Environment unsafeGet
+ */
+export function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S {
+  return self.cache.get(tag).match(
+    () => {
+      let index      = -1;
+      const iterator = self.map[Symbol.iterator]();
+      let service: S = null!;
+      let r: IteratorResult<readonly [Tag<unknown>, readonly [unknown, number]]>;
+      while (!(r = iterator.next()).done) {
+        const [curTag, [curService, curIndex]] = r.value;
+        if (curTag == tag && curIndex > index) {
+          index   = curIndex;
+          service = curService as S;
+        }
+      }
+      if (service === null) throw new Error("Defect in Environment: Could not find tag in map");
+      else {
+        self.cache = self.cache.set(tag, service);
+        return service;
+      }
+    },
+    (a) => a as S,
+  );
+  // return self.cache.unsafeGet(tag) as S;
+}
+
+/**
+ * @tsplus fluent fncts.Environment update
+ */
+export function update<R extends Has<S>, S>(self: Environment<R>, f: (s: S) => S, tag: Tag<S>): Environment<R> {
+  return self.add(f(self.get(tag)), tag);
+}

package/_src/data/Environment/definition.ts

@@ -0,0 +1,32 @@
+/**
+ * @tsplus static fncts.prelude.builtin.SymbolOps env
+ */
+export const EnvSymbol = Symbol.for("fncts.Env");
+
+export type EnvSymbol = typeof EnvSymbol;
+
+/**
+ * @tsplus type fncts.Environment
+ * @tsplus companion fncts.EnvironmentOps
+ */
+export class Environment<R> implements Hashable, Equatable {
+  readonly _typeId: EnvSymbol = EnvSymbol;
+  readonly [EnvSymbol]!: (_: never) => R;
+  constructor(
+    readonly map: HashMap<Tag<unknown>, readonly [unknown, number]>,
+    readonly index: number,
+    public cache: HashMap<Tag<unknown>, unknown> = HashMap.makeDefault(),
+  ) {}
+
+  get [Symbol.hash](): number {
+    return Hashable.unknown(this.cache);
+  }
+
+  [Symbol.equals](that: unknown): boolean {
+    return isEnvironment(that) ? this.map == that.map : false;
+  }
+}
+
+export function isEnvironment(u: unknown): u is Environment<unknown> {
+  return hasTypeId(u, EnvSymbol);
+}

package/_src/data/Environment.ts

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

package/_src/data/ExecutionStrategy.ts

@@ -0,0 +1,81 @@
+export interface Sequential {
+  readonly _tag: "Sequential";
+}
+
+export interface Concurrent {
+  readonly _tag: "Concurrent";
+}
+
+export interface ConcurrentBounded {
+  readonly _tag: "ConcurrentBounded";
+  readonly fiberBound: number;
+}
+
+/**
+ * @tsplus static fncts.ExecutionStrategyOps sequential
+ */
+export const sequential: Sequential = {
+  _tag: "Sequential",
+};
+
+/**
+ * @tsplus static fncts.ExecutionStrategyOps concurrent
+ */
+export const concurrent: Concurrent = {
+  _tag: "Concurrent",
+};
+
+/**
+ * @tsplus static fncts.ExecutionStrategyOps concurrentBounded
+ */
+export function concurrentBounded(fiberBound: number): ConcurrentBounded {
+  return {
+    _tag: "ConcurrentBounded",
+    fiberBound,
+  };
+}
+
+/**
+ * @tsplus type fncts.ExecutionStrategy
+ */
+export type ExecutionStrategy = Sequential | Concurrent | ConcurrentBounded;
+
+/**
+ * @tsplus type fncts.ExecutionStrategyOps
+ */
+export interface ExecutionStrategyOps {}
+
+export const ExecutionStrategy: ExecutionStrategyOps = {};
+
+/**
+ * @tsplus fluent fncts.ExecutionStrategy match
+ */
+export function match_<A, B, C>(
+  strategy: ExecutionStrategy,
+  sequential: () => A,
+  concurrent: () => B,
+  concurrentBounded: (fiberBound: number) => C,
+): A | B | C {
+  switch (strategy._tag) {
+    case "Sequential": {
+      return sequential();
+    }
+    case "Concurrent": {
+      return concurrent();
+    }
+    case "ConcurrentBounded": {
+      return concurrentBounded(strategy.fiberBound);
+    }
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.ExecutionStrategy match
+ */
+export function match<A, B, C>(
+  sequential: () => A,
+  concurrent: () => B,
+  concurrentBounded: (fiberBound: number) => C,
+): (strategy: ExecutionStrategy) => A | B | C {
+  return (strategy) => match_(strategy, sequential, concurrent, concurrentBounded);
+}