@fncts/base 0.0.3 → 0.0.6

package/_src/data/Branded/definition.ts

@@ -0,0 +1,47 @@
+import type { Union } from "@fncts/typelevel";
+
+type Brand_<A, K extends string> = Brand<A, K>;
+
+export declare namespace Branded {
+  const Symbol: unique symbol;
+  export type Symbol = typeof Symbol;
+
+  export interface Brand<A, K extends string> {
+    readonly [Branded.Symbol]: {
+      [_ in K]: A;
+    };
+  }
+
+  export type Type<A extends Brand_<any, any>> = [A] extends [Brand_<infer A, infer K>] ? Validated<A, K> : never;
+
+  export type Validated<A, K extends string> = A & Brand<A, K>;
+
+  export type IsValidated<P extends Brand<any, any>> = {
+    [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? 0 : 1
+  }[keyof P[Branded.Symbol]] extends 0 ? unknown : never;
+
+  export type Unbrand<P extends Brand<any, any>> = P extends infer Q & Brands<P> ? Q : P;
+
+  export type Brands<P extends Brand<any, any>> = Union.IntersectionOf<{
+    [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K]
+      ? K extends string
+        ? Brand<P[Branded.Symbol][K], K>
+        : never
+      : never;
+  }[keyof P[Branded.Symbol]]>;
+}
+
+/**
+ * @tsplus type fncts.Brand
+ * @tsplus companion fncts.BrandOps
+ */
+export class Brand<A, K extends string> {
+  constructor(readonly validate: Refinement<A, A & Branded.Brand<A, K>>) {}
+}
+
+/**
+ * @tsplus static fncts.BrandOps __call
+ */
+export function makeBrand<A, K extends string>(p: Predicate<A>): Brand<A, K> {
+  return new Brand(p as Refinement<A, A & Branded.Brand<A, K>>);
+}

package/_src/data/Branded/derivations.ts

@@ -0,0 +1,57 @@
+import type { Brand, Branded } from "@fncts/base/data/Branded/definition";
+import type { Check } from "@fncts/typelevel/Check";
+
+import { BrandedError, CompoundError } from "@fncts/base/data/DecodeError";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
+
+/**
+ * @tsplus derive fncts.Guard<_> 10
+ */
+export function deriveGuard<A extends Branded.Brand<any, any>>(
+  ...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True
+    ? [
+      base: Guard<Branded.Unbrand<A>>,
+      brands: {
+        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+      }
+    ]
+    : never
+): Guard<A> {
+  const validations = Object.values(brands) as ReadonlyArray<Brand<A, any>>;
+  return Guard((u): u is A => base.is(u) && validations.every((brand) => brand.validate(u)));
+}
+
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ */
+export function deriveDecoder<A extends Branded.Brand<any, any>>(
+  ...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True
+    ? [
+        base: Decoder<Branded.Unbrand<A>>,
+        brands: {
+          [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+        },
+      ]
+    : never
+): Decoder<A> {
+  const label = "Brand<" + Object.keys(brands).join(" & ") + ">";
+  return Decoder((u) => base.decode(u).match2(
+    These.left,
+    (warning, value) => {
+      const failedBrands: Array<string> = [];
+      for (const brand in brands) {
+        if (!brands[brand]!.validate(value as any)) {
+          failedBrands.push(brand);
+        }
+      }
+      if (failedBrands.length > 0) {
+        const error = new BrandedError(label, Vector.from(failedBrands));
+        return warning.match(
+          () => These.left(error),
+          (warning) => These.left(new CompoundError(label, Vector(warning, error)))
+        );
+      }
+      return These.rightOrBoth(warning, value);
+    }
+  ), label);
+}

package/_src/data/Branded.ts

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

package/_src/data/CaseClass.ts

@@ -45,7 +45,7 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
   get [Symbol.hash](): number {
     let h = hash0;
     for (const k of this[keysSymbol]) {
-      h = Hashable.combine(h, Hashable.unknown((this as T)[k]!));
+      h = Hashable.combine(h, Hashable.unknown(this[k]!));
     }
     return h;
   }
@@ -67,7 +67,7 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
       while (result && i < len) {
         result =
           this[keysSymbol][i] === thatKeys[i] &&
-          ((this as T)[this[keysSymbol]![i]!] as {}) == (that as T)[thatKeys[i]!];
+          (this[this[keysSymbol]![i]!] as {}) == (that as T)[thatKeys[i]!];
         i++;
       }
 

package/_src/data/Cause/api/fold.ts

@@ -56,6 +56,7 @@ function foldLoop<E, Z>(
     }
   } else {
     return out.foldLeft(List.empty(), (acc, v) => {
+      Either.concrete(v);
       if (v.isRight()) {
         return acc.prepend(v.right);
       } else {

package/_src/data/Cause/api.ts

@@ -218,6 +218,7 @@ export function filterDefects_<E>(self: Cause<E>, p: Predicate<unknown>): Maybe<
  */
 function findLoop<A, B>(self: Cause<A>, f: (cause: Cause<A>) => Maybe<B>, stack: List<Cause<A>>): Maybe<B> {
   const r = f(self);
+  Maybe.concrete(r);
   switch (r._tag) {
     case MaybeTag.Nothing: {
       switch (self._tag) {
@@ -630,6 +631,15 @@ export function isThen<E>(self: Cause<E>): self is Then<E> {
   return self._tag === CauseTag.Then;
 }
 
+/**
+ * A type-guard matching `Interrupt`
+ *
+ * @tsplus fluent fncts.Cause isInterrupt
+ */
+export function isInterrupt<E>(self: Cause<E>): self is Interrupt {
+  return self._tag === CauseTag.Interrupt;
+}
+
 /**
  * A type-guard matching `Traced`
  *
@@ -799,6 +809,8 @@ function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<C
       return Eval.defer(() => sequenceCauseEitherEval(self.left)).zipWith(
         Eval.defer(() => sequenceCauseEitherEval(self.right)),
         (lefts, rights) => {
+          Either.concrete(lefts);
+          Either.concrete(rights);
           return lefts._tag === "Left"
             ? rights._tag === "Right"
               ? Either.right(rights.right)
@@ -811,6 +823,8 @@ function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<C
       return Eval.defer(() => sequenceCauseEitherEval(self.left)).zipWith(
         Eval.defer(() => sequenceCauseEitherEval(self.right)),
         (lefts, rights) => {
+          Either.concrete(lefts);
+          Either.concrete(rights);
           return lefts._tag === "Left"
             ? rights._tag === "Right"
               ? Either.right(rights.right)
@@ -854,6 +868,8 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
       return Eval.defer(() => sequenceCauseMaybeEval(self.left)).zipWith(
         Eval.defer(() => sequenceCauseMaybeEval(self.right)),
         (lefts, rights) => {
+          Maybe.concrete(lefts);
+          Maybe.concrete(rights);
           return lefts._tag === "Just"
             ? rights._tag === "Just"
               ? Maybe.just(Cause.then(lefts.value, rights.value))
@@ -868,6 +884,8 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
       return Eval.defer(() => sequenceCauseMaybeEval(self.left)).zipWith(
         Eval.defer(() => sequenceCauseMaybeEval(self.right)),
         (lefts, rights) => {
+          Maybe.concrete(lefts);
+          Maybe.concrete(rights);
           return lefts._tag === "Just"
             ? rights._tag === "Just"
               ? Maybe.just(Cause.both(lefts.value, rights.value))

package/_src/data/Const/api.ts

@@ -1,10 +1,10 @@
-import type { Const } from "./definition.js";
+import { Const } from "./definition.js";
 
 /**
  * @tsplus fluent fncts.Const map
  */
 export function map_<E, A, B>(self: Const<E, A>, _f: (a: A) => B): Const<E, B> {
-  return unsafeCoerce(self);
+  return new Const(self.getConst);
 }
 
 /**
@@ -12,5 +12,5 @@ export function map_<E, A, B>(self: Const<E, A>, _f: (a: A) => B): Const<E, B> {
  * @tsplus static fncts.ConstOps __call
  */
 export function mkConst<E, A = never>(e: E): Const<E, A> {
-  return unsafeCoerce(e);
+  return new Const(e);
 }

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