Function foldWeightedDecomposeFold

packages/effect/src/internal/sink.ts:1170–1208

(
  input: Chunk.Chunk<In>,
  s: S,
  cost: number,
  dirty: boolean,
  max: number,
  costFn: (s: S, input: In) => number,
  decompose: (input: In) => Chunk.Chunk<In>,
  f: (s: S, input: In) => S
)

/** @internal */
const foldWeightedDecomposeFold = <In, S>(
  input: Chunk.Chunk<In>,
  s: S,
  cost: number,
  dirty: boolean,
  max: number,
  costFn: (s: S, input: In) => number,
  decompose: (input: In) => Chunk.Chunk<In>,
  f: (s: S, input: In) => S
): [S, number, boolean, Chunk.Chunk<In>] => {
  for (let index = 0; index < input.length; index++) {
    const elem = Chunk.unsafeGet(input, index)
    const prevCost = cost
    cost = cost + costFn(s, elem)
    if (cost <= max) {
      s = f(s, elem)
      dirty = true
      continue
    }
    const decomposed = decompose(elem)
    if (decomposed.length <= 1 && !dirty) {
      // If `elem` cannot be decomposed, we need to cross the `max` threshold. To
      // minimize "injury", we only allow this when we haven't added anything else
      // to the aggregate (dirty = false).
      return [f(s, elem), cost, true, Chunk.drop(input, index + 1)]
    }
    if (decomposed.length <= 1 && dirty) {
      // If the state is dirty and `elem` cannot be decomposed, we stop folding
      // and include `elem` in the leftovers.
      return [s, prevCost, dirty, Chunk.drop(input, index)]
    }
    // `elem` got decomposed, so we will recurse with the decomposed elements pushed
    // into the chunk we're processing and see if we can aggregate further.
    input = Chunk.appendAll(decomposed, Chunk.drop(input, index + 1))
    cost = prevCost
    index = -1
  }
  return [s, cost, dirty, Chunk.empty<In>()]
}

/** @internal */
export const foldWeightedDecomposeEffect = <S, In, E, R, E2, R2, E3, R3>(