@fncts/base 0.0.29 → 0.0.31

package/_src/control/Pure/definition.ts

@@ -0,0 +1,222 @@
+export interface PureF extends HKT {
+  type: Pure<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
+  variance: {
+    W: "+";
+    S: "_";
+    R: "-";
+    E: "+";
+    A: "+";
+  };
+}
+
+export const PureVariance = Symbol.for("fncts.Pure.Variance");
+export type PureVariance = typeof PureVariance;
+
+export const PureTypeId = Symbol.for("fncts.Pure");
+export type PureTypeId = typeof PureTypeId;
+
+/**
+ * `Pure<W, S1, S2, R, E, A>` is a purely functional description of a synchronous computation
+ * that requires an environment `R` and an initial state `S1` and may either
+ * fail with an `E` or succeed with an updated state `S2` and an `A`. Because
+ * of its polymorphism `Z` can be used to model a variety of effects
+ * including context, state, failure, and logging.
+ *
+ * @tsplus type fncts.control.Pure
+ * @tsplus companion fncts.control.PureOps
+ */
+export abstract class Pure<W, S1, S2, R, E, A> {
+  readonly [PureTypeId]: PureTypeId = PureTypeId;
+  declare [PureVariance]: {
+    readonly _W: (_: never) => W;
+    readonly _S1: (_: S1) => void;
+    readonly _S2: (_: never) => S2;
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
+}
+
+/**
+ * @tsplus unify fncts.control.Pure
+ */
+export function unifyPure<X extends Pure<any, any, any, any, any, any>>(
+  _: X,
+): Pure<
+  [X] extends [Pure<infer W, any, any, any, any, any>] ? W : never,
+  [X] extends [Pure<any, infer S1, any, any, any, any>] ? S1 : never,
+  [X] extends [Pure<any, any, infer S2, any, any, any>] ? S2 : never,
+  [X] extends [Pure<any, any, any, infer R, any, any>] ? R : never,
+  [X] extends [Pure<any, any, any, any, infer E, any>] ? E : never,
+  [X] extends [Pure<any, any, any, any, any, infer A>] ? A : never
+> {
+  return _;
+}
+
+export class PurePrimitive {
+  readonly [PureTypeId]: PureTypeId = PureTypeId;
+  declare [PureVariance]: {
+    readonly _W: (_: never) => never;
+    readonly _S1: (_: unknown) => void;
+    readonly _S2: (_: never) => never;
+    readonly _R: (_: never) => never;
+    readonly _E: (_: never) => never;
+    readonly _A: (_: never) => never;
+  };
+  constructor(readonly _tag: unknown) {}
+  readonly i0: unknown = undefined;
+  readonly i1: unknown = undefined;
+  readonly i2: unknown = undefined;
+}
+
+/**
+ * @tsplus static fncts.control.PureOps isPure
+ */
+export function isPure(u: unknown): u is Pure<unknown, unknown, unknown, unknown, unknown, unknown> {
+  return isObject(u) && PureTypeId in u;
+}
+
+export const enum PureTag {
+  SucceedNow,
+  Succeed,
+  Defer,
+  Fail,
+  Modify,
+  Chain,
+  Match,
+  Access,
+  Provide,
+  Tell,
+  Listen,
+  MapLog,
+}
+
+export type PureOp<Tag extends number, Body = {}> = PurePrimitive &
+  Body & {
+    _tag: Tag;
+  };
+
+export interface SucceedNow
+  extends PureOp<
+    PureTag.SucceedNow,
+    {
+      readonly i0: any;
+    }
+  > {}
+
+export interface Succeed
+  extends PureOp<
+    PureTag.Succeed,
+    {
+      readonly i0: () => any;
+    }
+  > {}
+
+export interface Defer
+  extends PureOp<
+    PureTag.Defer,
+    {
+      readonly i0: () => Primitive;
+    }
+  > {}
+
+export interface Fail
+  extends PureOp<
+    PureTag.Fail,
+    {
+      readonly i0: Cause<unknown>;
+    }
+  > {}
+
+export interface Modify
+  extends PureOp<
+    PureTag.Modify,
+    {
+      readonly i0: (s1: any) => readonly [any, any];
+    }
+  > {}
+
+export interface FlatMap
+  extends PureOp<
+    PureTag.Chain,
+    {
+      readonly i0: Primitive;
+      readonly i1: (a: any) => Primitive;
+    }
+  > {}
+
+export interface Match
+  extends PureOp<
+    PureTag.Match,
+    {
+      readonly i0: Primitive;
+      readonly i1: (ws: Conc<any>, e: Cause<unknown>) => Primitive;
+      readonly i2: (ws: Conc<any>, a: any) => Primitive;
+    }
+  > {}
+
+export interface Access
+  extends PureOp<
+    PureTag.Access,
+    {
+      readonly i0: (r: Environment<any>) => Primitive;
+    }
+  > {}
+
+export interface Provide
+  extends PureOp<
+    PureTag.Provide,
+    {
+      readonly i0: Primitive;
+      readonly i1: Environment<any>;
+    }
+  > {}
+
+export interface Tell
+  extends PureOp<
+    PureTag.Tell,
+    {
+      readonly i0: Conc<any>;
+    }
+  > {}
+
+export interface MapLog
+  extends PureOp<
+    PureTag.MapLog,
+    {
+      readonly i0: Primitive;
+      readonly i1: (ws: Conc<any>) => Conc<any>;
+    }
+  > {}
+
+export type Primitive =
+  | SucceedNow
+  | Fail
+  | Modify
+  | FlatMap
+  | Match
+  | Access
+  | Provide
+  | Defer
+  | Succeed
+  | Tell
+  | MapLog;
+
+/**
+ * @tsplus static fncts.control.PureOps concrete
+ */
+export function concrete(_: Pure<any, any, any, any, any, any>): asserts _ is Primitive {
+  //
+}
+
+export const PureErrorTypeId = Symbol.for("fncts.Pure.ZError");
+export type PureErrorTypeId = typeof PureErrorTypeId;
+
+export class PureError<E> {
+  readonly [PureErrorTypeId]: PureErrorTypeId = PureErrorTypeId;
+  constructor(readonly cause: Cause<E>) {}
+}
+
+export function isPureError(u: unknown): u is PureError<unknown> {
+  return isObject(u) && PureErrorTypeId in u;
+}

package/_src/control/{Z → Pure}/instances.ts

@@ -1,12 +1,12 @@
 import type * as P from "../../typeclass.js";
-import type { ZF } from "./definition.js";
+import type { PureF } from "./definition.js";
 
 import { map, succeedNow, zip, zipWith } from "./api.js";
 /**
- * @tsplus static fncts.control.ZOps Applicative
+ * @tsplus static fncts.control.PureOps Applicative
  * @tsplus implicit
  */
-export const Applicative = HKT.instance<P.Applicative<ZF>>({
+export const Applicative = HKT.instance<P.Applicative<PureF>>({
   map,
   zip,
   zipWith,

package/_src/control/{Z → Pure}/runtime.ts

@@ -1,18 +1,18 @@
 import { identity } from "../../data/function.js";
 import { Stack } from "../../internal/Stack.js";
-import { concrete, isZError, ZTag } from "./definition.js";
+import { concrete, isPureError, PurePrimitive, PureTag } from "./definition.js";
 
 class MatchFrame {
-  readonly _zTag = "MatchFrame";
+  readonly _tag = "MatchFrame";
   constructor(
-    readonly failure: (e: any) => Z<any, any, any, any, any, any>,
-    readonly apply: (a: any) => Z<any, any, any, any, any, any>,
+    readonly failure: (e: any) => Pure<any, any, any, any, any, any>,
+    readonly apply: (a: any) => Pure<any, any, any, any, any, any>,
   ) {}
 }
 
 class ApplyFrame {
-  readonly _zTag = "ApplyFrame";
-  constructor(readonly apply: (e: any) => Z<any, any, any, any, any, any>) {}
+  readonly _tag = "ApplyFrame";
+  constructor(readonly apply: (e: any) => Pure<any, any, any, any, any, any>) {}
 }
 
 type Frame = MatchFrame | ApplyFrame;
@@ -21,16 +21,16 @@ type Frame = MatchFrame | ApplyFrame;
  * Runs this computation with the specified initial state, returning either a
  * failure or the updated state and the result
  *
- * @tsplus pipeable fncts.control.Z unsafeRunAll
+ * @tsplus pipeable fncts.control.Pure unsafeRunAll
  */
 export function unsafeRunAll<S1>(s: S1) {
-  return <W, S2, E, A>(ma: Z<W, S1, S2, never, E, A>): readonly [Conc<W>, Exit<E, readonly [S2, A]>] => {
+  return <W, S2, E, A>(ma: Pure<W, S1, S2, never, E, A>): readonly [Conc<W>, Exit<E, readonly [S2, A]>] => {
     const stack: Stack<Frame> = Stack();
     let s0                    = s as any;
     let result: any           = null;
     const environment         = Stack<Environment<unknown>>();
     let failed                = false;
-    let current               = ma as Z<any, any, any, any, any, any> | undefined;
+    let current               = ma as Pure<any, any, any, any, any, any> | undefined;
     let log                   = Conc.empty<W>();
     function unsafeUnwindStack() {
       let unwinding = true;
@@ -39,7 +39,7 @@ export function unsafeRunAll<S1>(s: S1) {
         if (next == null) {
           unwinding = false;
         } else {
-          if (next._zTag === "MatchFrame") {
+          if (next._tag === "MatchFrame") {
             unwinding = false;
             stack.push(new ApplyFrame(next.failure));
           }
@@ -49,24 +49,24 @@ export function unsafeRunAll<S1>(s: S1) {
     while (current != null) {
       try {
         while (current != null) {
-          const currZ: Z<any, any, any, any, any, any> = current;
-          concrete(currZ);
-          switch (currZ._tag) {
-            case ZTag.Chain: {
-              const nested       = currZ.ma;
-              const continuation = currZ.f;
+          const currPure: Pure<any, any, any, any, any, any> = current;
+          concrete(currPure);
+          switch (currPure._tag) {
+            case PureTag.Chain: {
+              const nested       = currPure.i0;
+              const continuation = currPure.i1;
               concrete(nested);
               switch (nested._tag) {
-                case ZTag.SucceedNow: {
-                  current = continuation(nested.value);
+                case PureTag.SucceedNow: {
+                  current = continuation(nested.i0);
                   break;
                 }
-                case ZTag.Succeed: {
-                  current = continuation(nested.effect());
+                case PureTag.Succeed: {
+                  current = continuation(nested.i0());
                   break;
                 }
-                case ZTag.Modify: {
-                  const updated = nested.run(s0);
+                case PureTag.Modify: {
+                  const updated = nested.i0(s0);
                   result        = updated[0];
                   s0            = updated[1];
                   current       = continuation(result);
@@ -80,8 +80,8 @@ export function unsafeRunAll<S1>(s: S1) {
               }
               break;
             }
-            case ZTag.Succeed: {
-              result                = currZ.effect();
+            case PureTag.Succeed: {
+              result                = currPure.i0();
               const nextInstruction = stack.pop();
               if (nextInstruction) {
                 current = nextInstruction.apply(result);
@@ -90,12 +90,12 @@ export function unsafeRunAll<S1>(s: S1) {
               }
               break;
             }
-            case ZTag.Defer: {
-              current = currZ.make();
+            case PureTag.Defer: {
+              current = currPure.i0();
               break;
             }
-            case ZTag.SucceedNow: {
-              result          = currZ.value;
+            case PureTag.SucceedNow: {
+              result          = currPure.i0;
               const nextInstr = stack.pop();
               if (nextInstr) {
                 current = nextInstr.apply(result);
@@ -104,30 +104,30 @@ export function unsafeRunAll<S1>(s: S1) {
               }
               break;
             }
-            case ZTag.Fail: {
+            case PureTag.Fail: {
               unsafeUnwindStack();
               const nextInst = stack.pop();
               if (nextInst) {
-                current = nextInst.apply(currZ.cause);
+                current = nextInst.apply(currPure.i0);
               } else {
                 failed  = true;
-                result  = currZ.cause;
+                result  = currPure.i0;
                 current = undefined;
               }
               break;
             }
-            case ZTag.Match: {
-              current     = currZ.z;
+            case PureTag.Match: {
+              current     = currPure.i0;
               const state = s0;
               stack.push(
                 new MatchFrame(
                   (cause: Cause<any>) => {
-                    const m = Z.put(state).flatMap(() => currZ.onFailure(log, cause));
+                    const m = Pure.put(state).flatMap(() => currPure.i1(log, cause));
                     log     = Conc.empty();
                     return m;
                   },
                   (a) => {
-                    const m = currZ.onSuccess(log, a);
+                    const m = currPure.i2(log, a);
                     log     = Conc.empty();
                     return m;
                   },
@@ -135,20 +135,20 @@ export function unsafeRunAll<S1>(s: S1) {
               );
               break;
             }
-            case ZTag.Access: {
-              current = currZ.asks(environment.peek() ?? Environment());
+            case PureTag.Access: {
+              current = currPure.i0(environment.peek() ?? Environment());
               break;
             }
-            case ZTag.Provide: {
-              environment.push(currZ.env);
-              current = currZ.ma.match(
-                (e) => Z.succeedNow(environment.pop()).flatMap(() => Z.failNow(e)),
-                (a) => Z.succeedNow(environment.pop()).flatMap(() => Z.succeedNow(a)),
-              );
+            case PureTag.Provide: {
+              environment.push(currPure.i1);
+              current             = new PurePrimitive(PureTag.Match) as any;
+              (current as any).i0 = currPure;
+              (current as any).i1 = (e: any) => Pure.succeedNow(environment.pop()).flatMap(() => Pure.failNow(e));
+              (current as any).i2 = (a: any) => Pure.succeedNow(environment.pop()).flatMap(() => Pure.succeedNow(a));
               break;
             }
-            case ZTag.Modify: {
-              const updated  = currZ.run(s0);
+            case PureTag.Modify: {
+              const updated  = currPure.i0(s0);
               s0             = updated[1];
               result         = updated[0];
               const nextInst = stack.pop();
@@ -159,8 +159,8 @@ export function unsafeRunAll<S1>(s: S1) {
               }
               break;
             }
-            case ZTag.Tell: {
-              log            = currZ.log;
+            case PureTag.Tell: {
+              log            = currPure.i0;
               const nextInst = stack.pop();
               if (nextInst) {
                 current = nextInst.apply(result);
@@ -169,17 +169,17 @@ export function unsafeRunAll<S1>(s: S1) {
               }
               break;
             }
-            case ZTag.MapLog: {
-              current = currZ.ma;
+            case PureTag.MapLog: {
+              current = currPure.i0;
               stack.push(
                 new MatchFrame(
                   (cause: Cause<any>) => {
-                    log = currZ.modifyLog(log);
-                    return Z.failCauseNow(cause);
+                    log = currPure.i1(log);
+                    return Pure.failCauseNow(cause);
                   },
                   (a) => {
-                    log = currZ.modifyLog(log);
-                    return Z.succeedNow(a);
+                    log = currPure.i1(log);
+                    return Pure.succeedNow(a);
                   },
                 ),
               );
@@ -187,8 +187,8 @@ export function unsafeRunAll<S1>(s: S1) {
           }
         }
       } catch (e) {
-        if (isZError(e)) {
-          current = Z.failCauseNow(e.cause);
+        if (isPureError(e)) {
+          current = Pure.failCauseNow(e.cause);
         } else {
           failed = true;
           result = Cause.halt(e);
@@ -206,13 +206,12 @@ export function unsafeRunAll<S1>(s: S1) {
  * Runs this computation with the specified initial state, returning both
  * the updated state and the result.
  *
- * @tsplus pipeable fncts.control.Z unsafeRun
+ * @tsplus pipeable fncts.control.Pure unsafeRun
  */
 export function unsafeRun<S1>(s: S1) {
-  return <W, S2, A>(ma: Z<W, S1, S2, never, never, A>): readonly [S2, A] => {
+  return <W, S2, A>(ma: Pure<W, S1, S2, never, never, A>): readonly [S2, A] => {
     return ma.unsafeRunAll(s)[1].match((cause) => {
-      // throw cause.squash
-      throw new Error();
+      throw cause.squashWith(Function.identity);
     }, identity);
   };
 }
@@ -220,19 +219,19 @@ export function unsafeRun<S1>(s: S1) {
 /**
  * Runs this computation, returning the result.
  *
- * @tsplus getter fncts.control.Z unsafeRunResult
+ * @tsplus getter fncts.control.Pure unsafeRunResult
  */
-export function unsafeRunResult<W, A>(ma: Z<W, unknown, unknown, never, never, A>): A {
+export function unsafeRunResult<W, A>(ma: Pure<W, unknown, unknown, never, never, A>): A {
   return ma.unsafeRun({})[1];
 }
 
 /**
  * Runs this computation with the given environment, returning the result.
  *
- * @tsplus pipeable fncts.control.Z unsafeRunReader
+ * @tsplus pipeable fncts.control.Pure unsafeRunReader
  */
 export function unsafeRunReader<R>(r: Environment<R>) {
-  return <W, A>(ma: Z<W, unknown, never, R, never, A>): A => {
+  return <W, A>(ma: Pure<W, unknown, never, R, never, A>): A => {
     return unsafeRunResult(ma.provideEnvironment(r));
   };
 }
@@ -241,10 +240,10 @@ export function unsafeRunReader<R>(r: Environment<R>) {
  * Runs this computation with the specified initial state, returning the
  * updated state and discarding the result.
  *
- * @tsplus pipeable fncts.control.Z unsafeRunState
+ * @tsplus pipeable fncts.control.Pure unsafeRunState
  */
 export function unsafeRunState<S1>(s: S1) {
-  return <W, S2, A>(ma: Z<W, S1, S2, never, never, A>): S2 => {
+  return <W, S2, A>(ma: Pure<W, S1, S2, never, never, A>): S2 => {
     return ma.unsafeRun(s)[0];
   };
 }
@@ -253,14 +252,13 @@ export function unsafeRunState<S1>(s: S1) {
  * Runs this computation with the specified initial state, returning the
  * result and discarding the updated state.
  *
- * @tsplus pipeable fncts.control.Z unsafeRunStateResult
+ * @tsplus pipeable fncts.control.Pure unsafeRunStateResult
  */
 export function unsafeRunStateResult<S1>(s: S1) {
-  return <W, S2, A>(ma: Z<W, S1, S2, never, never, A>): A => {
+  return <W, S2, A>(ma: Pure<W, S1, S2, never, never, A>): A => {
     return ma.unsafeRunAll(s)[1].match(
       (cause) => {
-        // throw cause.squash
-        throw new Error();
+        throw cause.squashWith(Function.identity);
       },
       ([_, a]) => a,
     );
@@ -270,22 +268,21 @@ export function unsafeRunStateResult<S1>(s: S1) {
 /**
  * Runs this computation returning either the result or error
  *
- * @tsplus getter fncts.control.Z unsafeRunExit
+ * @tsplus getter fncts.control.Pure unsafeRunExit
  */
-export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, never, E, A>): Exit<E, A> {
+export function unsafeRunExit<E, A>(ma: Pure<never, unknown, unknown, never, E, A>): Exit<E, A> {
   return ma.unsafeRunAll({} as never)[1].map(([_, a]) => a);
 }
 
 /**
  *
- * @tsplus getter fncts.control.Z unsafeRunWriter
+ * @tsplus getter fncts.control.Pure unsafeRunWriter
  */
-export function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A] {
+export function unsafeRunWriter<W, A>(ma: Pure<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A] {
   const [w, exit] = ma.unsafeRunAll({});
   return exit.match(
-    () => {
-      // throw cause.squash
-      throw new Error();
+    (cause) => {
+      throw cause.squashWith(Function.identity);
     },
     ([_, a]) => [w, a],
   );

package/_src/control/Pure.ts

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

package/_src/control.ts

@@ -2,5 +2,5 @@
 export type {} from "./control/CompletablePromise.js";
 export type {} from "./control/Eval.js";
 export type {} from "./control/LazyValue.js";
-export type {} from "./control/Z.js";
+export type {} from "./control/Pure.js";
 // codegen:end

package/_src/data/Date/definition.ts

@@ -0,0 +1,6 @@
+declare global {
+  /** @tsplus type fncts.Date */
+  interface Date {}
+  /** @tsplus type fncts.DateOps */
+  interface DateConstructor {}
+}

package/_src/data/Date.ts

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