🚿 Make batch() function in helper module deprecated

Author: lambdalisue

denops_std/helper/README.md

@@ -27,77 +27,8 @@ export async function main(denops: Denops): Promise<void> {
 
 ### batch
 
-Use `batch()` to call multiple denops functions sequentially without overhead
-and get results like:
-
-```typescript
-import { Denops } from "https://deno.land/x/denops_std/mod.ts";
-import { batch } from "https://deno.land/x/denops_std/helper/mod.ts";
-
-export async function main(denops: Denops): Promise<void> {
-  const results = await batch(denops, (helper) => {
-    helper.call("range", 2);
-    helper.cmd("echomsg 'Hello'");
-    helper.eval("v:version");
-  });
-
-  console.log(results);
-  // [
-  //   [0, 1],
-  //   0,
-  //   '800',
-  // ]
-}
-```
-
-The `helper` instance implement `Denops` interface thus users can use it as
-`denops` like:
-
-```typescript
-import { Denops } from "https://deno.land/x/denops_std/mod.ts";
-import * as fn from "https://deno.land/x/denops_std/function/mod.ts";
-import * as vars from "https://deno.land/x/denops_std/variable/mod.ts";
-import { batch } from "https://deno.land/x/denops_std/helper/mod.ts";
-
-export async function main(denops: Denops): Promise<void> {
-  const results = await batch(denops, (helper) => {
-    fn.range(helper, 2);
-    vars.v.get(helper, "version");
-  });
-
-  console.log(results);
-  // [
-  //   [0, 1],
-  //   '800',
-  // ]
-}
-```
-
-When one of function call fails during batch process, `batch` throws
-`BatchError` which contains succeeded results as `results` like:
-
-```typescript
-import { BatchError, Denops } from "https://deno.land/x/denops_std/mod.ts";
-import { batch } from "https://deno.land/x/denops_std/helper/mod.ts";
-
-export async function main(denops: Denops): Promise<void> {
-  try {
-    await batch(denops, (helper) => {
-      helper.call("range", 0);
-      helper.call("range", 1);
-      helper.call("no-such-function");
-      helper.call("range", 2);
-    });
-  } catch (e) {
-    // e is an instance of BatchErro
-    if (e instanceof BatchError) {
-      // Print succeeded results
-      console.log("Succeeded:", e.results);
-    }
-    throw e;
-  }
-}
-```
+Deprecated in favor of [`batch`](./batch/README.md) module. Use `gather()`
+function on that module instead.
 
 ### execute
 

denops_std/helper/batch.ts

@@ -1,75 +1,20 @@
-import { Context, Denops, Dispatcher, Meta } from "../deps.ts";
-
-class BatchHelper implements Denops {
-  #denops: Denops;
-  #calls: [string, ...unknown[]][];
-
-  constructor(denops: Denops) {
-    this.#denops = denops;
-    this.#calls = [];
-  }
-
-  static getCalls(helper: BatchHelper): [string, ...unknown[]][] {
-    return helper.#calls;
-  }
-
-  get name(): string {
-    return this.#denops.name;
-  }
-
-  get meta(): Meta {
-    return this.#denops.meta;
-  }
-
-  get dispatcher(): Dispatcher {
-    return this.#denops.dispatcher;
-  }
-
-  set dispatcher(dispatcher: Dispatcher) {
-    this.#denops.dispatcher = dispatcher;
-  }
-
-  call(fn: string, ...args: unknown[]): Promise<unknown> {
-    this.#calls.push([fn, ...args]);
-    return Promise.resolve();
-  }
-
-  batch(..._calls: [string, ...unknown[]][]): Promise<unknown[]> {
-    throw new Error(
-      "The 'batch' method is not available on BatchDenops instance.",
-    );
-  }
-
-  cmd(cmd: string, ctx: Context = {}): Promise<void> {
-    this.call("denops#api#cmd", cmd, ctx);
-    return Promise.resolve();
-  }
-
-  eval(expr: string, ctx: Context = {}): Promise<unknown> {
-    this.call("denops#api#eval", expr, ctx);
-    return Promise.resolve();
-  }
-
-  dispatch(name: string, fn: string, ...args: unknown[]): Promise<unknown> {
-    return this.#denops.dispatch(name, fn, ...args);
-  }
-}
+import { Denops } from "../deps.ts";
+import { gather } from "../batch/mod.ts";
+import type { GatherHelper } from "../batch/mod.ts";
 
 /**
- * Call denops functions sequentially without redraw and return the results.
- *
- * It is a wrapper function of `denops.batch()` to allow users to use `function`
- * modules, `denops.cmd()`, `denops.eval()`, or whatever things which assume a
- * `denops` instance.
+ * @deprecated Use `gather()` function in `batch` module instead.
  */
 export async function batch(
   denops: Denops,
-  main: (helper: BatchHelper) => Promise<void> | void,
+  main: (helper: GatherHelper) => Promise<void> | void,
 ): Promise<unknown[]> {
-  const helper = new BatchHelper(denops);
-  await main(helper);
-  const calls = BatchHelper.getCalls(helper);
-  return await denops.batch(...calls);
+  console.warn(
+    "DEPRECATED: Use `gather()` function in `batch` module instead.",
+  );
+  return await gather(denops, async (helper: GatherHelper) => {
+    return await main(helper);
+  });
 }
 
-export type { BatchHelper };
+export type { GatherHelper as BatchHelper };