#mizchi/process_pool

moon add mizchi/process_pool

#Features

• Run multiple external processes in parallel with configurable concurrency limits
• Timeout support for individual jobs
• Callback support for job completion notifications
• Cross-platform:
  • native: moonbitlang/async
  • Semaphore-based concurrency control
  • js: node:child_process
  • wasm, wasm-gc with WASI

#Usage

#Basic Example

let pool = @process_pool.ProcessPool::new(max_workers=4)
let results = pool.run_all([
  @process_pool.job("echo", ["hello"]),
  @process_pool.job("echo", ["world"]),
])

assert_eq(results.length(), 2)
assert_eq(results[0].exit_code, 0)
assert_eq(results[1].exit_code, 0)

#With Timeout

let pool = @process_pool.ProcessPool::new(max_workers=2)
let results = pool.run_all([
  @process_pool.job("sleep", ["10"], timeout=100),  // 100ms timeout
])

assert_eq(results.length(), 1)
assert_true(results[0].timed_out)

#With Error Checking

let pool = @process_pool.ProcessPool::new(max_workers=2)
let mut caught = false

// Raises JobError if any job fails
ignore(pool.run_all_checked([
  @process_pool.job("echo", ["hello"]),
  @process_pool.job("false", []),  // This will fail
])) catch {
  @process_pool.JobError::ProcessFailed(..) => {
    caught = true
  }
  _ => ()
}

assert_true(caught)

#With Completion Callback

let count = @ref.new(0)
let callback = @process_pool.OnJobComplete(fn(_result) {
  count.update(fn(n) { n + 1 })
})

let pool = @process_pool.ProcessPool::new(
  max_workers=4,
  on_complete=callback,
)

let results = pool.run_all([
  @process_pool.job("echo", ["task1"]),
  @process_pool.job("echo", ["task2"]),
])

assert_eq(results.length(), 2)
assert_eq(count.val, 2)

#Map Pattern (for SSG, batch processing, etc.)

let pool = @process_pool.ProcessPool::new(max_workers=4)
let items = ["a", "b", "c"]

let results = pool.map(items, fn(item) {
  @process_pool.job("echo", [item])
})

assert_eq!(results.length(), 3)
for result in results {
  assert_eq(result.exit_code, 0)
}

#API

#Types

#Job

///|
let _a : @process_pool.Job = @process_pool.job("echo", ["hello"])

#JobResult

#JobError

#Functions

#job(cmd, args, cwd?, timeout?) -> Job

#ProcessPool::new(max_workers~ = 4, on_complete?) -> ProcessPool

#ProcessPool::run_all(jobs) -> Array[JobResult]

#ProcessPool::run_all_checked(jobs) -> Array[JobResult]

#ProcessPool::map(items, to_job) -> Array[JobResult]

#now() -> Int64

#Benchmark

#Running the Benchmark

# 1. Generate test documents (16 files, ~5000 words each)
node example/scripts/generate_docs.mjs

# 2. Run the benchmark
cd example && moon run --target native .

#Results

#Platform Support

#JS Semaphore Behavior Note

#License