@fncts/base 0.0.20 → 0.0.21

package/_src/control/Z/runtime.ts

@@ -21,205 +21,200 @@ type Frame = MatchFrame | ApplyFrame;
  * Runs this computation with the specified initial state, returning either a
  * failure or the updated state and the result
  *
- * @tsplus fluent fncts.control.Z unsafeRunAll
+ * @tsplus pipeable fncts.control.Z unsafeRunAll
  */
-export function unsafeRunAll_<W, S1, S2, E, A>(
-  ma: Z<W, S1, S2, never, E, A>,
-  s: S1,
-): 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 log                   = Conc.empty<W>();
-
-  function unsafeUnwindStack() {
-    let unwinding = true;
-    while (unwinding) {
-      const next = stack.pop();
-
-      if (next == null) {
-        unwinding = false;
-      } else {
-        if (next._zTag === "MatchFrame") {
+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]>] => {
+    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 log                   = Conc.empty<W>();
+    function unsafeUnwindStack() {
+      let unwinding = true;
+      while (unwinding) {
+        const next = stack.pop();
+        if (next == null) {
           unwinding = false;
-          stack.push(new ApplyFrame(next.failure));
+        } else {
+          if (next._zTag === "MatchFrame") {
+            unwinding = false;
+            stack.push(new ApplyFrame(next.failure));
+          }
         }
       }
     }
-  }
-
-  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;
-            concrete(nested);
-            switch (nested._tag) {
-              case ZTag.SucceedNow: {
-                current = continuation(nested.value);
-                break;
+    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;
+              concrete(nested);
+              switch (nested._tag) {
+                case ZTag.SucceedNow: {
+                  current = continuation(nested.value);
+                  break;
+                }
+                case ZTag.Succeed: {
+                  current = continuation(nested.effect());
+                  break;
+                }
+                case ZTag.Modify: {
+                  const updated = nested.run(s0);
+                  result        = updated[0];
+                  s0            = updated[1];
+                  current       = continuation(result);
+                  break;
+                }
+                default: {
+                  current = nested;
+                  stack.push(new ApplyFrame(continuation));
+                  break;
+                }
               }
-              case ZTag.Succeed: {
-                current = continuation(nested.effect());
-                break;
+              break;
+            }
+            case ZTag.Succeed: {
+              result                = currZ.effect();
+              const nextInstruction = stack.pop();
+              if (nextInstruction) {
+                current = nextInstruction.apply(result);
+              } else {
+                current = undefined;
               }
-              case ZTag.Modify: {
-                const updated = nested.run(s0);
-                result        = updated[0];
-                s0            = updated[1];
-                current       = continuation(result);
-                break;
+              break;
+            }
+            case ZTag.Defer: {
+              current = currZ.make();
+              break;
+            }
+            case ZTag.SucceedNow: {
+              result          = currZ.value;
+              const nextInstr = stack.pop();
+              if (nextInstr) {
+                current = nextInstr.apply(result);
+              } else {
+                current = undefined;
               }
-              default: {
-                current = nested;
-                stack.push(new ApplyFrame(continuation));
-                break;
+              break;
+            }
+            case ZTag.Fail: {
+              unsafeUnwindStack();
+              const nextInst = stack.pop();
+              if (nextInst) {
+                current = nextInst.apply(currZ.cause);
+              } else {
+                failed  = true;
+                result  = currZ.cause;
+                current = undefined;
               }
+              break;
             }
-            break;
-          }
-          case ZTag.Succeed: {
-            result                = currZ.effect();
-            const nextInstruction = stack.pop();
-            if (nextInstruction) {
-              current = nextInstruction.apply(result);
-            } else {
-              current = undefined;
+            case ZTag.Match: {
+              current     = currZ.z;
+              const state = s0;
+              stack.push(
+                new MatchFrame(
+                  (cause: Cause<any>) => {
+                    const m = Z.put(state).flatMap(() => currZ.onFailure(log, cause));
+                    log     = Conc.empty();
+                    return m;
+                  },
+                  (a) => {
+                    const m = currZ.onSuccess(log, a);
+                    log     = Conc.empty();
+                    return m;
+                  },
+                ),
+              );
+              break;
             }
-            break;
-          }
-          case ZTag.Defer: {
-            current = currZ.make();
-            break;
-          }
-          case ZTag.SucceedNow: {
-            result          = currZ.value;
-            const nextInstr = stack.pop();
-            if (nextInstr) {
-              current = nextInstr.apply(result);
-            } else {
-              current = undefined;
+            case ZTag.Access: {
+              current = currZ.asks(environment.peek() ?? Environment());
+              break;
             }
-            break;
-          }
-          case ZTag.Fail: {
-            unsafeUnwindStack();
-            const nextInst = stack.pop();
-            if (nextInst) {
-              current = nextInst.apply(currZ.cause);
-            } else {
-              failed  = true;
-              result  = currZ.cause;
-              current = undefined;
+            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)),
+              );
+              break;
             }
-            break;
-          }
-          case ZTag.Match: {
-            current     = currZ.z;
-            const state = s0;
-            stack.push(
-              new MatchFrame(
-                (cause: Cause<any>) => {
-                  const m = Z.put(state).flatMap(() => currZ.onFailure(log, cause));
-                  log     = Conc.empty();
-                  return m;
-                },
-                (a) => {
-                  const m = currZ.onSuccess(log, a);
-                  log     = Conc.empty();
-                  return m;
-                },
-              ),
-            );
-            break;
-          }
-          case ZTag.Access: {
-            current = currZ.asks(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)),
-            );
-            break;
-          }
-          case ZTag.Modify: {
-            const updated  = currZ.run(s0);
-            s0             = updated[1];
-            result         = updated[0];
-            const nextInst = stack.pop();
-            if (nextInst) {
-              current = nextInst.apply(result);
-            } else {
-              current = undefined;
+            case ZTag.Modify: {
+              const updated  = currZ.run(s0);
+              s0             = updated[1];
+              result         = updated[0];
+              const nextInst = stack.pop();
+              if (nextInst) {
+                current = nextInst.apply(result);
+              } else {
+                current = undefined;
+              }
+              break;
             }
-            break;
-          }
-          case ZTag.Tell: {
-            log            = currZ.log;
-            const nextInst = stack.pop();
-            if (nextInst) {
-              current = nextInst.apply(result);
-            } else {
-              current = undefined;
+            case ZTag.Tell: {
+              log            = currZ.log;
+              const nextInst = stack.pop();
+              if (nextInst) {
+                current = nextInst.apply(result);
+              } else {
+                current = undefined;
+              }
+              break;
+            }
+            case ZTag.MapLog: {
+              current = currZ.ma;
+              stack.push(
+                new MatchFrame(
+                  (cause: Cause<any>) => {
+                    log = currZ.modifyLog(log);
+                    return Z.failCauseNow(cause);
+                  },
+                  (a) => {
+                    log = currZ.modifyLog(log);
+                    return Z.succeedNow(a);
+                  },
+                ),
+              );
             }
-            break;
-          }
-          case ZTag.MapLog: {
-            current = currZ.ma;
-            stack.push(
-              new MatchFrame(
-                (cause: Cause<any>) => {
-                  log = currZ.modifyLog(log);
-                  return Z.failCauseNow(cause);
-                },
-                (a) => {
-                  log = currZ.modifyLog(log);
-                  return Z.succeedNow(a);
-                },
-              ),
-            );
           }
         }
-      }
-    } catch (e) {
-      if (isZError(e)) {
-        current = Z.failCauseNow(e.cause);
-      } else {
-        failed = true;
-        result = Cause.halt(e);
+      } catch (e) {
+        if (isZError(e)) {
+          current = Z.failCauseNow(e.cause);
+        } else {
+          failed = true;
+          result = Cause.halt(e);
+        }
       }
     }
-  }
-
-  if (failed) {
-    return [log, Exit.failCause(result)];
-  }
-
-  return [log, Exit.succeed([s0, result])];
+    if (failed) {
+      return [log, Exit.failCause(result)];
+    }
+    return [log, Exit.succeed([s0, result])];
+  };
 }
 
 /**
  * Runs this computation with the specified initial state, returning both
  * the updated state and the result.
  *
- * @tsplus fluent fncts.control.Z unsafeRun
+ * @tsplus pipeable fncts.control.Z unsafeRun
  */
