@soundscript/soundscript 0.1.0

package/soundscript/match.sts

@@ -0,0 +1,26 @@
+export type MatchArm<TValue = unknown, TResult = unknown> = (value: TValue) => TResult;
+
+// `where(...)` is an ordinary helper value so TS/Deno consumers have a concrete implementation.
+// In the supported Soundscript pipeline, `Match(...)` consumes and strips it during macro expansion.
+export function where<TValue, TResult>(
+  arm: (value: TValue) => TResult,
+  predicate: (value: TValue) => unknown,
+): (value: TValue) => TResult {
+  return (value) => {
+    if (!predicate(value)) {
+      throw new Error(
+        'where(...) is intended for Match(...) guard arms and should be removed during Soundscript expansion.',
+      );
+    }
+    return arm(value);
+  };
+}
+
+export function Match<TArm extends MatchArm<any, any>>(
+  _value: unknown,
+  _arms: readonly [TArm, ...TArm[]],
+): ReturnType<TArm> {
+  throw new Error(
+    'Match(...) is a Soundscript macro and should be removed during Soundscript expansion.',
+  );
+}

package/soundscript/result.sts

@@ -0,0 +1,179 @@
+import { normalizeThrown } from '@soundscript/soundscript/failures';
+import { type Bind, type Kind, type Kind2, type TypeLambda } from '@soundscript/soundscript/hkt';
+import { type Applicative, type Functor, type Monad } from '@soundscript/soundscript/typeclasses';
+
+// #[variance(T: out)]
+export type Ok<T> = { readonly tag: 'ok'; readonly value: T };
+// #[variance(E: out)]
+export type Err<E> = { readonly tag: 'err'; readonly error: E };
+
+// #[variance(T: out, E: out)]
+export type Result<T, E> = Ok<T> | Err<E>;
+// #[variance(T: out)]
+export type Some<T> = Ok<T>;
+export type None = Err<void>;
+// #[variance(T: out)]
+export type Option<T> = Result<T, void>;
+
+export interface OptionF extends TypeLambda {
+  readonly type: Option<this['Args'][0]>;
+}
+
+export interface ResultF extends TypeLambda {
+  readonly type: Result<this['Args'][1], this['Args'][0]>;
+}
+
+export type OptionKind<T> = Kind<OptionF, T>;
+export type ResultKind<E, T> = Kind2<ResultF, E, T>;
+
+export function ok<T>(value: T): Result<T, never> {
+  return { tag: 'ok', value };
+}
+
+export function err(): Result<never, void>;
+export function err<E>(error: E): Result<never, E>;
+export function err<E>(error?: E): Result<never, E | void> {
+  return { tag: 'err', error };
+}
+
+export function some<T>(value: T): Option<T> {
+  return ok(value);
+}
+
+export function none(): Option<never> {
+  return err();
+}
+
+export function isOk<T, E>(value: Result<T, E>): value is Ok<T> {
+  return value.tag === 'ok';
+}
+
+export function isErr<T, E>(value: Result<T, E>): value is Err<E> {
+  return value.tag === 'err';
+}
+
+export function isSome<T>(value: Option<T>): value is Some<T> {
+  return isOk(value);
+}
+
+export function isNone<T>(value: Option<T>): value is None {
+  return isErr(value);
+}
+
+function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+  return (typeof value === 'object' || typeof value === 'function') &&
+    value !== null &&
+    'then' in value &&
+    typeof value.then === 'function';
+}
+
+export function resultOf<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
+export function resultOf<T, E>(
+  fn: () => Promise<T>,
+  mapError: (error: Error) => E,
+): Promise<Result<T, E>>;
+export function resultOf<T>(fn: () => T): Result<T, Error>;
+export function resultOf<T, E>(fn: () => T, mapError: (error: Error) => E): Result<T, E>;
+export function resultOf<T, E>(
+  fn: () => T | Promise<T>,
+  mapError?: (error: Error) => E,
+): Result<T, E | Error> | Promise<Result<T, E | Error>> {
+  try {
+    const value = fn();
+    if (isPromiseLike(value)) {
+      return Promise.resolve(value as PromiseLike<T>).then(
+        (resolved) => ok(resolved),
+        (error) => {
+          const normalized = normalizeThrown(error);
+          return err(mapError ? mapError(normalized) : normalized);
+        },
+      );
+    }
+    return ok(value);
+  } catch (error) {
+    const normalized = normalizeThrown(error);
+    return err(mapError ? mapError(normalized) : normalized);
+  }
+}
+
+function mapOption<A, B>(value: Option<A>, f: (value: A) => B): Option<B> {
+  return isOk(value) ? ok(f(value.value)) : value;
+}
+
+function apOption<A, B>(
+  fn: Option<(value: A) => B>,
+  value: Option<A>,
+): Option<B> {
+  if (!isOk(fn)) {
+    return fn;
+  }
+  return isOk(value) ? ok(fn.value(value.value)) : value;
+}
+
+function flatMapOption<A, B>(value: Option<A>, f: (value: A) => Option<B>): Option<B> {
+  return isOk(value) ? f(value.value) : value;
+}
+
+const optionMonadImpl: Monad<OptionF> = {
+  ap: apOption,
+  flatMap: flatMapOption,
+  map: mapOption,
+  pure: some,
+};
+
+export const optionFunctor: Functor<OptionF> = optionMonadImpl;
+export const optionApplicative: Applicative<OptionF> = optionMonadImpl;
+export const optionMonad: Monad<OptionF> = optionMonadImpl;
+
+function mapResult<E, A, B>(value: Result<A, E>, f: (value: A) => B): Result<B, E> {
+  return isOk(value) ? ok(f(value.value)) : value;
+}
+
+function apResult<E, A, B>(
+  fn: Result<(value: A) => B, E>,
+  value: Result<A, E>,
+): Result<B, E> {
+  if (!isOk(fn)) {
+    return fn;
+  }
+  return isOk(value) ? ok(fn.value(value.value)) : value;
+}
+
+function flatMapResult<E, A, B>(
+  value: Result<A, E>,
+  f: (value: A) => Result<B, E>,
+): Result<B, E> {
+  return isOk(value) ? f(value.value) : value;
+}
+
+function createResultMonad<E>(): Monad<Bind<ResultF, [E]>> {
+  return {
+    ap: apResult,
+    flatMap: flatMapResult,
+    map: mapResult,
+    pure: ok,
+  };
+}
+
+export function resultFunctor<E>(): Functor<Bind<ResultF, [E]>> {
+  return createResultMonad<E>();
+}
+
+export function resultApplicative<E>(): Applicative<Bind<ResultF, [E]>> {
+  return createResultMonad<E>();
+}
+
+export function resultMonad<E>(): Monad<Bind<ResultF, [E]>> {
+  return createResultMonad<E>();
+}
+
+function macroRuntimeError(name: string): never {
+  throw new Error(
+    `${name}(...) is a Soundscript macro and should be removed during Soundscript expansion.`,
+  );
+}
+
+export function Try<T, E>(value: Result<T, E>): T;
+export function Try(_value: unknown): never {
+  return macroRuntimeError('Try');
+}

