@fncts/base 0.0.1 → 0.0.4

package/_src/data/Const/definition.ts

@@ -1,11 +1,28 @@
 /**
- * @tsplus type fncts.Const
+ * @tsplus type fncts.ConstF
  */
-export type Const<E, A> = E & { readonly _A: A };
+export interface ConstF extends Const<any, any> {}
 
 /**
- * @tsplus type fncts.ConstOps
+ * @tsplus type fncts.ConstF
+ */
+export interface Const1F<E> extends Const1<E, any> {}
+
+/**
+ * @tsplus type fncts.Const
+ * @tsplus companion fncts.ConstOps
  */
-export interface ConstOps {}
+export class Const<E, A> {
+  readonly [HKT.F]!: ConstF;
+  readonly [HKT.E]!: () => E;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Const<HKT._E<this>, HKT._A<this>>;
+  constructor(readonly getConst: E) {}
+}
 
-export const Const: ConstOps = {};
+export interface Const1<E, A> {
+  readonly [HKT.F]: ConstF;
+  readonly [HKT.E]: () => E;
+  readonly [HKT.A]: () => A;
+  readonly [HKT.T]: Const<E, HKT._A<this>>;
+}

package/_src/data/Const/instances.ts

@@ -1,34 +1,25 @@
-import * as P from "../../typeclass.js";
-import { map_ } from "./api.js";
+import type * as P from "../../typeclass.js";
+import type { Const1F,ConstF } from "@fncts/base/data/Const/definition";
 
-export interface ConstF extends HKT {
-  readonly type: Const<this["E"], this["A"]>;
-  readonly variance: {
-    E: "_";
-    A: "_";
-  };
-}
+import { Const } from "@fncts/base/data/Const/definition";
 
 /**
  * @tsplus static fncts.ConstOps getApply
  */
