import type { MaybePromise } from "https://esm.town/v/postpostscript/typeUtils"; export function $chain(method: InterruptibleChainMethod): InterruptibleChain; export function $chain(): InterruptibleChain; export function $chain( method?: InterruptibleChainMethod, ): InterruptibleChain | InterruptibleChain { if (!method) { const chain = $chain(() => { // never called return undefined; }); chain.index = -1; return chain; } return new InterruptibleChain(method); } export class InterruptibleChain { index = 0; parent: InterruptibleChain | undefined; method: InterruptibleChainMethod; constructor(method: InterruptibleChainMethod) { this.method = method; } then(method: InterruptibleChainMethod | InterruptibleChain): InterruptibleChain { let _method = typeof method === "object" ? subchainMethod(method) : method; const child = new InterruptibleChain(_method); if (this.index === -1) { return child; } child.index = this.index + 1; child.parent = this; return child; } init(state: InterruptibleChainState = { index: 0, value: undefined, }) { return new InterruptibleChainHandle(this, state); } } export class InterruptibleChainHandle { state: InterruptibleChainState; chain: InterruptibleChain; interrupt: Interrupt | undefined = undefined; constructor(chain: InterruptibleChain, state: InterruptibleChainState = { index: 0, value: undefined, }) { this.chain = chain; this.state = state; } get done() { return this.state.index === this.chain.index + 1; } async advance(): Promise> { if (this.done) { throw new Error("chain is complete"); } this.interrupt = undefined; let chain: InterruptibleChain = this.chain; while (this.state.index < chain.index) { chain = chain.parent!; } let value: T | Interrupt; try { value = await chain.method(this.state.value, (reason, intermediateState) => { return new Interrupt(reason, chain, intermediateState); }, this.state.intermediateState); } catch (err) { if (err instanceof Interrupt) { value = err; } else { value = new Interrupt(err, chain); } } if (value instanceof Interrupt) { this.interrupt = value; if (value.intermediateState !== undefined) { this.state.intermediateState = value.intermediateState; } else if ("intermediateState" in this.state) { delete this.state.intermediateState; } return this; } this.state.value = value; if ("intermediateState" in this.state) { delete this.state.intermediateState; } this.state.index += 1; return this; } async untilDone(): Promise< { done: true; value: T; handle: InterruptibleChainHandle; } | { done: false; interrupt: Interrupt; handle: InterruptibleChainHandle; } > { this.interrupt = undefined; while (!(this.done || this.interrupt)) { await this.advance(); } if (this.interrupt) { return { done: false, interrupt: this.interrupt, handle: this, }; } return { done: true, value: this.state.value, handle: this, }; } } export class Interrupt { reason: T; chain: InterruptibleChain; intermediateState: IntermediateState | undefined; constructor(reason: T, chain: InterruptibleChain, intermediateState?: IntermediateState) { this.reason = reason; this.chain = chain; this.intermediateState = intermediateState; } } export type IntermediateState = any; export type InterruptibleChainMethod = ( result: P, interrupt: (reason: R, intermediateState?: IntermediateState) => Interrupt, intermediateState?: IntermediateState, ) => MaybePromise; export type InterruptibleChainState = { index: number; value: any; intermediateState?: IntermediateState; }; type SubchainState = InterruptibleChainState | undefined; export function subchainMethod(chain: InterruptibleChain): InterruptibleChainMethod { return async (previous, interrupt, intermediateState: SubchainState) => { const status = await chain.init( intermediateState || { index: 0, value: previous, }, ).untilDone(); if (status.done) { return status.value; } else { return interrupt( `subchain interrupted: ${status.interrupt.reason}`, status.handle.state, ); } }; } export function join[]>( ...chains: Chains ): InterruptibleChain> { let chain: InterruptibleChain = $chain((previous) => [[], previous]); for (const subchain of chains) { chain = chain.then(async ([result, previous], interrupt, intermediateState: SubchainState) => { const value = await subchainMethod(subchain)(undefined, interrupt, intermediateState); if (value instanceof Interrupt) { return value; } return [[ ...result, value, ], undefined]; }); } chain = chain.then(([result, _]) => result); return chain as InterruptibleChain>; } export type InterruptibleChainJoinResult[], Return extends any[] = []> = List extends [infer Chain extends InterruptibleChain, ...infer Rest extends InterruptibleChain[]] ? InterruptibleChainJoinResult< Rest, [...Return, (Chain extends InterruptibleChain ? Awaited : never)] > : Return; export function append[]>( ...chains: Chains ): InterruptibleChain> { let chain = chains[0]; for (const next of chains) { chain = chain.then(next); } return chain; } export type AppendResult[]> = List extends [infer Chain extends InterruptibleChain] ? (Chain extends InterruptibleChain ? Awaited : never) : (List extends [any, ...infer Rest extends InterruptibleChain[]] ? AppendResult< Rest > : never);

interruptibleChain