@barnum/barnum 0.3.0 → 0.4.0

package/src/pipe.ts

@@ -3,91 +3,136 @@ import {
   type PipeIn,
   type Pipeable,
   type TypedAction,
-  typedAction,
+  toAction,
 } from "./ast.js";
-import { identity } from "./builtins.js";
+import { chain } from "./chain.js";
+import { identity } from "./builtins/index.js";
 
-export function pipe<T1, T2>(a1: Pipeable<T1, T2>): TypedAction<PipeIn<T1>, T2>;
-export function pipe<T1, T2, T3>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-): TypedAction<PipeIn<T1>, T3>;
-export function pipe<T1, T2, T3, T4>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-  a3: Pipeable<T3, T4>,
-): TypedAction<PipeIn<T1>, T4>;
-export function pipe<T1, T2, T3, T4, T5>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-  a3: Pipeable<T3, T4>,
-  a4: Pipeable<T4, T5>,
-): TypedAction<PipeIn<T1>, T5>;
-export function pipe<T1, T2, T3, T4, T5, T6>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-  a3: Pipeable<T3, T4>,
-  a4: Pipeable<T4, T5>,
-  a5: Pipeable<T5, T6>,
-): TypedAction<PipeIn<T1>, T6>;
-export function pipe<T1, T2, T3, T4, T5, T6, T7>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-  a3: Pipeable<T3, T4>,
-  a4: Pipeable<T4, T5>,
-  a5: Pipeable<T5, T6>,
-  a6: Pipeable<T6, T7>,
-): TypedAction<PipeIn<T1>, T7>;
-export function pipe<T1, T2, T3, T4, T5, T6, T7, T8>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-  a3: Pipeable<T3, T4>,
-  a4: Pipeable<T4, T5>,
-  a5: Pipeable<T5, T6>,
-  a6: Pipeable<T6, T7>,
-  a7: Pipeable<T7, T8>,
-): TypedAction<PipeIn<T1>, T8>;
-export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-  a3: Pipeable<T3, T4>,
-  a4: Pipeable<T4, T5>,
-  a5: Pipeable<T5, T6>,
-  a6: Pipeable<T6, T7>,
-  a7: Pipeable<T7, T8>,
-  a8: Pipeable<T8, T9>,
-): TypedAction<PipeIn<T1>, T9>;
-export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-  a3: Pipeable<T3, T4>,
-  a4: Pipeable<T4, T5>,
-  a5: Pipeable<T5, T6>,
-  a6: Pipeable<T6, T7>,
-  a7: Pipeable<T7, T8>,
-  a8: Pipeable<T8, T9>,
-  a9: Pipeable<T9, T10>,
-): TypedAction<PipeIn<T1>, T10>;
-export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
-  a1: Pipeable<T1, T2>,
-  a2: Pipeable<T2, T3>,
-  a3: Pipeable<T3, T4>,
-  a4: Pipeable<T4, T5>,
-  a5: Pipeable<T5, T6>,
-  a6: Pipeable<T6, T7>,
-  a7: Pipeable<T7, T8>,
-  a8: Pipeable<T8, T9>,
-  a9: Pipeable<T9, T10>,
-  a10: Pipeable<T10, T11>,
-): TypedAction<PipeIn<T1>, T11>;
+export function pipe<TStep1, TStep2>(
+  a1: Pipeable<TStep1, TStep2>,
+): TypedAction<PipeIn<TStep1>, TStep2>;
+export function pipe<TStep1, TStep2, TStep3>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+): TypedAction<PipeIn<TStep1>, TStep3>;
+export function pipe<TStep1, TStep2, TStep3, TStep4>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+  a3: Pipeable<TStep3, TStep4>,
+): TypedAction<PipeIn<TStep1>, TStep4>;
+export function pipe<TStep1, TStep2, TStep3, TStep4, TStep5>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+  a3: Pipeable<TStep3, TStep4>,
+  a4: Pipeable<TStep4, TStep5>,
+): TypedAction<PipeIn<TStep1>, TStep5>;
+export function pipe<TStep1, TStep2, TStep3, TStep4, TStep5, TStep6>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+  a3: Pipeable<TStep3, TStep4>,
+  a4: Pipeable<TStep4, TStep5>,
+  a5: Pipeable<TStep5, TStep6>,
+): TypedAction<PipeIn<TStep1>, TStep6>;
+export function pipe<TStep1, TStep2, TStep3, TStep4, TStep5, TStep6, TStep7>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+  a3: Pipeable<TStep3, TStep4>,
+  a4: Pipeable<TStep4, TStep5>,
+  a5: Pipeable<TStep5, TStep6>,
+  a6: Pipeable<TStep6, TStep7>,
+): TypedAction<PipeIn<TStep1>, TStep7>;
+export function pipe<
+  TStep1,
+  TStep2,
+  TStep3,
+  TStep4,
+  TStep5,
+  TStep6,
+  TStep7,
+  TStep8,
+>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+  a3: Pipeable<TStep3, TStep4>,
+  a4: Pipeable<TStep4, TStep5>,
+  a5: Pipeable<TStep5, TStep6>,
+  a6: Pipeable<TStep6, TStep7>,
+  a7: Pipeable<TStep7, TStep8>,
+): TypedAction<PipeIn<TStep1>, TStep8>;
+export function pipe<
+  TStep1,
+  TStep2,
+  TStep3,
+  TStep4,
+  TStep5,
+  TStep6,
+  TStep7,
+  TStep8,
+  TStep9,
+>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+  a3: Pipeable<TStep3, TStep4>,
+  a4: Pipeable<TStep4, TStep5>,
+  a5: Pipeable<TStep5, TStep6>,
+  a6: Pipeable<TStep6, TStep7>,
+  a7: Pipeable<TStep7, TStep8>,
+  a8: Pipeable<TStep8, TStep9>,
+): TypedAction<PipeIn<TStep1>, TStep9>;
+export function pipe<
+  TStep1,
+  TStep2,
+  TStep3,
+  TStep4,
+  TStep5,
+  TStep6,
+  TStep7,
+  TStep8,
+  TStep9,
+  TStep10,
+>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+  a3: Pipeable<TStep3, TStep4>,
+  a4: Pipeable<TStep4, TStep5>,
+  a5: Pipeable<TStep5, TStep6>,
+  a6: Pipeable<TStep6, TStep7>,
+  a7: Pipeable<TStep7, TStep8>,
+  a8: Pipeable<TStep8, TStep9>,
+  a9: Pipeable<TStep9, TStep10>,
+): TypedAction<PipeIn<TStep1>, TStep10>;
+export function pipe<
+  TStep1,
+  TStep2,
+  TStep3,
+  TStep4,
+  TStep5,
+  TStep6,
+  TStep7,
+  TStep8,
+  TStep9,
+  TStep10,
+  TStep11,
+>(
+  a1: Pipeable<TStep1, TStep2>,
+  a2: Pipeable<TStep2, TStep3>,
+  a3: Pipeable<TStep3, TStep4>,
+  a4: Pipeable<TStep4, TStep5>,
+  a5: Pipeable<TStep5, TStep6>,
+  a6: Pipeable<TStep6, TStep7>,
+  a7: Pipeable<TStep7, TStep8>,
+  a8: Pipeable<TStep8, TStep9>,
+  a9: Pipeable<TStep9, TStep10>,
+  a10: Pipeable<TStep10, TStep11>,
+): TypedAction<PipeIn<TStep1>, TStep11>;
 export function pipe(...actions: Action[]): Action {
   if (actions.length === 0) {
-    return identity;
+    return identity();
   }
   if (actions.length === 1) {
     return actions[0];
   }
-  return actions.reduceRight(
-    (rest, first) => typedAction({ kind: "Chain", first, rest }) as Action,
+  return actions.reduceRight((rest, first) =>
+    toAction(chain(toAction(first), toAction(rest))),
   );
 }

package/src/race.ts

@@ -1,43 +1,32 @@
 import {
   type Action,
   type Pipeable,
-  type Result,
+  type Result as ResultT,
   type TypedAction,
+  toAction,
   typedAction,
   buildRestartBranchAction,
-  TAG_BREAK,
-  IDENTITY,
 } from "./ast.js";
+import { chain } from "./chain.js";
+import { identity, tag } from "./builtins/index.js";
+import { Result } from "./result.js";
 import {
   allocateRestartHandlerId,
   type RestartHandlerId,
 } from "./effect-id.js";
 
-// ---------------------------------------------------------------------------
-// Shared AST fragments
-// ---------------------------------------------------------------------------
-
-const TAG_OK: Action = {
-  kind: "Invoke",
-  handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Ok" } },
-};
-
-const TAG_ERR: Action = {
-  kind: "Invoke",
-  handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Err" } },
-};
-
 /**
  * `Chain(Tag("Break"), RestartPerform(id))` — shared by race branches.
  * The winning branch tags its result as Break, then performs. The handler
  * restarts the body; Branch takes the Break arm (identity), `RestartHandle` exits.
  */
 function breakPerform(restartHandlerId: RestartHandlerId): Action {
-  return {
-    kind: "Chain",
-    first: TAG_BREAK,
-    rest: { kind: "RestartPerform", restart_handler_id: restartHandlerId },
-  };
+  return toAction(
+    chain(toAction(tag("Break", "LoopResult")), {
+      kind: "RestartPerform",
+      restart_handler_id: restartHandlerId,
+    }),
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -53,7 +42,7 @@ function breakPerform(restartHandlerId: RestartHandlerId): Action {
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({`
  *         `Continue: All(Chain(a, breakPerform), Chain(b, breakPerform), ...),`
  *         `Break: identity,`
@@ -68,16 +57,14 @@ export function race<TIn, TOut>(
   const restartHandlerId = allocateRestartHandlerId();
   const perform = breakPerform(restartHandlerId);
 
-  const branches = actions.map((action) => ({
-    kind: "Chain" as const,
-    first: action as Action,
-    rest: perform,
-  }));
+  const branches = actions.map((action) =>
+    toAction(chain(toAction(action), toAction(perform))),
+  );
 
   const allAction: Action = { kind: "All", actions: branches };
 
   return typedAction(
-    buildRestartBranchAction(restartHandlerId, allAction, IDENTITY),
+    buildRestartBranchAction(restartHandlerId, allAction, toAction(identity())),
   );
 }
 
@@ -93,10 +80,10 @@ export function race<TIn, TOut>(
  *
  * To preserve data across a sleep, use `bindInput`.
  */
-export function sleep(ms: number): TypedAction<any, never> {
-  return typedAction<any, never>({
+export function sleep(ms: number): TypedAction<any, void> {
+  return typedAction<any, void>({
     kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "Sleep", value: ms } },
+    handler: { kind: "Builtin", builtin: { kind: "Sleep", ms } },
   });
 }
 
@@ -153,31 +140,34 @@ Object.defineProperty(dynamicSleep, "__definition", {
 export function withTimeout<TIn, TOut>(
   ms: Pipeable<TIn, number>,
   body: Pipeable<TIn, TOut>,
-): TypedAction<TIn, Result<TOut, void>> {
+): TypedAction<TIn, ResultT<TOut, void>> {
   const restartHandlerId = allocateRestartHandlerId();
   const perform = breakPerform(restartHandlerId);
 
-  // Branch 1: body → Tag("Ok") → Tag("Break") → RestartPerform
-  const bodyBranch: Action = {
-    kind: "Chain",
-    first: { kind: "Chain", first: body as Action, rest: TAG_OK },
-    rest: perform,
-  };
-
-  // Branch 2: ms → sleep() → Tag("Err") → Tag("Break") → RestartPerform
-  const sleepBranch: Action = {
-    kind: "Chain",
-    first: {
-      kind: "Chain",
-      first: { kind: "Chain", first: ms as Action, rest: DYNAMIC_SLEEP_INVOKE },
-      rest: TAG_ERR,
-    },
-    rest: perform,
-  };
+  // Branch 1: body → Tag("Ok") → Break → RestartPerform
+  const bodyBranch = toAction(
+    chain(
+      toAction(chain(toAction(body), toAction(Result.ok()))),
+      toAction(perform),
+    ),
+  );
+
+  // Branch 2: ms → sleep() → Tag("Err") → Break → RestartPerform
+  const sleepBranch = toAction(
+    chain(
+      toAction(
+        chain(
+          toAction(chain(toAction(ms), toAction(DYNAMIC_SLEEP_INVOKE))),
+          toAction(Result.err()),
+        ),
+      ),
+      toAction(perform),
+    ),
+  );
 
   const allAction: Action = { kind: "All", actions: [bodyBranch, sleepBranch] };
 
   return typedAction(
-    buildRestartBranchAction(restartHandlerId, allAction, IDENTITY),
+    buildRestartBranchAction(restartHandlerId, allAction, toAction(identity())),
   );
 }

package/src/recursive.ts

@@ -2,6 +2,7 @@ import {
   type Action,
   type Pipeable,
   type TypedAction,
+  toAction,
   typedAction,
   branch,
 } from "./ast.js";
@@ -10,10 +11,10 @@ import { chain } from "./chain.js";
 import {
   constant,
   identity,
-  extractField,
-  extractIndex,
+  getField,
+  getIndex,
   tag,
-} from "./builtins.js";
+} from "./builtins/index.js";
 import { allocateResumeHandlerId } from "./effect-id.js";
 
 // ---------------------------------------------------------------------------
@@ -28,16 +29,14 @@ type FunctionRefs<TDefs extends FunctionDef[]> = {
 
 /**
  * Constraint for the entry-point callback return type. Only requires the
- * output phantom fields — omits __in and __in_co so that actions with
- * In = never (e.g. pipelines starting from a call token) are assignable.
+ * output phantom field — omits __in and __in_co so that actions with
+ * any input type (e.g. pipelines starting from a call token) are assignable.
  */
 type BodyResult<TOut> = Action & {
   __out?: () => TOut;
-  __out_contra?: (output: TOut) => void;
 };
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const UNUSED_STATE: any = undefined;
+const UNUSED_STATE = null;
 
 // ---------------------------------------------------------------------------
 // defineRecursiveFunctions
@@ -58,6 +57,12 @@ const UNUSED_STATE: any = undefined;
  * is Chain(Tag("CallN"), ResumePerform(id)). The handler dispatches to the
  * correct function body by tag. The caller's pipeline is preserved as a
  * ResumePerformFrame across each call.
+ *
+ * **Known limitation:** concurrent calls to the same function do not work
+ * as expected. `all(f(x), f(x))` will NOT call `f` twice — both branches
+ * perform on the same ResumeHandle, and the second perform will not
+ * execute independently. Use sequential calls (chain/then) instead of
+ * concurrent calls (all) when calling recursive functions multiple times.
  */
 export function defineRecursiveFunctions<TDefs extends FunctionDef[]>(
   bodiesFn: (...fns: FunctionRefs<TDefs>) => {
@@ -76,37 +81,49 @@ export function defineRecursiveFunctions<TDefs extends FunctionDef[]>(
   // Call tokens: Chain(Tag("CallN"), ResumePerform(resumeHandlerId))
   const fnCount = bodiesFn.length;
   const callTokens = Array.from({ length: fnCount }, (_, i) =>
-    typedAction(chain(tag(`Call${i}`), resumePerform as any) as Action),
+    typedAction(
+      toAction(
+        chain(
+          toAction(tag(`Call${i}`, "RecursiveDispatch")),
+          toAction(resumePerform),
+        ),
+      ),
+    ),
   );
 
   // Get function body ASTs
-  const bodyActions = bodiesFn(
-    ...(callTokens as FunctionRefs<TDefs>),
-  ) as Action[];
+  const bodyActions = (
+    bodiesFn(...(callTokens as FunctionRefs<TDefs>)) as Pipeable[]
+  ).map(toAction);
 
-  // Branch cases: CallN → ExtractField("value") → bodyN
+  // Branch cases: CallN → GetField("value") → bodyN
   const cases: Record<string, Action> = {};
   for (let i = 0; i < bodyActions.length; i++) {
-    cases[`Call${i}`] = chain(
-      extractField("value"),
-      bodyActions[i] as any,
-    ) as Action;
+    cases[`Call${i}`] = toAction(
+      chain(toAction(getField("value")), toAction(bodyActions[i])),
+    );
   }
 
   // Return curried entry-point combinator
   return <TOut>(entryFn: (...fns: FunctionRefs<TDefs>) => BodyResult<TOut>) => {
-    const userBody = entryFn(...(callTokens as FunctionRefs<TDefs>)) as Action;
+    const userBody = toAction(entryFn(...(callTokens as FunctionRefs<TDefs>)));
 
     return typedAction<any, TOut>(
-      chain(all(identity, constant(UNUSED_STATE)), {
-        kind: "ResumeHandle",
-        resume_handler_id: resumeHandlerId,
-        body: chain(extractIndex(0), userBody as any) as Action,
-        handler: all(
-          chain(extractIndex(0), branch(cases) as any),
-          constant(UNUSED_STATE),
-        ) as Action,
-      } as Action) as Action,
+      toAction(
+        chain(toAction(all(identity(), constant(UNUSED_STATE))), {
+          kind: "ResumeHandle",
+          resume_handler_id: resumeHandlerId,
+          body: toAction(
+            chain(toAction(getIndex(0).unwrap()), toAction(userBody)),
+          ),
+          handler: toAction(
+            all(
+              chain(toAction(getIndex(0).unwrap()), toAction(branch(cases))),
+              constant(UNUSED_STATE),
+            ),
+          ),
+        }),
+      ),
     );
   };
 }

package/src/result.ts

@@ -0,0 +1,168 @@
+import {
+  type Option as OptionT,
+  type Pipeable,
+  type Result as ResultT,
+  type ResultDef,
+  type TypedAction,
+  branch,
+} from "./ast.js";
+import { chain } from "./chain.js";
+import { constant, drop, identity, panic, tag } from "./builtins/index.js";
+import { Option } from "./option.js";
+
+// ---------------------------------------------------------------------------
+// Result namespace — combinators for Result<TValue, TError> tagged unions
+// ---------------------------------------------------------------------------
+
+export const Result = {
+  /** Tag combinator: wrap value as `Result.Ok`. `TValue → Result<TValue, TError>` */
+  ok<TValue, TError = never>(): TypedAction<TValue, ResultT<TValue, TError>> {
+    return tag<"Result", ResultDef<TValue, TError>, "Ok">("Ok", "Result");
+  },
+  /** Tag combinator: wrap value as `Result.Err`. `TError → Result<TValue, TError>` */
+  err<TValue = never, TError = unknown>(): TypedAction<
+    TError,
+    ResultT<TValue, TError>
+  > {
+    return tag<"Result", ResultDef<TValue, TError>, "Err">("Err", "Result");
+  },
+
+  /** Transform the Ok value. `Result<TValue, TError> → Result<TOut, TError>` */
+  map<TValue, TOut, TError>(
+    action: Pipeable<TValue, TOut>,
+  ): TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>> {
+    return branch({
+      Ok: chain(action, Result.ok<TOut, TError>()),
+      Err: Result.err<TOut, TError>(),
+    }) as TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>>;
+  },
+
+  /** Transform the Err value. `Result<TValue, TError> → Result<TValue, TErrorOut>` */
+  mapErr<TValue, TError, TErrorOut>(
+    action: Pipeable<TError, TErrorOut>,
+  ): TypedAction<ResultT<TValue, TError>, ResultT<TValue, TErrorOut>> {
+    return branch({
+      Ok: Result.ok<TValue, TErrorOut>(),
+      Err: chain(action, Result.err<TValue, TErrorOut>()),
+    }) as TypedAction<ResultT<TValue, TError>, ResultT<TValue, TErrorOut>>;
+  },
+
+  /**
+   * Monadic bind (flatMap) for Ok. If Ok, pass value to action which
+   * returns Result<TOut, TError>. If Err, propagate.
+   */
+  andThen<TValue, TOut, TError>(
+    action: Pipeable<TValue, ResultT<TOut, TError>>,
+  ): TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>> {
+    return branch({
+      Ok: action,
+      Err: Result.err<TOut, TError>(),
+    }) as TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>>;
+  },
+
+  /** Fallback on Err. If Ok, keep it. If Err, pass error to fallback. */
+  or<TValue, TError, TErrorOut>(
+    fallback: Pipeable<TError, ResultT<TValue, TErrorOut>>,
+  ): TypedAction<ResultT<TValue, TError>, ResultT<TValue, TErrorOut>> {
+    return branch({
+      Ok: Result.ok<TValue, TErrorOut>(),
+      Err: fallback,
+    }) as TypedAction<ResultT<TValue, TError>, ResultT<TValue, TErrorOut>>;
+  },
+
+  /**
+   * Extract the Ok value or panic. `Result<TValue, TError> → TValue`
+   *
+   * Panics (fatal, not caught by tryCatch) if the value is Err.
+   */
+  unwrap<TValue, TError>(): TypedAction<ResultT<TValue, TError>, TValue> {
+    return branch({
+      Ok: identity<TValue>(),
+      Err: panic("called unwrap on Err"),
+    }) as TypedAction<ResultT<TValue, TError>, TValue>;
+  },
+
+  /**
+   * Extract Ok or compute default from Err. `Result<TValue, TError> → TValue`
+   */
+  unwrapOr<TValue, TError>(
+    defaultAction: Pipeable<TError, TValue>,
+  ): TypedAction<ResultT<TValue, TError>, TValue> {
+    return branch({
+      Ok: identity<TValue>(),
+      Err: defaultAction,
+    }) as TypedAction<ResultT<TValue, TError>, TValue>;
+  },
+
+  /**
+   * Convert Ok to Some, Err to None. `Result<TValue, TError> → Option<TValue>`
+   */
+  asOkOption<TValue, TError>(): TypedAction<
+    ResultT<TValue, TError>,
+    OptionT<TValue>
+  > {
+    return branch({
+      Ok: Option.some<TValue>(),
+      Err: chain(drop, Option.none<TValue>()),
+    }) as TypedAction<ResultT<TValue, TError>, OptionT<TValue>>;
+  },
+
+  /**
+   * Convert Err to Some, Ok to None. `Result<TValue, TError> → Option<TError>`
+   */
+  asErrOption<TValue, TError>(): TypedAction<
+    ResultT<TValue, TError>,
+    OptionT<TError>
+  > {
+    return branch({
+      Ok: chain(drop, Option.none<TError>()),
+      Err: Option.some<TError>(),
+    }) as TypedAction<ResultT<TValue, TError>, OptionT<TError>>;
+  },
+
+  /**
+   * Swap Result/Option nesting.
+   * `Result<Option<TValue>, TError> → Option<Result<TValue, TError>>`
+   */
+  transpose<TValue, TError>(): TypedAction<
+    ResultT<OptionT<TValue>, TError>,
+    OptionT<ResultT<TValue, TError>>
+  > {
+    return branch({
+      Ok: branch({
+        Some: chain(
+          Result.ok<TValue, TError>(),
+          Option.some<ResultT<TValue, TError>>(),
+        ),
+        None: chain(drop, Option.none<ResultT<TValue, TError>>()),
+      }),
+      Err: chain(
+        Result.err<TValue, TError>(),
+        Option.some<ResultT<TValue, TError>>(),
+      ),
+    }) as TypedAction<
+      ResultT<OptionT<TValue>, TError>,
+      OptionT<ResultT<TValue, TError>>
+    >;
+  },
+
+  /**
+   * Test if the value is Ok. `Result<TValue, TError> → boolean`
+   */
+  isOk<TValue, TError>(): TypedAction<ResultT<TValue, TError>, boolean> {
+    return branch({
+      Ok: constant<boolean>(true),
+      Err: constant<boolean>(false),
+    }) as TypedAction<ResultT<TValue, TError>, boolean>;
+  },
+
+  /**
+   * Test if the value is Err. `Result<TValue, TError> → boolean`
+   */
+  isErr<TValue, TError>(): TypedAction<ResultT<TValue, TError>, boolean> {
+    return branch({
+      Ok: constant<boolean>(false),
+      Err: constant<boolean>(true),
+    }) as TypedAction<ResultT<TValue, TError>, boolean>;
+  },
+} as const;