-export function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): readonly [S2, A] {
-  return ma.unsafeRunAll(s)[1].match((cause) => {
-    // throw cause.squash
-    throw new Error();
-  }, identity);
+export function unsafeRun<S1>(s: S1) {
+  return <W, S2, A>(ma: Z<W, S1, S2, never, never, A>): readonly [S2, A] => {
+    return ma.unsafeRunAll(s)[1].match((cause) => {
+      // throw cause.squash
+      throw new Error();
+    }, identity);
+  };
 }
 
 /**
@@ -228,42 +223,48 @@ export function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S
  * @tsplus getter fncts.control.Z unsafeRunResult
  */
 export function unsafeRunResult<W, A>(ma: Z<W, unknown, unknown, never, never, A>): A {
-  return unsafeRun_(ma, {})[1];
+  return ma.unsafeRun({})[1];
 }
 
 /**
  * Runs this computation with the given environment, returning the result.
  *
- * @tsplus fluent fncts.control.Z unsafeRunReader
+ * @tsplus pipeable fncts.control.Z unsafeRunReader
  */
-export function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>, r: Environment<R>): A {
-  return unsafeRunResult(ma.provideEnvironment(r));
+export function unsafeRunReader<R>(r: Environment<R>) {
+  return <W, A>(ma: Z<W, unknown, never, R, never, A>): A => {
+    return unsafeRunResult(ma.provideEnvironment(r));
+  };
 }
 
 /**
  * Runs this computation with the specified initial state, returning the
  * updated state and discarding the result.
  *
- * @tsplus fluent fncts.control.Z unsafeRunState
+ * @tsplus pipeable fncts.control.Z unsafeRunState
  */
-export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): S2 {
-  return ma.unsafeRun(s)[0];
+export function unsafeRunState<S1>(s: S1) {
+  return <W, S2, A>(ma: Z<W, S1, S2, never, never, A>): S2 => {
+    return ma.unsafeRun(s)[0];
+  };
 }
 
 /**
  * Runs this computation with the specified initial state, returning the
  * result and discarding the updated state.
  *
- * @tsplus fluent fncts.control.Z unsafeRunStateResult
+ * @tsplus pipeable fncts.control.Z unsafeRunStateResult
  */
-export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): A {
-  return ma.unsafeRunAll(s)[1].match(
-    (cause) => {
-      // throw cause.squash
-      throw new Error();
-    },
-    ([_, a]) => a,
-  );
+export function unsafeRunStateResult<S1>(s: S1) {
+  return <W, S2, A>(ma: Z<W, S1, S2, never, never, A>): A => {
+    return ma.unsafeRunAll(s)[1].match(
+      (cause) => {
+        // throw cause.squash
+        throw new Error();
+      },
+      ([_, a]) => a,
+    );
+  };
 }
 
 /**

package/_src/data/Branded/definition.ts

@@ -1,7 +1,5 @@
 import type { Union } from "@fncts/typelevel";
-
 declare const validSym: unique symbol;
-
 export declare namespace Brand {
   export type valid = typeof validSym;
 
@@ -25,16 +23,17 @@ export declare namespace Brand {
     : never;
 
   export type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P;
-
-  export type Brands<P> = P extends Valid<any, any> ? Union.IntersectionOf<
-    {
-      [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K]
-        ? K extends string
-          ? Valid<P[Brand.valid][K], K>
-          : never
-        : never;
-    }[keyof P[Brand.valid]]
-  > : unknown;
+  export type Brands<P> = P extends Valid<any, any>
+    ? Union.IntersectionOf<
+        {
+          [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K]
+            ? K extends string
+              ? Valid<P[Brand.valid][K], K>
+              : never
+            : never;
+        }[keyof P[Brand.valid]]
+      >
+    : unknown;
 }
 
 /**

package/_src/data/Branded/derivations.ts

@@ -1,4 +1,4 @@
-import type { Validation, Brand } from "@fncts/base/data/Branded/definition";
+import type { Brand, Validation } from "@fncts/base/data/Branded/definition";
 import type { Check } from "@fncts/typelevel/Check";
 
 import { BrandedError, CompoundError } from "@fncts/base/data/DecodeError";
@@ -29,7 +29,7 @@ export function deriveDecoder<A extends Brand.Valid<any, any>>(
     ? [
         base: Decoder<Brand.Unbranded<A>>,
         brands: {
-          [K in (keyof A[Brand.valid]) & string]: Validation<A[Brand.valid][K], K>;
+          [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
         },
       ]
     : never

package/_src/data/CaseClass.ts

@@ -82,7 +82,10 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
 };
 
 export interface CaseConstructorTagged<Tag extends string | symbol, K extends string | symbol> {
-  new <T>(args: Equals<T, {}> extends true ? void : T): T & Copy<T> & { readonly [k in K]: Tag };
+  new <T>(args: Equals<T, {}> extends true ? void : T): T &
+    Copy<T> & {
+      readonly [k in K]: Tag;
+    };
 }
 
 export function Tagged<Tag extends string | symbol, Key extends string | symbol>(

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

@@ -87,19 +87,18 @@ function foldLoop<E, Z>(
 /**
  * Folds over a cause
  *
- * @tsplus fluent fncts.Cause fold
+ * @tsplus pipeable fncts.Cause fold
  */
-export function fold_<E, Z>(
-  self: Cause<E>,
-  cases: {
-    Empty: () => Z;
-    Fail: (e: E, trace: Trace) => Z;
-    Halt: (t: unknown, trace: Trace) => Z;
-    Interrupt: (fiberId: FiberId, trace: Trace) => Z;
-    Then: (l: Z, r: Z) => Z;
-    Both: (l: Z, r: Z) => Z;
-    Stackless: (z: Z, stackless: boolean) => Z;
-  },
-): Z {
-  return foldLoop(cases, Cons(self, Nil()), List.empty()).unsafeHead;
+export function fold<E, Z>(cases: {
+  Empty: () => Z;
+  Fail: (e: E, trace: Trace) => Z;
+  Halt: (t: unknown, trace: Trace) => Z;
+  Interrupt: (fiberId: FiberId, trace: Trace) => Z;
+  Then: (l: Z, r: Z) => Z;
+  Both: (l: Z, r: Z) => Z;
+  Stackless: (z: Z, stackless: boolean) => Z;
+}) {
+  return (self: Cause<E>): Z => {
+    return foldLoop(cases, Cons(self, Nil()), List.empty()).unsafeHead;
+  };
 }