Function forEach

packages/effect/src/Micro.ts:3878–3970

(iterable: Iterable<A>, f: (a: A, index: number) => Micro<B, E, R>, options?: {
  readonly concurrency?: Concurrency | undefined
  readonly discard?: boolean | undefined
})

    readonly discard: true
  }): Micro<void, E, R>
} = <
  A,
  B,
  E,
  R
>(iterable: Iterable<A>, f: (a: A, index: number) => Micro<B, E, R>, options?: {
  readonly concurrency?: Concurrency | undefined
  readonly discard?: boolean | undefined
}): Micro<any, E, R> =>
  withMicroFiber((parent) => {
    const concurrencyOption = options?.concurrency === "inherit"
      ? parent.getRef(CurrentConcurrency)
      : options?.concurrency ?? 1
    const concurrency = concurrencyOption === "unbounded"
      ? Number.POSITIVE_INFINITY
      : Math.max(1, concurrencyOption)

    const items = Arr.fromIterable(iterable)
    let length = items.length
    if (length === 0) {
      return options?.discard ? void_ : succeed([])
    }

    const out: Array<B> | undefined = options?.discard ? undefined : new Array(length)
    let index = 0

    if (concurrency === 1) {
      return as(
        whileLoop({
          while: () => index < items.length,
          body: () => f(items[index], index),
          step: out ?
            (b) => out[index++] = b :
            (_) => index++
        }),
        out as any
      )
    }
    return async((resume) => {
      const fibers = new Set<MicroFiber<unknown, unknown>>()
      let result: MicroExit<any, any> | undefined = undefined
      let inProgress = 0
      let doneCount = 0
      let pumping = false
      let interrupted = false
      function pump() {
        pumping = true
        while (inProgress < concurrency && index < length) {
          const currentIndex = index
          const item = items[currentIndex]
          index++
          inProgress++
          try {
            const child = unsafeFork(parent, f(item, currentIndex), true, true)
            fibers.add(child)
            child.addObserver((exit) => {
              fibers.delete(child)
              if (interrupted) {