package/soundscript/thunk.sts

@@ -0,0 +1,15 @@
+function macroRuntimeError(name: string): never {
+  throw new Error(
+    `${name}(...) is a Soundscript macro and should be removed during Soundscript expansion.`,
+  );
+}
+
+export function lazy<T>(_value: T): () => T;
+export function lazy(_value: unknown): never {
+  return macroRuntimeError('lazy');
+}
+
+export function memo<T>(_value: T): () => T;
+export function memo(_value: unknown): never {
+  return macroRuntimeError('memo');
+}

package/soundscript/typeclasses.sts

@@ -0,0 +1,167 @@
+import type { Binder, BoundEffect, Kind, MonadTypeLambda, TypeLambda } from '@soundscript/soundscript/hkt';
+
+export interface Contravariant<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  contramap<A, B>(value: Kind<F, A>, project: (value: B) => A): Kind<F, B>;
+}
+
+export interface Invariant<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  imap<A, B>(
+    value: Kind<F, A>,
+    decodeMap: (value: A) => B,
+    encodeMap: (value: B) => A,
+  ): Kind<F, B>;
+}
+
+export interface Functor<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  map<A, B>(value: Kind<F, A>, f: (value: A) => B): Kind<F, B>;
+}
+
+export interface Applicative<F extends TypeLambda> extends Functor<F> {
+  ap<A, B>(fn: Kind<F, (value: A) => B>, value: Kind<F, A>): Kind<F, B>;
+  pure<A>(value: A): Kind<F, A>;
+}
+
+export interface Monad<F extends TypeLambda> extends Applicative<F> {
+  flatMap<A, B>(value: Kind<F, A>, f: (value: A) => Kind<F, B>): Kind<F, B>;
+}
+
+export interface AsyncMonad<F extends TypeLambda> extends Monad<F> {
+  fromPromise<A>(promise: PromiseLike<A>): Kind<F, A>;
+}
+
+function runGenerator<F extends TypeLambda, T>(
+  monad: Monad<F>,
+  iterator: Generator<Kind<F, unknown>, T, unknown>,
+  input?: unknown,
+): Kind<F, T> {
+  const step = iterator.next(input as never);
+  if (step.done) {
+    return monad.pure(step.value);
+  }
+
+  return monad.flatMap(step.value, (nextInput) => runGenerator(monad, iterator, nextInput));
+}
+
+export function monadGen<F extends TypeLambda, T>(
+  monad: Monad<F>,
+  factory: () => Generator<Kind<F, unknown>, T, unknown>,
+): Kind<F, T> {
+  return runGenerator(monad, factory());
+}
+
+function bindValue<F extends TypeLambda>(_monad: Monad<F>) {
+  return function <A>(_effect: BoundEffect<F, A>, value: unknown): A {
+    return value as A;
+  };
+}
+
+export type DoBinder<M extends Monad<TypeLambda>> = Binder<MonadTypeLambda<M>>;
+
+class DoBindSignal<F extends TypeLambda> {
+  constructor(readonly effect: Kind<F, unknown>) {}
+}
+
+function executeDoBody<F extends TypeLambda, T>(
+  body: (bind: Binder<F>) => T,
+  resolvedValues: readonly unknown[],
+): { done: true; value: T } | { done: false; effect: Kind<F, unknown> } {
+  let index = 0;
+  const bind: Binder<F> = <A>(effect: BoundEffect<F, A>): A => {
+    if (index < resolvedValues.length) {
+      return resolvedValues[index++] as A;
+    }
+    throw new DoBindSignal(effect);
+  };
+
+  try {
+    return { done: true, value: body(bind) };
+  } catch (error) {
+    if (error instanceof DoBindSignal) {
+      return { done: false, effect: error.effect };
+    }
+    throw error;
+  }
+}
+
+async function executeAsyncDoBody<F extends TypeLambda, T>(
+  body: (bind: Binder<F>) => T | PromiseLike<T>,
+  resolvedValues: readonly unknown[],
+): Promise<{ done: true; value: T } | { done: false; effect: Kind<F, unknown> }> {
+  let index = 0;
+  const bind: Binder<F> = <A>(effect: BoundEffect<F, A>): A => {
+    if (index < resolvedValues.length) {
+      return resolvedValues[index++] as A;
+    }
+    throw new DoBindSignal(effect);
+  };
+
+  try {
+    return { done: true, value: await body(bind) };
+  } catch (error) {
+    if (error instanceof DoBindSignal) {
+      return { done: false, effect: error.effect };
+    }
+    throw error;
+  }
+}
+
+function runDo<F extends TypeLambda, T>(
+  monad: Monad<F>,
+  body: (bind: Binder<F>) => T,
+  resolvedValues: readonly unknown[] = [],
+): Kind<F, T> {
+  const step = executeDoBody(body, resolvedValues);
+  if (step.done) {
+    return monad.pure(step.value);
+  }
+  return monad.flatMap(step.effect, (value) => runDo(monad, body, [...resolvedValues, value]));
+}
+
+function runAsyncDo<F extends TypeLambda, T>(
+  monad: AsyncMonad<F>,
+  body: (bind: Binder<F>) => T | PromiseLike<T>,
+  resolvedValues: readonly unknown[] = [],
+): Kind<F, T> {
+  return monad.flatMap(
+    monad.fromPromise(executeAsyncDoBody(body, resolvedValues)),
+    (step) =>
+      step.done ? monad.pure(step.value) : monad.flatMap(
+        step.effect,
+        (value) => runAsyncDo(monad, body, [...resolvedValues, value]),
+      ),
+  );
+}
+
+export interface DoRuntime {
+  <F extends TypeLambda, T>(
+    monad: Monad<F>,
+    body: (bind: Binder<F>) => T,
+  ): Kind<F, T>;
+  <F extends TypeLambda, T>(
+    monad: AsyncMonad<F>,
+    body: (bind: Binder<F>) => T | PromiseLike<T>,
+  ): Kind<F, T>;
+  readonly macroBind: <F extends TypeLambda>(
+    monad: Monad<F>,
+  ) => <A>(effect: BoundEffect<F, A>, value: unknown) => A;
+  readonly macroGen: typeof monadGen;
+}
+
+function createDoRuntime(): DoRuntime {
+  const runtime = (<F extends TypeLambda, T>(
+    monad: Monad<F>,
+    body: (bind: Binder<F>) => T | PromiseLike<T>,
+  ): Kind<F, T> => {
+    return 'fromPromise' in monad
+      ? runAsyncDo(monad as AsyncMonad<F>, body, [])
+      : runDo(monad, body as (bind: Binder<F>) => T, []);
+  }) as DoRuntime;
+  Object.assign(runtime, { macroBind: bindValue, macroGen: monadGen });
+  return runtime;
+}
+
+// The compiler lowers `Do(...)` to `Do.macroGen(...)`, but keep a callable runtime bridge.
+export const Do = createDoRuntime();