-export function getApply<E>(S: P.Semigroup<E>): P.Apply<ConstF, HKT.Fix<"E", E>> {
-  type CE = HKT.Fix<"E", E>;
-  const ap_: P.ap_<ConstF, CE>           = (fab, fa) => Const(S.combine_(fab, fa));
-  const zipWith_: P.zipWith_<ConstF, CE> = (fa, fb, _f) => Const(S.combine_(fa, fb));
-  return P.Apply({
-    map_,
-    ap_,
-    zipWith_,
-  });
+export function getApply<E>(S: P.Semigroup<E>): P.Apply<Const1F<E>> {
+  return {
+    map: (fa, f) => fa.map(f),
+    zip: (self, that) => Const(S.combine(self.getConst, that.getConst)),
+    zipWith: (self, that, _f) => Const(S.combine(self.getConst, that.getConst)),
+  };
 }
 
 /**
  * @tsplus static fncts.ConstOps getApplicative
  */
-export function getApplicative<E>(M: P.Monoid<E>): P.Applicative<ConstF, HKT.Fix<"E", E>> {
-  return P.Applicative({
+export function getApplicative<E>(M: P.Monoid<E>): P.Applicative<Const1F<E>> {
+  return {
     ...getApply(M),
     pure: <A>() => Const<E, A>(M.nat),
-  });
+  };
 }

package/_src/data/DecodeError/definition.ts

@@ -0,0 +1,227 @@
+import { show } from "@fncts/base/typeclass/Showable";
+
+export const DecodeErrorTypeId = Symbol.for("fncts.DecodeError");
+export type DecodeErrorTypeId = typeof DecodeErrorTypeId;
+
+export abstract class DecodeError {
+  readonly _typeId: DecodeErrorTypeId = DecodeErrorTypeId;
+  abstract render: Eval<RoseTree<string>>;
+}
+
+export class RequiredKeyError extends DecodeError {
+  readonly _tag = "RequiredKey";
+  constructor(readonly key: string, readonly error: DecodeError) {
+    super();
+  }
+  render = Eval.defer(this.error.render.map((error) => RoseTree(`on required key ${this.key}`, Vector(error))));
+}
+
+export class OptionalKeyError extends DecodeError {
+  readonly _tag = "OptionalKey";
+  constructor(readonly key: PropertyKey, readonly error: DecodeError) {
+    super();
+  }
+  render = Eval.defer(this.error.render.map((error) => RoseTree(`on optional key ${show(this.key)}`, Vector(error))));
+}
+
+export class RequiredIndexError<I, E extends DecodeError> extends DecodeError {
+  readonly _tag = "RequiredIndex";
+  constructor(readonly index: I, readonly error: E) {
+    super();
+  }
+  render = Eval.defer(this.error.render.map((error) => RoseTree(`on required index ${this.index}`, Vector(error))));
+}
+
+export class OptionalIndexError<I, E extends DecodeError> extends DecodeError {
+  readonly _tag = "RequiredIndex";
+  constructor(readonly index: I, readonly error: E) {
+    super();
+  }
+  render = Eval.defer(this.error.render.map((error) => RoseTree(`on optional index ${this.index}`, Vector(error))));
+}
+
+export class LazyError<E extends DecodeError> extends DecodeError {
+  readonly _tag = "Lazy";
+  constructor(readonly error: E) {
+    super();
+  }
+  render = Eval.defer(this.error.render.map((error) => RoseTree("while decoding a lazy decoder", Vector(error))));
+}
+
+export class MemberError extends DecodeError {
+  readonly _tag = "Member";
+  constructor(readonly label: string, readonly error: DecodeError) {
+    super();
+  }
+  render = Eval.defer(this.error.render.map((error) => RoseTree(`on member ${this.label}`, Vector(error))));
+}
+
+const vowels = ["a", "e", "i", "o", "u", "y"];
+
+function startsWithVowel(s: string): boolean {
+  for (let i = 0; i < vowels.length; i++) {
+    if (s.startsWith(vowels[i]!)) return true;
+  }
+  return false;
+}
+
+export class CompoundError<E extends DecodeError> extends DecodeError {
+  readonly _tag = "Compound";
+  constructor(readonly name: string, readonly errors: Vector<E>) {
+    super();
+  }
+  render = Eval.defer(
+    this.errors
+      .traverse((error) => error.render)
+      .map((errors) =>
+        RoseTree(
+          `${this.errors.length} error(s) found while decoding ${startsWithVowel(this.name) ? "an" : "a"} ${this.name}`,
+          errors,
+        ),
+      ),
+  );
+}
+
+export class CompositionError<E extends DecodeError> extends DecodeError {
+  readonly _tag = "Composition";
+  constructor(readonly errors: Vector<E>) {
+    super();
+  }
+  render = Eval.defer(
+    this.errors
+      .traverse((error) => error.render)
+      .map((errors) =>
+        errors.length === 1
+          ? errors.unsafeGet(1)!
+          : RoseTree(`${errors.length} errors found while decoding a composition`, errors),
+      ),
+  );
+}
+
+export class StringError extends DecodeError {
+  readonly _tag = "String";
+  constructor(readonly actual: unknown) {
+    super();
+  }
+  render = Eval(RoseTree(cannotDecode(this.actual, "a string")));
+}
+
+export class NumberError extends DecodeError {
+  readonly _tag = "Number";
+  constructor(readonly actual: unknown) {
+    super();
+  }
+  render = Eval(RoseTree(cannotDecode(this.actual, "a number")));
+}
+
+export class NaNError extends DecodeError {
+  readonly _tag = "NaN";
+  render        = Eval.now(RoseTree("value is NaN"));
+}
+
+export class InfinityError extends DecodeError {
+  readonly _tag = "Infinity";
+  render        = Eval(RoseTree("value is Infinity"));
+}
+
+export class BooleanError extends DecodeError {
+  readonly _tag = "Boolean";
+  constructor(readonly actual: unknown) {
+    super();
+  }
+  render = Eval(RoseTree(cannotDecode(this.actual, "a boolean")));
+}
+
+export class PrimitiveError extends DecodeError {
+  readonly _tag = "Primitive";
+  constructor(readonly actual: unknown, readonly name: string) {
+    super();
+  }
+  render = Eval(RoseTree(cannotDecode(this.actual, this.name)));
+}
+
+export class LiteralError<A extends string | number | boolean> extends DecodeError {
+  readonly _tag = "Literal";
+  constructor(readonly actual: unknown, readonly literals: Vector<A>) {
+    super();
+  }
+  render = Eval(
+    RoseTree(cannotDecode(this.actual, `one of ${this.literals.map((literal) => show(literal)).join(", ")}`)),
+  );
+}
+
+export class UnexpectedKeysError extends DecodeError {
+  readonly _tag = "UnexpectedKeys";
+  constructor(readonly keys: Vector<string>) {
+    super();
+  }
+  render = Eval(
+    RoseTree(
+      `${this.keys.length} error(s) found while checking keys`,
+      this.keys.map((key) => RoseTree(`unexpected key ${show(key)}`)),
+    ),
+  );
+}
+
+export class UnexpectedIndicesError extends DecodeError {
+  readonly _tag = "UnexpectedIndices";
+  constructor(readonly indices: Vector<number>) {
+    super();
+  }
+  render = Eval(
+    RoseTree(
+      `${this.indices.length} error(s) found while checking indices`,
+      this.indices.map((index) => RoseTree(`unexpected index ${show(index)}`)),
+    ),
+  );
+}
+
+export class MissingKeyError extends DecodeError {
+  readonly _tag = "MissingKeys";
+  constructor(readonly key: PropertyKey) {
+    super();
+  }
+  render = Eval(RoseTree(`missing required key ${show(this.key)}`));
+}
+
+export class MissingIndicesError extends DecodeError {
+  readonly _tag = "MissingIndices";
+  constructor(readonly keys: Vector<PropertyKey>) {
+    super();
+  }
+  render = Eval(
+    RoseTree(
+      `${this.keys.length} error(s) found while checking indices`,
+      this.keys.map((key) => RoseTree(`missing required index ${show(key)}`)),
+    ),
+  );
+}
+
+function cannotDecode(u: unknown, expected: string): string {
+  return `cannot decode ${show(u)}, expected ${expected}`;
+}
+
+export class BrandedError extends DecodeError {
+  readonly _tag = "BrandedError";
+  constructor(readonly name: string, readonly brands: Vector<string>) {
+    super();
+  }
+  render = Eval(
+    RoseTree(
+      `${this.brands.length} brand(s) failed to be validated while decoding ${this.name}`,
+      this.brands.map((brand) => RoseTree(brand)),
+    ),
+  );
+}
+
+export class UnionError extends DecodeError {
+  readonly _tag = "UnionError";
+  constructor(readonly label: string, readonly errors: Vector<DecodeError>) {
+    super();
+  }
+  render = Eval.defer(
+    this.errors
+      .traverse((error) => error.render)
+      .map((errors) => RoseTree(`${this.errors.length} error(s) found while decoding ${this.label}`, errors)),
+  );
+}

package/_src/data/DecodeError.ts

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

package/_src/data/Decoder/api.ts

@@ -0,0 +1,198 @@
+import type { DecodeError } from "@fncts/base/data/DecodeError";
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+
+import {
+  CompoundError,
+  LiteralError,
+  MemberError,
+  MissingKeyError,
+  OptionalKeyError,
+  PrimitiveError,
+  RequiredKeyError,
+  UnionError,
+} from "@fncts/base/data/DecodeError";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
+
+/**
+ * @tsplus fluent fncts.Decoder __call
+ */
+export function decode<I, E, A>(self: Decoder<A>, input: unknown): These<DecodeError, A> {
+  return self.decode(input);
+}
+
+export function fromGuard<A>(guard: Guard<A>, onFalse: (i: unknown) => DecodeError, label: string): Decoder<A> {
+  return Decoder((a) => (guard.is(a) ? These.right(a) : These.left(onFalse(a))), label);
+}
+
+/**
+ * @tsplus implicit
+ */
+export const string: Decoder<string> = fromGuard(String.Guard, (u) => new PrimitiveError(u, "string"), "string");
+
+/**
+ * @tsplus implicit
+ */
+export const number: Decoder<number> = fromGuard(Number.Guard, (u) => new PrimitiveError(u, "number"), "number");
+
+/**
+ * @tsplus implicit
+ */
+export const boolean: Decoder<boolean> = fromGuard(Boolean.Guard, (u) => new PrimitiveError(u, "boolean"), "boolean");
+
+/**
+ * @tsplus implicit
+ */
+export const record: Decoder<{}> = fromGuard(Object.Guard, (u) => new PrimitiveError(u, "{}"), "{}");
+
+/**
+ * @tsplus derive fncts.Decoder lazy
+ */
+export function deriveLazy<A>(f: (_: Decoder<A>) => Decoder<A>): Decoder<A> {
+  let cached: Decoder<A> | undefined;
+  const decoder: Decoder<A> = Decoder((u) => {
+    if (!cached) {
+      cached = f(decoder);
+    }
+    return cached.decode(u);
+  }, "[Recursive]");
+  return decoder;
+}
+
+/**
+ * @tsplus derive fncts.Decoder<_> 20
+ */
+export function deriveLiteral<A extends string | number | boolean>(
+  ...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never
+): Decoder<A> {
+  return Decoder(
+    (u) => (u === value ? These.right(u as A) : These.left(new LiteralError(u, Vector(value)))),
+    value.toString(),
+  );
+}
+
+/**
+ * @tsplus derive fncts.Decoder<|> 30
+ */
+export function deriveUnion<A extends ReadonlyArray<unknown>>(
+  ...elements: {
+    [K in keyof A]: Decoder<A[K]>;
+  }
+): Decoder<A[number]> {
+  const label = elements.map((decoder) => decoder.label).join(" | ");
+  return Decoder((u) => {
+    const errors: Array<MemberError> = [];
+    for (const decoder of elements) {
+      const result = decoder.decode(u);
+      if (result.isLeft()) {
+        errors.push(new MemberError(decoder.label, result.left));
+      } else {
+        return These.rightOrBoth(result.leftMaybe, result.right);
+      }
+    }
+    return These.left(new UnionError(label, Vector.from(errors)));
+  }, label);
+}
+
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ */
+export function deriveStruct<A extends Record<string, any>>(
+  ...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True
+    ? [
+        ...[
+          requiredFields: {
+            [k in RequiredKeys<A>]: Decoder<A[k]>;
+          },
+        ],
+        ...([OptionalKeys<A>] extends [never]
+          ? []
+          : [
+              optionalFields: {
+                [k in OptionalKeys<A>]: Decoder<NonNullable<A[k]>>;
+              },
+            ]),
+      ]
+    : never
+): Decoder<A> {
+  let label = "{";
+  let first = true;
+  for (const k in requiredFields) {
+    if (first) {
+      label += ` ${k}: ${(requiredFields[k] as Decoder<any>).label}`;
+    } else {
+      label += `, ${k}: ${(requiredFields[k] as Decoder<any>).label}`;
+    }
+    first = false;
+  }
+  if (optionalFields) {
+    for (const k in optionalFields) {
+      if (first) {
+        label += ` ${k}?: ${(optionalFields[k] as Decoder<any>).label}`;
+      } else {
+        label += `, ${k}?: ${(optionalFields[k] as Decoder<any>).label}`;
+      }
+    }
+  }
+  if (label.length > 1) {
+    label += " ";
+  }
+  label += "}";
+
+  return Decoder((u) => {
+    const recordResult = record.decode(u);
+    if (recordResult.isLeft()) {
+      return recordResult;
+    }
+    const input = recordResult.right;
+    let errored = false;
+    const errors: Array<RequiredKeyError | OptionalKeyError> = [];
+    const decoded = {} as A;
+    for (const key in requiredFields) {
+      if (!(key in input)) {
+        errors.push(new RequiredKeyError(key, new MissingKeyError(key)));
+        errored = true;
+      } else {
+        const res = (requiredFields[key] as Decoder<any>).decode(input[key]);
+        res.match2(
+          (e) => {
+            errored = true;
+            errors.push(new RequiredKeyError(key, e));
+          },
+          (warning, a) => {
+            decoded[key as keyof A] = a;
+            if (warning.isJust()) {
+              errors.push(new RequiredKeyError(key, warning.value));
+            }
+          },
+        );
+      }
+    }
+    if (optionalFields) {
+      for (const key in optionalFields) {
+        if (key in input && typeof input[key as string] !== "undefined") {
+          const res = (optionalFields[key] as Decoder<any>).decode(input[key as string]);
+          res.match2(
+            (e) => {
+              errored = true;
+              errors.push(new OptionalKeyError(key, e));
+            },
+            (warning, a) => {
+              decoded[key as keyof A] = a;
+              if (warning.isJust()) {
+                errors.push(new RequiredKeyError(key, warning.value));
+              }
+            },
+          );
+        }
+      }
+    }
+    if (errored) {
+      return These.left(new CompoundError("struct", Vector.from(errors)));
+    }
+    if (errors.length !== 0) {
+      return These.both(new CompoundError("struct", Vector.from(errors)), decoded);
+    }
+    return These.right(decoded);
+  }, label);
+}

package/_src/data/Decoder/definition.ts

@@ -0,0 +1,25 @@
+import type { DecodeError } from "@fncts/base/data/DecodeError";
+
+export const DecoderTypeId = Symbol.for("fncts.Decoder");
+export type DecoderTypeId = typeof DecoderTypeId;
+
+export interface DecoderF extends Decoder<any> {}
+
+/**
+ * @tsplus type fncts.Decoder
+ * @tsplus companion fncts.DecoderOps
+ */
+export class Decoder<A> {
+  readonly _typeId: DecoderTypeId = DecoderTypeId;
+  readonly [HKT.F]!: DecoderF;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Decoder<HKT._A<this>>;
+  constructor(readonly decode: (input: unknown) => These<DecodeError, A>, readonly label: string) {}
+}
+
+/**
+ * @tsplus static fncts.DecoderOps __call
+ */
+export function makeDecoder<A>(decode: (input: unknown) => These<DecodeError, A>, label: string): Decoder<A> {
+  return new Decoder(decode, label);
+}

package/_src/data/Decoder.ts

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

package/_src/data/Duration/api.ts

@@ -4,54 +4,54 @@ import type { IsInt } from "@fncts/base/types";
  * @tsplus getter fncts.Number milliseconds
  * @tsplus static fncts.DurationOps milliseconds
  */
-export function milliseconds<N extends number>(self: IsInt<N>): Duration {
-  return new Duration(self);
+export function milliseconds(self: number): Duration {
+  return new Duration(Math.round(self));
 }
 
 /**
  * @tsplus getter fncts.Number seconds
  * @tsplus static fncts.DurationOps seconds
  */
-export function seconds<N extends number>(self: IsInt<N>): Duration {
-  return new Duration(self * 1000);
+export function seconds(self: number): Duration {
+  return new Duration(Math.round(self * 1000));
 }
 
 /**
  * @tsplus getter fncts.Number minutes
  * @tsplus static fncts.DurationOps minutes
  */
-export function minutes<N extends number>(self: IsInt<N>): Duration {
-  return new Duration(self * 60_000);
+export function minutes(self: number): Duration {
+  return new Duration(Math.round(self * 60_000));
 }
 
 /**
  * @tsplus getter fncts.Number hours
  * @tsplus static fncts.DurationOps hours
  */
-export function hours<N extends number>(self: IsInt<N>): Duration {
-  return new Duration(self * 3_600_000);
+export function hours(self: number): Duration {
+  return new Duration(Math.round(self * 3_600_000));
 }
 
 /**
  * @tsplus getter fncts.Number days
  * @tsplus static fncts.DurationOps days
  */
-export function days<N extends number>(self: IsInt<N>): Duration {
-  return new Duration(self * 86_400_000);
+export function days(self: number): Duration {
+  return new Duration(Math.round(self * 86_400_000));
 }
 
 /**
  * @tsplus operator fncts.Duration *
  */
-export function mult<N extends number>(self: Duration, multiplicand: IsInt<N>) {
-  return new Duration(self.milliseconds * multiplicand);
+export function mult(self: Duration, multiplicand: number) {
+  return new Duration(self.milliseconds * Math.round(multiplicand));
 }
 
 /**
  * @tsplus operator fncts.Duration *
  */
-export function multInverted<N extends number>(multiplicand: IsInt<N>, self: Duration) {
-  return new Duration(self.milliseconds * multiplicand);
+export function multInverted(multiplicand: number, self: Duration) {
+  return new Duration(Math.round(self.milliseconds) * multiplicand);
 }
 
 /**
@@ -67,3 +67,10 @@ export function sum(self: Duration, that: Duration): Duration {
 export function difference(self: Duration, that: Duration): Duration {
   return new Duration(self.milliseconds - that.milliseconds);
 }
+
+/**
+ * @tsplus static fncts.DurationOps fromInterval
+ */
+export function fromInterval(start: number, end: number): Duration {
+  return Duration.milliseconds(Math.round(end) - Math.round(start));
+}

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

@@ -11,6 +11,8 @@ export function alignWith_<E1, A, E2, B, C>(
   fb: Either<E2, B>,
   f: (_: These<A, B>) => C,
 ): Either<E1 | E2, C> {
+  self.concrete();
+  fb.concrete();
   return self._tag === EitherTag.Left
     ? fb._tag === EitherTag.Left
       ? self