@fncts/base 0.0.3 → 0.0.6

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

package/_src/data/Either/api.ts

@@ -1,14 +1,17 @@
 import type * as P from "../../typeclass.js";
-import type { EitherF } from "./instances.js";
+import type { EitherF } from "./definition.js";
 
 import { hasTypeId } from "../../util/predicates.js";
 import { identity } from "../function.js";
+import { concrete } from "./definition.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> {
+  self.concrete();
+  fa.concrete();
   return self._tag === EitherTag.Left ? self : fa._tag === EitherTag.Left ? fa : Right(self.right(fa.right));
 }
 
@@ -16,6 +19,7 @@ export function ap_<E1, A, E2, B>(self: Either<E1, (a: A) => B>, fa: Either<E2,
  * @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> {
+  self.concrete();
   return self._tag === EitherTag.Left ? Left(f(self.left)) : Right(g(self.right));
 }
 
@@ -23,6 +27,7 @@ export function bimap_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => E2, g: (
  * @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> {
+  self.concrete();
   return self._tag === EitherTag.Left ? f(self.left) : self;
 }
 
@@ -47,6 +52,7 @@ export function catchMap_<E, A, B>(self: Either<E, A>, f: (e: E) => B): Either<n
  * @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> {
+  self.concrete();
   return self._tag === EitherTag.Left ? self : f(self.right);
 }
 
@@ -54,6 +60,7 @@ export function flatMap_<E1, A, E2, B>(self: Either<E1, A>, f: (a: A) => Either<
  * @tsplus fluent fncts.Either foldLeft
  */
 export function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a: A) => B): B {
+  self.concrete();
   return self._tag === EitherTag.Left ? b : f(b, self.right);
 }
 
@@ -61,23 +68,16 @@ export function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a: A) =>
  * @tsplus fluent fncts.Either foldRight
  */
 export function foldRight_<E, A, B>(self: Either<E, A>, b: B, f: (a: A, b: B) => B): B {
+  self.concrete();
   return self._tag === EitherTag.Left ? b : f(self.right, b);
 }
 
 /**
- * @constrained
+ * @tsplus fluent fncts.Either foldMap
  */
-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);
+export function foldMap_<E, A, M>(self: Either<E, A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
+  self.concrete();
+  return self._tag === EitherTag.Left ? M.nat : f(self.right);
 }
 
 /**
@@ -119,6 +119,7 @@ export function isEither(u: unknown): u is Either<unknown, unknown> {
  * @tsplus static fncts.EitherOps isLeft
  */
 export function isLeft<E, A>(self: Either<E, A>): self is Left<E> {
+  self.concrete();
   return self._tag === EitherTag.Left;
 }
 