package/thunk.d.ts

@@ -0,0 +1,2 @@
+export function lazy<T>(value: T): () => T;
+export function memo<T>(value: T): () => T;

package/thunk.js

@@ -0,0 +1,10 @@
+function macroRuntimeError(name) {
+    throw new Error(`${name}(...) is a Soundscript macro and should be removed during Soundscript expansion.`);
+}
+export function lazy(_value) {
+    return macroRuntimeError('lazy');
+}
+export function memo(_value) {
+    return macroRuntimeError('memo');
+}
+//# sourceMappingURL=thunk.js.map

package/thunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thunk.js","sourceRoot":"","sources":["./soundscript/thunk.sts"],"names":[],"mappings":"AAAA,SAAS,iBAAiB,CAAC,IAAY;IACrC,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,kFAAkF,CAC1F,CAAC;AACJ,CAAC;AAGD,MAAM,UAAU,IAAI,CAAC,MAAe;IAClC,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC;AAGD,MAAM,UAAU,IAAI,CAAC,MAAe;IAClC,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC","sourcesContent":["function macroRuntimeError(name: string): never {\n  throw new Error(\n    `${name}(...) is a Soundscript macro and should be removed during Soundscript expansion.`,\n  );\n}\n\nexport function lazy<T>(_value: T): () => T;\nexport function lazy(_value: unknown): never {\n  return macroRuntimeError('lazy');\n}\n\nexport function memo<T>(_value: T): () => T;\nexport function memo(_value: unknown): never {\n  return macroRuntimeError('memo');\n}\n"]}

