Lift a simple function into an operation safely.

lib/lift.ts

@@ -1,3 +1,4 @@
+import { shift } from "./deps.ts";
 import { type Operation } from "./types.ts";
 
 /**
@@ -16,20 +17,17 @@ import { type Operation } from "./types.ts";
  * @returns a function returning an operation that invokes `fn` when evaluated
  */
 export function lift<TArgs extends unknown[], TReturn>(
-  fn: Fn<TArgs, TReturn>,
-): LiftedFn<TArgs, TReturn> {
+  fn: (...args: TArgs) => TReturn,
+): (...args: TArgs) => Operation<TReturn> {
   return (...args: TArgs) => {
     return ({
-      [Symbol.iterator]() {
-        let value = fn(...args);
-        return { next: () => ({ done: true, value }) };
+      *[Symbol.iterator]() {
+        return yield () => {
+          return shift(function* (k) {
+            k.tail({ ok: true, value: fn(...args) });
+          });
+        };
       },
     });
   };
 }
-
-type Fn<TArgs extends unknown[], TReturn> = (...args: TArgs) => TReturn;
-
-type LiftedFn<TArgs extends unknown[], TReturn> = (
-  ...args: TArgs
-) => Operation<TReturn>;

test/lift.test.ts

@@ -0,0 +1,23 @@
+import { createSignal, each, lift, run, sleep, spawn } from "../mod.ts";
+import { describe, expect, it } from "./suite.ts";
+
+describe("lift", () => {
+  it("safely does not continue if the call stops the operation", async () => {
+    let reached = false;
+
+    await run(function* () {
+      let signal = createSignal<void, void>();
+
+      yield* spawn(function* () {
+        yield* sleep(0);
+        yield* lift(signal.close)();
+
+        reached = true;
+      });
+
+      for (let _ of yield* each(signal));
+    });
+
+    expect(reached).toBe(false);
+  });
+});