@@ -127,6 +128,7 @@ export function isLeft<E, A>(self: Either<E, A>): self is Left<E> {
  * @tsplus static fncts.EitherOps isRight
  */
 export function isRight<E, A>(self: Either<E, A>): self is Right<A> {
+  self.concrete();
   return self._tag === EitherTag.Right;
 }
 
@@ -134,6 +136,7 @@ export function isRight<E, A>(self: Either<E, A>): self is Right<A> {
  * @tsplus fluent fncts.Either map
  */
 export function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B> {
+  self.concrete();
   return self._tag === EitherTag.Left ? self : Right(f(self.right));
 }
 
@@ -141,6 +144,7 @@ export function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B>
  * @tsplus fluent fncts.Either mapLeft
  */
 export function mapLeft_<E1, A, E2>(self: Either<E1, A>, f: (e: E1) => E2): Either<E2, A> {
+  self.concrete();
   return self._tag === EitherTag.Left ? Left(f(self.left)) : self;
 }
 
@@ -155,45 +159,96 @@ export function merge<E, A>(self: Either<E, A>): E | A {
  * @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> {
+  self.concrete();
   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> {
+  self.concrete();
   return self._tag === EitherTag.Left ? Right(self.left) : Left(self.right);
 }
 
-export const traverse_: P.traverse_<EitherF> = (A) => (self, f) =>
+/**
+ * @tsplus fluent fncts.Either traverse
+ */
+export const traverse_: P.Traversable<EitherF>["traverse"] = (self, f, A) =>
   self.match(
     (e) => A.pure(Left(e)),
-    (a) => f(a).via(A.map((b) => Right(b))),
+    (a) => f(a).map((b) => Right(b), A),
   );
 
-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> {
+  self.concrete();
+  fb.concrete();
   return self._tag === EitherTag.Left ? self : fb._tag === EitherTag.Left ? fb : Right(f(self.right, fb.right));
 }
 
+/**
+ * @tsplus fluent fncts.Either filterMap
+ */
+export function filterMap<E, A, B>(
+  self: Either<E, A>,
+  f: (a: A) => Maybe<B>,
+  /** @tsplus auto */ M: P.Monoid<E>,
+): Either<E, B> {
+  self.concrete();
+  return self._tag === EitherTag.Left
+    ? self
+    : f(self.right).match(
+        () => Left(M.nat),
+        (b) => Right(b),
+      );
+}
+
+/**
+ * @tsplus fluent fncts.Either filter
+ */
+export function filter<E, A>(self: Either<E, A>, f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): Either<E, A> {
+  self.concrete();
+  return self._tag === EitherTag.Left ? self : f(self.right) ? self : Left(M.nat);
+}
+
+/**
+ * @tsplus fluent fncts.Either partitionMap
+ */
+export function partitionMap<E, A, B, C>(
+  self: Either<E, A>,
+  f: (a: A) => Either<B, C>,
+  /** @tsplus auto */ M: P.Monoid<E>,
+): readonly [Either<E, B>, Either<E, C>] {
+  self.concrete();
+  if (self._tag === EitherTag.Left) {
+    return [self, self];
+  }
+  const fb: Either<B, C> = f(self.right);
+  fb.concrete();
+  switch (fb._tag) {
+    case EitherTag.Left:
+      return [Right(fb.left), Left(M.nat)];
+    case EitherTag.Right:
+      return [Left(M.nat), fb];
+  }
+}
+
+/**
+ * @tsplus fluent fncts.Either partition
+ */
+export function partition<E, A>(
+  self: Either<E, A>,
+  p: Predicate<A>,
+  /** @tsplus auto */ M: P.Monoid<E>,
+): readonly [Either<E, A>, Either<E, A>] {
+  self.concrete();
+  return self._tag === EitherTag.Left ? [self, self] : p(self.right) ? [Left(M.nat), self] : [self, Left(M.nat)];
+}
+
 // codegen:start { preset: barrel, include: api/*.ts }
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/_src/data/Either/definition.ts

@@ -6,37 +6,50 @@ export const enum EitherTag {
 export const EitherTypeId = Symbol.for("fncts.base.data.Either");
 export type EitherTypeId = typeof EitherTypeId;
 
+export interface EitherF extends Either<any, any> {}
+export interface Either1F<E> extends Either1<E, any> {}
+
 /**
- * @tsplus type fncts.Either.Left
- * @tsplus companion fncts.Either.LeftOps
+ * @tsplus type fncts.Either
+ * @tsplus companion fncts.EitherOps
  */
-export class Left<E> {
+export class Either<E, A> {
   readonly _typeId: EitherTypeId = EitherTypeId;
-  readonly _tag                  = EitherTag.Left;
-  constructor(readonly left: E) {}
+  readonly [HKT.F]!: EitherF;
+  readonly [HKT.E]!: () => E;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Either<HKT._E<this>, HKT._A<this>>;
 }
 
-/**
- * @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) {}
+export interface Either1<E, A> {
+  readonly _typeId: EitherTypeId;
+  readonly [HKT.F]: EitherF;
+  readonly [HKT.E]: () => E;
+  readonly [HKT.A]: () => A;
+  readonly [HKT.T]: Either<E, HKT._A<this>>;
 }
 
 /**
- * @tsplus type fncts.Either
+ * @tsplus type fncts.Either.Left
+ * @tsplus companion fncts.Either.LeftOps
  */
-export type Either<E, A> = Left<E> | Right<A>;
+export class Left<E> extends Either<E, never> {
+  readonly _tag = EitherTag.Left;
+  constructor(readonly left: E) {
+    super();
+  }
+}
 
 /**
- * @tsplus type fncts.EitherOps
+ * @tsplus type fncts.Either.Right
+ * @tsplus companion fncts.Either.RightOps
  */
-export interface EitherOps {}
-
-export const Either: EitherOps = {};
+export class Right<A> extends Either<never, A> {
+  readonly _tag = EitherTag.Right;
+  constructor(readonly right: A) {
+    super();
+  }
+}
 
 /**
  * @tsplus unify fncts.Either
@@ -46,3 +59,12 @@ export function unifyEither<X extends Either<any, any>>(
 ): Either<[X] extends [Either<infer E, any>] ? E : never, [X] extends [Either<any, infer A>] ? A : never> {
   return self;
 }
+
+/**
+ * @tsplus fluent fncts.Either concrete
+ * @tsplus static fncts.EitherOps concrete
+ * @tsplus macro remove
+ */
+export function concrete<E, A>(self: Either<E, A>): asserts self is Left<E> | Right<A> {
+  //
+}

package/_src/data/Either/destructors.ts

@@ -4,6 +4,7 @@ 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 {
+  self.concrete();
   switch (self._tag) {
     case EitherTag.Left:
       return left(self.left);