package/typeclasses.d.ts

@@ -0,0 +1,57 @@
+import type { Binder, BoundEffect, Kind, MonadTypeLambda, TypeLambda } from '@soundscript/soundscript/hkt';
+
+export interface Contravariant<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  contramap<A, B>(value: Kind<F, A>, project: (value: B) => A): Kind<F, B>;
+}
+
+export interface Invariant<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  imap<A, B>(
+    value: Kind<F, A>,
+    decodeMap: (value: A) => B,
+    encodeMap: (value: B) => A,
+  ): Kind<F, B>;
+}
+
+export interface Functor<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  map<A, B>(value: Kind<F, A>, f: (value: A) => B): Kind<F, B>;
+}
+
+export interface Applicative<F extends TypeLambda> extends Functor<F> {
+  ap<A, B>(fn: Kind<F, (value: A) => B>, value: Kind<F, A>): Kind<F, B>;
+  pure<A>(value: A): Kind<F, A>;
+}
+
+export interface Monad<F extends TypeLambda> extends Applicative<F> {
+  flatMap<A, B>(value: Kind<F, A>, f: (value: A) => Kind<F, B>): Kind<F, B>;
+}
+
+export interface AsyncMonad<F extends TypeLambda> extends Monad<F> {
+  fromPromise<A>(promise: PromiseLike<A>): Kind<F, A>;
+}
+
+export function monadGen<F extends TypeLambda, T>(
+  monad: Monad<F>,
+  factory: () => Generator<Kind<F, unknown>, T, unknown>,
+): Kind<F, T>;
+
+export type DoBinder<M extends Monad<TypeLambda>> = Binder<MonadTypeLambda<M>>;
+
+export interface DoRuntime {
+  <F extends TypeLambda, T>(
+    monad: Monad<F>,
+    body: (bind: Binder<F>) => T,
+  ): Kind<F, T>;
+  <F extends TypeLambda, T>(
+    monad: AsyncMonad<F>,
+    body: (bind: Binder<F>) => T | PromiseLike<T>,
+  ): Kind<F, T>;
+  readonly macroBind: <F extends TypeLambda>(
+    monad: Monad<F>,
+  ) => <A>(effect: BoundEffect<F, A>, value: unknown) => A;
+  readonly macroGen: typeof monadGen;
+}
+
+export const Do: DoRuntime;

package/typeclasses.js

@@ -0,0 +1,78 @@
+function runGenerator(monad, iterator, input) {
+    const step = iterator.next(input);
+    if (step.done) {
+        return monad.pure(step.value);
+    }
+    return monad.flatMap(step.value, (nextInput) => runGenerator(monad, iterator, nextInput));
+}
+export function monadGen(monad, factory) {
+    return runGenerator(monad, factory());
+}
+function bindValue(_monad) {
+    return function (_effect, value) {
+        return value;
+    };
+}
+class DoBindSignal {
+    constructor(effect) {
+        this.effect = effect;
+    }
+}
+function executeDoBody(body, resolvedValues) {
+    let index = 0;
+    const bind = (effect) => {
+        if (index < resolvedValues.length) {
+            return resolvedValues[index++];
+        }
+        throw new DoBindSignal(effect);
+    };
+    try {
+        return { done: true, value: body(bind) };
+    }
+    catch (error) {
+        if (error instanceof DoBindSignal) {
+            return { done: false, effect: error.effect };
+        }
+        throw error;
+    }
+}
+async function executeAsyncDoBody(body, resolvedValues) {
+    let index = 0;
+    const bind = (effect) => {
+        if (index < resolvedValues.length) {
+            return resolvedValues[index++];
+        }
+        throw new DoBindSignal(effect);
+    };
+    try {
+        return { done: true, value: await body(bind) };
+    }
+    catch (error) {
+        if (error instanceof DoBindSignal) {
+            return { done: false, effect: error.effect };
+        }
+        throw error;
+    }
+}
+function runDo(monad, body, resolvedValues = []) {
+    const step = executeDoBody(body, resolvedValues);
+    if (step.done) {
+        return monad.pure(step.value);
+    }
+    return monad.flatMap(step.effect, (value) => runDo(monad, body, [...resolvedValues, value]));
+}
+function runAsyncDo(monad, body, resolvedValues = []) {
+    return monad.flatMap(monad.fromPromise(executeAsyncDoBody(body, resolvedValues)), (step) => step.done ? monad.pure(step.value) : monad.flatMap(step.effect, (value) => runAsyncDo(monad, body, [...resolvedValues, value])));
+}
+function createDoRuntime() {
+    const runtime = ((monad, body) => {
+        return 'fromPromise' in monad
+            ? runAsyncDo(monad, body, [])
+            : runDo(monad, body, []);
+    });
+    Object.assign(runtime, { macroBind: bindValue, macroGen: monadGen });
+    return runtime;
+}
+// The compiler lowers `Do(...)` to `Do.macroGen(...)`, but keep a callable runtime bridge.
+export const Do = createDoRuntime();
+//# sourceMappingURL=typeclasses.js.map

package/typeclasses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeclasses.js","sourceRoot":"","sources":["./soundscript/typeclasses.sts"],"names":[],"mappings":"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","sourcesContent":["import type { Binder, BoundEffect, Kind, MonadTypeLambda, TypeLambda } from '@soundscript/soundscript/hkt';\n\nexport interface Contravariant<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  contramap<A, B>(value: Kind<F, A>, project: (value: B) => A): Kind<F, B>;\n}\n\nexport interface Invariant<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  imap<A, B>(\n    value: Kind<F, A>,\n    decodeMap: (value: A) => B,\n    encodeMap: (value: B) => A,\n  ): Kind<F, B>;\n}\n\nexport interface Functor<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  map<A, B>(value: Kind<F, A>, f: (value: A) => B): Kind<F, B>;\n}\n\nexport interface Applicative<F extends TypeLambda> extends Functor<F> {\n  ap<A, B>(fn: Kind<F, (value: A) => B>, value: Kind<F, A>): Kind<F, B>;\n  pure<A>(value: A): Kind<F, A>;\n}\n\nexport interface Monad<F extends TypeLambda> extends Applicative<F> {\n  flatMap<A, B>(value: Kind<F, A>, f: (value: A) => Kind<F, B>): Kind<F, B>;\n}\n\nexport interface AsyncMonad<F extends TypeLambda> extends Monad<F> {\n  fromPromise<A>(promise: PromiseLike<A>): Kind<F, A>;\n}\n\nfunction runGenerator<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  iterator: Generator<Kind<F, unknown>, T, unknown>,\n  input?: unknown,\n): Kind<F, T> {\n  const step = iterator.next(input as never);\n  if (step.done) {\n    return monad.pure(step.value);\n  }\n\n  return monad.flatMap(step.value, (nextInput) => runGenerator(monad, iterator, nextInput));\n}\n\nexport function monadGen<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  factory: () => Generator<Kind<F, unknown>, T, unknown>,\n): Kind<F, T> {\n  return runGenerator(monad, factory());\n}\n\nfunction bindValue<F extends TypeLambda>(_monad: Monad<F>) {\n  return function <A>(_effect: BoundEffect<F, A>, value: unknown): A {\n    return value as A;\n  };\n}\n\nexport type DoBinder<M extends Monad<TypeLambda>> = Binder<MonadTypeLambda<M>>;\n\nclass DoBindSignal<F extends TypeLambda> {\n  constructor(readonly effect: Kind<F, unknown>) {}\n}\n\nfunction executeDoBody<F extends TypeLambda, T>(\n  body: (bind: Binder<F>) => T,\n  resolvedValues: readonly unknown[],\n): { done: true; value: T } | { done: false; effect: Kind<F, unknown> } {\n  let index = 0;\n  const bind: Binder<F> = <A>(effect: BoundEffect<F, A>): A => {\n    if (index < resolvedValues.length) {\n      return resolvedValues[index++] as A;\n    }\n    throw new DoBindSignal(effect);\n  };\n\n  try {\n    return { done: true, value: body(bind) };\n  } catch (error) {\n    if (error instanceof DoBindSignal) {\n      return { done: false, effect: error.effect };\n    }\n    throw error;\n  }\n}\n\nasync function executeAsyncDoBody<F extends TypeLambda, T>(\n  body: (bind: Binder<F>) => T | PromiseLike<T>,\n  resolvedValues: readonly unknown[],\n): Promise<{ done: true; value: T } | { done: false; effect: Kind<F, unknown> }> {\n  let index = 0;\n  const bind: Binder<F> = <A>(effect: BoundEffect<F, A>): A => {\n    if (index < resolvedValues.length) {\n      return resolvedValues[index++] as A;\n    }\n    throw new DoBindSignal(effect);\n  };\n\n  try {\n    return { done: true, value: await body(bind) };\n  } catch (error) {\n    if (error instanceof DoBindSignal) {\n      return { done: false, effect: error.effect };\n    }\n    throw error;\n  }\n}\n\nfunction runDo<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  body: (bind: Binder<F>) => T,\n  resolvedValues: readonly unknown[] = [],\n): Kind<F, T> {\n  const step = executeDoBody(body, resolvedValues);\n  if (step.done) {\n    return monad.pure(step.value);\n  }\n  return monad.flatMap(step.effect, (value) => runDo(monad, body, [...resolvedValues, value]));\n}\n\nfunction runAsyncDo<F extends TypeLambda, T>(\n  monad: AsyncMonad<F>,\n  body: (bind: Binder<F>) => T | PromiseLike<T>,\n  resolvedValues: readonly unknown[] = [],\n): Kind<F, T> {\n  return monad.flatMap(\n    monad.fromPromise(executeAsyncDoBody(body, resolvedValues)),\n    (step) =>\n      step.done ? monad.pure(step.value) : monad.flatMap(\n        step.effect,\n        (value) => runAsyncDo(monad, body, [...resolvedValues, value]),\n      ),\n  );\n}\n\nexport interface DoRuntime {\n  <F extends TypeLambda, T>(\n    monad: Monad<F>,\n    body: (bind: Binder<F>) => T,\n  ): Kind<F, T>;\n  <F extends TypeLambda, T>(\n    monad: AsyncMonad<F>,\n    body: (bind: Binder<F>) => T | PromiseLike<T>,\n  ): Kind<F, T>;\n  readonly macroBind: <F extends TypeLambda>(\n    monad: Monad<F>,\n  ) => <A>(effect: BoundEffect<F, A>, value: unknown) => A;\n  readonly macroGen: typeof monadGen;\n}\n\nfunction createDoRuntime(): DoRuntime {\n  const runtime = (<F extends TypeLambda, T>(\n    monad: Monad<F>,\n    body: (bind: Binder<F>) => T | PromiseLike<T>,\n  ): Kind<F, T> => {\n    return 'fromPromise' in monad\n      ? runAsyncDo(monad as AsyncMonad<F>, body, [])\n      : runDo(monad, body as (bind: Binder<F>) => T, []);\n  }) as DoRuntime;\n  Object.assign(runtime, { macroBind: bindValue, macroGen: monadGen });\n  return runtime;\n}\n\n// The compiler lowers `Do(...)` to `Do.macroGen(...)`, but keep a callable runtime bridge.\nexport const Do = createDoRuntime();\n"]}