effect 2.0.0-next.36 → 2.0.0-next.38

package/dist/groupBy-d11b31b1.esm.js

@@ -0,0 +1,206 @@
+import { e as isInterruptedOnly } from './Cause-5946c7a3.esm.js';
+import { s as map$2, o as of, l as unsafeFromArray } from './Chunk-4c1f4599.esm.js';
+import { m as make$1, _ as _await, s as succeed$1 } from './Deferred-9010d2ac.esm.js';
+import { w as succeed, b as as, M as gen, N as acquireRelease, k as flatMap$1, j as zipRight, r as map$1, A as forkScoped, s as sync, v as forEach, a3 as catchSomeCause, e as unit } from './Effect-ee05a487.esm.js';
+import { s as succeed$2, h as map$4 } from './Exit-666b4f01.esm.js';
+import { d as dual, p as pipe } from './Function-12511160.esm.js';
+import { b as match, e as fromNullable, m as map$3, s as some, n as none } from './Option-df40d2b9.esm.js';
+import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
+import { s as shutdown, b as bounded, o as offer, D as DequeueTypeId, d as capacity, a as size, e as awaitShutdown, i as isShutdown, f as isFull, g as isEmpty, t as take, h as takeAll, j as takeUpTo, k as takeBetween, l as takeN, p as poll, u as unbounded } from './Queue-d99be5de.esm.js';
+import { m as make$2, u as update, g as get } from './Ref-5eefaff1.esm.js';
+import { p as pipeTo, d as drain, r as runScoped, a as readWithCause, f as flatMap$2, b as fromEffect$1 } from './sink-637a9670.esm.js';
+import { ak as flatMap, aq as flattenTake, aG as fromQueue, ac as filterEffect, a_ as map, dA as zipWithIndex, d9 as unwrapScoped, dH as mapEffectSequential, dI as distributedWithDynamicCallback, ao as flattenExitOption, dJ as matchConcurrency, az as fromEffect, dK as mapEffectPar, au as toChannel } from './stream-e44fba40.esm.js';
+import { T as TakeImpl, o as of$1, c as chunk, f as failCause, e as end } from './take-0d5e0eab.esm.js';
+
+/** @internal */
+const GroupBySymbolKey = "effect/GroupBy";
+
+/** @internal */
+const GroupByTypeId = /*#__PURE__*/Symbol.for(GroupBySymbolKey);
+
+/** @internal */
+const groupByVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _K: _ => _,
+  _V: _ => _
+};
+
+/** @internal */
+const evaluate = /*#__PURE__*/dual(3, (self, f, options) => flatMap(self.grouped, ([key, queue]) => f(key, flattenTake(fromQueue(queue, {
+  shutdown: true
+}))), {
+  concurrency: "unbounded",
+  bufferSize: options?.bufferSize ?? 16
+}));
+
+/** @internal */
+const filter = /*#__PURE__*/dual(2, (self, predicate) => make(pipe(self.grouped, filterEffect(tuple => {
+  if (predicate(tuple[0])) {
+    return pipe(succeed(tuple), as(true));
+  }
+  return pipe(shutdown(tuple[1]), as(false));
+}))));
+
+/** @internal */
+const first = /*#__PURE__*/dual(2, (self, n) => make(pipe(zipWithIndex(self.grouped), filterEffect(tuple => {
+  const index = tuple[1];
+  const queue = tuple[0][1];
+  if (index < n) {
+    return pipe(succeed(tuple), as(true));
+  }
+  return pipe(shutdown(queue), as(false));
+}), map(tuple => tuple[0]))));
+
+/** @internal */
+const make = grouped => ({
+  [GroupByTypeId]: groupByVariance,
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  grouped
+});
+
+// Circular with Stream
+
+/** @internal */
+const groupBy = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self, f, options) => make(unwrapScoped(gen(function* ($) {
+  const decider = yield* $(make$1());
+  const output = yield* $(acquireRelease(bounded(options?.bufferSize ?? 16), queue => shutdown(queue)));
+  const ref = yield* $(make$2(new Map()));
+  const add = yield* $(mapEffectSequential(self, f), distributedWithDynamicCallback(options?.bufferSize ?? 16, ([key, value]) => flatMap$1(_await(decider), f => f(key, value)), exit => offer(output, exit)));
+  yield* $(succeed$1(decider, (key, _) => pipe(get(ref), map$1(map => fromNullable(map.get(key))), flatMap$1(match({
+    onNone: () => flatMap$1(add, ([index, queue]) => zipRight(update(ref, map => map.set(key, index)), pipe(offer(output, succeed$2([key, mapDequeue(queue, exit => new TakeImpl(pipe(exit, map$4(tuple => of(tuple[1])))))])), as(n => n === index)))),
+    onSome: index => succeed(n => n === index)
+  })))));
+  return flattenExitOption(fromQueue(output, {
+    shutdown: true
+  }));
+}))));
+
+/** @internal */
+const mapEffectOptions = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self, f, options) => {
+  if (options?.key) {
+    return evaluate(groupByKey(self, options.key, {
+      bufferSize: options.bufferSize
+    }), (_, s) => pipe(s, mapEffectSequential(f)));
+  }
+  return matchConcurrency(options?.concurrency, () => mapEffectSequential(self, f), n => options?.unordered ? flatMap(self, a => fromEffect(f(a)), {
+    concurrency: n
+  }) : mapEffectPar(self, n, f));
+});
+
+/** @internal */
+const bindEffect = /*#__PURE__*/dual(args => typeof args[0] !== "string", (self, tag, f, options) => mapEffectOptions(self, k => map$1(f(k), a => ({
+  ...k,
+  [tag]: a
+})), options));
+const mapDequeue = (dequeue, f) => new MapDequeue(dequeue, f);
+class MapDequeue {
+  [DequeueTypeId] = {
+    _Out: _ => _
+  };
+  constructor(dequeue, f) {
+    this.dequeue = dequeue;
+    this.f = f;
+  }
+  capacity() {
+    return capacity(this.dequeue);
+  }
+  size() {
+    return size(this.dequeue);
+  }
+  unsafeSize() {
+    return this.dequeue.unsafeSize();
+  }
+  awaitShutdown() {
+    return awaitShutdown(this.dequeue);
+  }
+  isActive() {
+    return this.dequeue.isActive();
+  }
+  isShutdown() {
+    return isShutdown(this.dequeue);
+  }
+  shutdown() {
+    return shutdown(this.dequeue);
+  }
+  isFull() {
+    return isFull(this.dequeue);
+  }
+  isEmpty() {
+    return isEmpty(this.dequeue);
+  }
+  take() {
+    return pipe(take(this.dequeue), map$1(a => this.f(a)));
+  }
+  takeAll() {
+    return pipe(takeAll(this.dequeue), map$1(map$2(a => this.f(a))));
+  }
+  takeUpTo(max) {
+    return pipe(takeUpTo(this.dequeue, max), map$1(map$2(a => this.f(a))));
+  }
+  takeBetween(min, max) {
+    return pipe(takeBetween(this.dequeue, min, max), map$1(map$2(a => this.f(a))));
+  }
+  takeN(n) {
+    return pipe(takeN(this.dequeue, n), map$1(map$2(a => this.f(a))));
+  }
+  poll() {
+    return pipe(poll(this.dequeue), map$1(map$3(a => this.f(a))));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const groupByKey = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self, f, options) => {
+  const loop = (map, outerQueue) => readWithCause({
+    onInput: input => flatMap$2(fromEffect$1(forEach(groupByIterable(input, f), ([key, values]) => {
+      const innerQueue = map.get(key);
+      if (innerQueue === undefined) {
+        return pipe(bounded(options?.bufferSize ?? 16), flatMap$1(innerQueue => pipe(sync(() => {
+          map.set(key, innerQueue);
+        }), zipRight(offer(outerQueue, of$1([key, innerQueue]))), zipRight(pipe(offer(innerQueue, chunk(values)), catchSomeCause(cause => isInterruptedOnly(cause) ? some(unit) : none()))))));
+      }
+      return catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? some(unit) : none());
+    }, {
+      discard: true
+    })), () => loop(map, outerQueue)),
+    onFailure: cause => fromEffect$1(offer(outerQueue, failCause(cause))),
+    onDone: () => pipe(fromEffect$1(pipe(forEach(map.entries(), ([_, innerQueue]) => pipe(offer(innerQueue, end), catchSomeCause(cause => isInterruptedOnly(cause) ? some(unit) : none())), {
+      discard: true
+    }), zipRight(offer(outerQueue, end)))))
+  });
+  return make(unwrapScoped(pipe(sync(() => new Map()), flatMap$1(map => pipe(acquireRelease(unbounded(), queue => shutdown(queue)), flatMap$1(queue => pipe(self, toChannel, pipeTo(loop(map, queue)), drain, runScoped, forkScoped, as(flattenTake(fromQueue(queue, {
+    shutdown: true
+  }))))))))));
+});
+
+/**
+ * A variant of `groupBy` that retains the insertion order of keys.
+ *
+ * @internal
+ */
+const groupByIterable = /*#__PURE__*/dual(2, (iterable, f) => {
+  const builder = [];
+  const iterator = iterable[Symbol.iterator]();
+  const map = new Map();
+  let next;
+  while ((next = iterator.next()) && !next.done) {
+    const value = next.value;
+    const key = f(value);
+    if (map.has(key)) {
+      const innerBuilder = map.get(key);
+      innerBuilder.push(value);
+    } else {
+      const innerBuilder = [value];
+      builder.push([key, innerBuilder]);
+      map.set(key, innerBuilder);
+    }
+  }
+  return unsafeFromArray(builder.map(tuple => [tuple[0], unsafeFromArray(tuple[1])]));
+});
+
+export { GroupByTypeId as G, groupByKey as a, bindEffect as b, first as c, make as d, evaluate as e, filter as f, groupBy as g, mapEffectOptions as m };

package/dist/groupBy-e1d3c5e8.cjs.dev.js

@@ -0,0 +1,216 @@
+'use strict';
+
+var Cause_dist_effectCause = require('./Cause-96c29074.cjs.dev.js');
+var Chunk_dist_effectChunk = require('./Chunk-bd290b8e.cjs.dev.js');
+var Deferred_dist_effectDeferred = require('./Deferred-5d5c886c.cjs.dev.js');
+var Effect_dist_effectEffect = require('./Effect-8392a3cd.cjs.dev.js');
+var Exit_dist_effectExit = require('./Exit-a23874e1.cjs.dev.js');
+var Function_dist_effectFunction = require('./Function-41ce433d.cjs.dev.js');
+var Option_dist_effectOption = require('./Option-03997d77.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('./Pipeable-4698db72.cjs.dev.js');
+var Queue_dist_effectQueue = require('./Queue-55a39179.cjs.dev.js');
+var Ref_dist_effectRef = require('./Ref-af783b72.cjs.dev.js');
+var sink = require('./sink-bb64c8a6.cjs.dev.js');
+var stream = require('./stream-7bc5bfac.cjs.dev.js');
+var take = require('./take-f87477f8.cjs.dev.js');
+
+/** @internal */
+const GroupBySymbolKey = "effect/GroupBy";
+
+/** @internal */
+const GroupByTypeId = /*#__PURE__*/Symbol.for(GroupBySymbolKey);
+
+/** @internal */
+const groupByVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _K: _ => _,
+  _V: _ => _
+};
+
+/** @internal */
+const evaluate = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, f, options) => stream.flatMap(self.grouped, ([key, queue]) => f(key, stream.flattenTake(stream.fromQueue(queue, {
+  shutdown: true
+}))), {
+  concurrency: "unbounded",
+  bufferSize: options?.bufferSize ?? 16
+}));
+
+/** @internal */
+const filter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => make(Function_dist_effectFunction.pipe(self.grouped, stream.filterEffect(tuple => {
+  if (predicate(tuple[0])) {
+    return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.succeed(tuple), Effect_dist_effectEffect.as(true));
+  }
+  return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.shutdown(tuple[1]), Effect_dist_effectEffect.as(false));
+}))));
+
+/** @internal */
+const first = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => make(Function_dist_effectFunction.pipe(stream.zipWithIndex(self.grouped), stream.filterEffect(tuple => {
+  const index = tuple[1];
+  const queue = tuple[0][1];
+  if (index < n) {
+    return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.succeed(tuple), Effect_dist_effectEffect.as(true));
+  }
+  return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.shutdown(queue), Effect_dist_effectEffect.as(false));
+}), stream.map(tuple => tuple[0]))));
+
+/** @internal */
+const make = grouped => ({
+  [GroupByTypeId]: groupByVariance,
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  },
+  grouped
+});
+
+// Circular with Stream
+
+/** @internal */
+const groupBy = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "function", (self, f, options) => make(stream.unwrapScoped(Effect_dist_effectEffect.gen(function* ($) {
+  const decider = yield* $(Deferred_dist_effectDeferred.make());
+  const output = yield* $(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(options?.bufferSize ?? 16), queue => Queue_dist_effectQueue.shutdown(queue)));
+  const ref = yield* $(Ref_dist_effectRef.make(new Map()));
+  const add = yield* $(stream.mapEffectSequential(self, f), stream.distributedWithDynamicCallback(options?.bufferSize ?? 16, ([key, value]) => Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred._await(decider), f => f(key, value)), exit => Queue_dist_effectQueue.offer(output, exit)));
+  yield* $(Deferred_dist_effectDeferred.succeed(decider, (key, _) => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(ref), Effect_dist_effectEffect.map(map => Option_dist_effectOption.fromNullable(map.get(key))), Effect_dist_effectEffect.flatMap(Option_dist_effectOption.match({
+    onNone: () => Effect_dist_effectEffect.flatMap(add, ([index, queue]) => Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.update(ref, map => map.set(key, index)), Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(output, Exit_dist_effectExit.succeed([key, mapDequeue(queue, exit => new take.TakeImpl(Function_dist_effectFunction.pipe(exit, Exit_dist_effectExit.map(tuple => Chunk_dist_effectChunk.of(tuple[1])))))])), Effect_dist_effectEffect.as(n => n === index)))),
+    onSome: index => Effect_dist_effectEffect.succeed(n => n === index)
+  })))));
+  return stream.flattenExitOption(stream.fromQueue(output, {
+    shutdown: true
+  }));
+}))));
+
+/** @internal */
+const mapEffectOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "function", (self, f, options) => {
+  if (options?.key) {
+    return evaluate(groupByKey(self, options.key, {
+      bufferSize: options.bufferSize
+    }), (_, s) => Function_dist_effectFunction.pipe(s, stream.mapEffectSequential(f)));
+  }
+  return stream.matchConcurrency(options?.concurrency, () => stream.mapEffectSequential(self, f), n => options?.unordered ? stream.flatMap(self, a => stream.fromEffect(f(a)), {
+    concurrency: n
+  }) : stream.mapEffectPar(self, n, f));
+});
+
+/** @internal */
+const bindEffect = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "string", (self, tag, f, options) => mapEffectOptions(self, k => Effect_dist_effectEffect.map(f(k), a => ({
+  ...k,
+  [tag]: a
+})), options));
+const mapDequeue = (dequeue, f) => new MapDequeue(dequeue, f);
+class MapDequeue {
+  [Queue_dist_effectQueue.DequeueTypeId] = {
+    _Out: _ => _
+  };
+  constructor(dequeue, f) {
+    this.dequeue = dequeue;
+    this.f = f;
+  }
+  capacity() {
+    return Queue_dist_effectQueue.capacity(this.dequeue);
+  }
+  size() {
+    return Queue_dist_effectQueue.size(this.dequeue);
+  }
+  unsafeSize() {
+    return this.dequeue.unsafeSize();
+  }
+  awaitShutdown() {
+    return Queue_dist_effectQueue.awaitShutdown(this.dequeue);
+  }
+  isActive() {
+    return this.dequeue.isActive();
+  }
+  isShutdown() {
+    return Queue_dist_effectQueue.isShutdown(this.dequeue);
+  }
+  shutdown() {
+    return Queue_dist_effectQueue.shutdown(this.dequeue);
+  }
+  isFull() {
+    return Queue_dist_effectQueue.isFull(this.dequeue);
+  }
+  isEmpty() {
+    return Queue_dist_effectQueue.isEmpty(this.dequeue);
+  }
+  take() {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(this.dequeue), Effect_dist_effectEffect.map(a => this.f(a)));
+  }
+  takeAll() {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeAll(this.dequeue), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.map(a => this.f(a))));
+  }
+  takeUpTo(max) {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeUpTo(this.dequeue, max), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.map(a => this.f(a))));
+  }
+  takeBetween(min, max) {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeBetween(this.dequeue, min, max), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.map(a => this.f(a))));
+  }
+  takeN(n) {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeN(this.dequeue, n), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.map(a => this.f(a))));
+  }
+  poll() {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.poll(this.dequeue), Effect_dist_effectEffect.map(Option_dist_effectOption.map(a => this.f(a))));
+  }
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const groupByKey = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "function", (self, f, options) => {
+  const loop = (map, outerQueue) => sink.readWithCause({
+    onInput: input => sink.flatMap(sink.fromEffect(Effect_dist_effectEffect.forEach(groupByIterable(input, f), ([key, values]) => {
+      const innerQueue = map.get(key);
+      if (innerQueue === undefined) {
+        return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.bounded(options?.bufferSize ?? 16), Effect_dist_effectEffect.flatMap(innerQueue => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => {
+          map.set(key, innerQueue);
+        }), Effect_dist_effectEffect.zipRight(Queue_dist_effectQueue.offer(outerQueue, take.of([key, innerQueue]))), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(innerQueue, take.chunk(values)), Effect_dist_effectEffect.catchSomeCause(cause => Cause_dist_effectCause.isInterruptedOnly(cause) ? Option_dist_effectOption.some(Effect_dist_effectEffect.unit) : Option_dist_effectOption.none()))))));
+      }
+      return Effect_dist_effectEffect.catchSomeCause(Queue_dist_effectQueue.offer(innerQueue, take.chunk(values)), cause => Cause_dist_effectCause.isInterruptedOnly(cause) ? Option_dist_effectOption.some(Effect_dist_effectEffect.unit) : Option_dist_effectOption.none());
+    }, {
+      discard: true
+    })), () => loop(map, outerQueue)),
+    onFailure: cause => sink.fromEffect(Queue_dist_effectQueue.offer(outerQueue, take.failCause(cause))),
+    onDone: () => Function_dist_effectFunction.pipe(sink.fromEffect(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.forEach(map.entries(), ([_, innerQueue]) => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(innerQueue, take.end), Effect_dist_effectEffect.catchSomeCause(cause => Cause_dist_effectCause.isInterruptedOnly(cause) ? Option_dist_effectOption.some(Effect_dist_effectEffect.unit) : Option_dist_effectOption.none())), {
+      discard: true
+    }), Effect_dist_effectEffect.zipRight(Queue_dist_effectQueue.offer(outerQueue, take.end)))))
+  });
+  return make(stream.unwrapScoped(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => new Map()), Effect_dist_effectEffect.flatMap(map => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.unbounded(), queue => Queue_dist_effectQueue.shutdown(queue)), Effect_dist_effectEffect.flatMap(queue => Function_dist_effectFunction.pipe(self, stream.toChannel, sink.pipeTo(loop(map, queue)), sink.drain, sink.runScoped, Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.as(stream.flattenTake(stream.fromQueue(queue, {
+    shutdown: true
+  }))))))))));
+});
+
+/**
+ * A variant of `groupBy` that retains the insertion order of keys.
+ *
+ * @internal
+ */
+const groupByIterable = /*#__PURE__*/Function_dist_effectFunction.dual(2, (iterable, f) => {
+  const builder = [];
+  const iterator = iterable[Symbol.iterator]();
+  const map = new Map();
+  let next;
+  while ((next = iterator.next()) && !next.done) {
+    const value = next.value;
+    const key = f(value);
+    if (map.has(key)) {
+      const innerBuilder = map.get(key);
+      innerBuilder.push(value);
+    } else {
+      const innerBuilder = [value];
+      builder.push([key, innerBuilder]);
+      map.set(key, innerBuilder);
+    }
+  }
+  return Chunk_dist_effectChunk.unsafeFromArray(builder.map(tuple => [tuple[0], Chunk_dist_effectChunk.unsafeFromArray(tuple[1])]));
+});
+
+exports.GroupByTypeId = GroupByTypeId;
+exports.bindEffect = bindEffect;
+exports.evaluate = evaluate;
+exports.filter = filter;
+exports.first = first;
+exports.groupBy = groupBy;
+exports.groupByKey = groupByKey;
+exports.make = make;
+exports.mapEffectOptions = mapEffectOptions;

package/dist/groupBy-f0a83f90.cjs.prod.js

@@ -0,0 +1,216 @@
+'use strict';
+
+var Cause_dist_effectCause = require('./Cause-384e2165.cjs.prod.js');
+var Chunk_dist_effectChunk = require('./Chunk-6cf5a8e6.cjs.prod.js');
+var Deferred_dist_effectDeferred = require('./Deferred-9d825b3b.cjs.prod.js');
+var Effect_dist_effectEffect = require('./Effect-f0659a90.cjs.prod.js');
+var Exit_dist_effectExit = require('./Exit-5691142c.cjs.prod.js');
+var Function_dist_effectFunction = require('./Function-2e6b0cda.cjs.prod.js');
+var Option_dist_effectOption = require('./Option-02025c86.cjs.prod.js');
+var Pipeable_dist_effectPipeable = require('./Pipeable-d3ec6711.cjs.prod.js');
+var Queue_dist_effectQueue = require('./Queue-de055f1c.cjs.prod.js');
+var Ref_dist_effectRef = require('./Ref-30e5ee58.cjs.prod.js');
+var sink = require('./sink-6a1db2b0.cjs.prod.js');
+var stream = require('./stream-22ea5a61.cjs.prod.js');
+var take = require('./take-05ea3c27.cjs.prod.js');
+
+/** @internal */
+const GroupBySymbolKey = "effect/GroupBy";
+
+/** @internal */
+const GroupByTypeId = /*#__PURE__*/Symbol.for(GroupBySymbolKey);
+
+/** @internal */
+const groupByVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _K: _ => _,
+  _V: _ => _
+};
+
+/** @internal */
+const evaluate = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, f, options) => stream.flatMap(self.grouped, ([key, queue]) => f(key, stream.flattenTake(stream.fromQueue(queue, {
+  shutdown: true
+}))), {
+  concurrency: "unbounded",
+  bufferSize: options?.bufferSize ?? 16
+}));
+
+/** @internal */
+const filter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => make(Function_dist_effectFunction.pipe(self.grouped, stream.filterEffect(tuple => {
+  if (predicate(tuple[0])) {
+    return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.succeed(tuple), Effect_dist_effectEffect.as(true));
+  }
+  return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.shutdown(tuple[1]), Effect_dist_effectEffect.as(false));
+}))));
+
+/** @internal */
+const first = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => make(Function_dist_effectFunction.pipe(stream.zipWithIndex(self.grouped), stream.filterEffect(tuple => {
+  const index = tuple[1];
+  const queue = tuple[0][1];
+  if (index < n) {
+    return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.succeed(tuple), Effect_dist_effectEffect.as(true));
+  }
+  return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.shutdown(queue), Effect_dist_effectEffect.as(false));
+}), stream.map(tuple => tuple[0]))));
+
+/** @internal */
+const make = grouped => ({
+  [GroupByTypeId]: groupByVariance,
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  },
+  grouped
+});
+
+// Circular with Stream
+
+/** @internal */
+const groupBy = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "function", (self, f, options) => make(stream.unwrapScoped(Effect_dist_effectEffect.gen(function* ($) {
+  const decider = yield* $(Deferred_dist_effectDeferred.make());
+  const output = yield* $(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(options?.bufferSize ?? 16), queue => Queue_dist_effectQueue.shutdown(queue)));
+  const ref = yield* $(Ref_dist_effectRef.make(new Map()));
+  const add = yield* $(stream.mapEffectSequential(self, f), stream.distributedWithDynamicCallback(options?.bufferSize ?? 16, ([key, value]) => Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred._await(decider), f => f(key, value)), exit => Queue_dist_effectQueue.offer(output, exit)));
+  yield* $(Deferred_dist_effectDeferred.succeed(decider, (key, _) => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(ref), Effect_dist_effectEffect.map(map => Option_dist_effectOption.fromNullable(map.get(key))), Effect_dist_effectEffect.flatMap(Option_dist_effectOption.match({
+    onNone: () => Effect_dist_effectEffect.flatMap(add, ([index, queue]) => Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.update(ref, map => map.set(key, index)), Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(output, Exit_dist_effectExit.succeed([key, mapDequeue(queue, exit => new take.TakeImpl(Function_dist_effectFunction.pipe(exit, Exit_dist_effectExit.map(tuple => Chunk_dist_effectChunk.of(tuple[1])))))])), Effect_dist_effectEffect.as(n => n === index)))),
+    onSome: index => Effect_dist_effectEffect.succeed(n => n === index)
+  })))));
+  return stream.flattenExitOption(stream.fromQueue(output, {
+    shutdown: true
+  }));
+}))));
+
+/** @internal */
+const mapEffectOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "function", (self, f, options) => {
+  if (options?.key) {
+    return evaluate(groupByKey(self, options.key, {
+      bufferSize: options.bufferSize
+    }), (_, s) => Function_dist_effectFunction.pipe(s, stream.mapEffectSequential(f)));
+  }
+  return stream.matchConcurrency(options?.concurrency, () => stream.mapEffectSequential(self, f), n => options?.unordered ? stream.flatMap(self, a => stream.fromEffect(f(a)), {
+    concurrency: n
+  }) : stream.mapEffectPar(self, n, f));
+});
+
+/** @internal */
+const bindEffect = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "string", (self, tag, f, options) => mapEffectOptions(self, k => Effect_dist_effectEffect.map(f(k), a => ({
+  ...k,
+  [tag]: a
+})), options));
+const mapDequeue = (dequeue, f) => new MapDequeue(dequeue, f);
+class MapDequeue {
+  [Queue_dist_effectQueue.DequeueTypeId] = {
+    _Out: _ => _
+  };
+  constructor(dequeue, f) {
+    this.dequeue = dequeue;
+    this.f = f;
+  }
+  capacity() {
+    return Queue_dist_effectQueue.capacity(this.dequeue);
+  }
+  size() {
+    return Queue_dist_effectQueue.size(this.dequeue);
+  }
+  unsafeSize() {
+    return this.dequeue.unsafeSize();
+  }
+  awaitShutdown() {
+    return Queue_dist_effectQueue.awaitShutdown(this.dequeue);
+  }
+  isActive() {
+    return this.dequeue.isActive();
+  }
+  isShutdown() {
+    return Queue_dist_effectQueue.isShutdown(this.dequeue);
+  }
+  shutdown() {
+    return Queue_dist_effectQueue.shutdown(this.dequeue);
+  }
+  isFull() {
+    return Queue_dist_effectQueue.isFull(this.dequeue);
+  }
+  isEmpty() {
+    return Queue_dist_effectQueue.isEmpty(this.dequeue);
+  }
+  take() {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(this.dequeue), Effect_dist_effectEffect.map(a => this.f(a)));
+  }
+  takeAll() {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeAll(this.dequeue), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.map(a => this.f(a))));
+  }
+  takeUpTo(max) {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeUpTo(this.dequeue, max), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.map(a => this.f(a))));
+  }
+  takeBetween(min, max) {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeBetween(this.dequeue, min, max), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.map(a => this.f(a))));
+  }
+  takeN(n) {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeN(this.dequeue, n), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.map(a => this.f(a))));
+  }
+  poll() {
+    return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.poll(this.dequeue), Effect_dist_effectEffect.map(Option_dist_effectOption.map(a => this.f(a))));
+  }
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const groupByKey = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "function", (self, f, options) => {
+  const loop = (map, outerQueue) => sink.readWithCause({
+    onInput: input => sink.flatMap(sink.fromEffect(Effect_dist_effectEffect.forEach(groupByIterable(input, f), ([key, values]) => {
+      const innerQueue = map.get(key);
+      if (innerQueue === undefined) {
+        return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.bounded(options?.bufferSize ?? 16), Effect_dist_effectEffect.flatMap(innerQueue => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => {
+          map.set(key, innerQueue);
+        }), Effect_dist_effectEffect.zipRight(Queue_dist_effectQueue.offer(outerQueue, take.of([key, innerQueue]))), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(innerQueue, take.chunk(values)), Effect_dist_effectEffect.catchSomeCause(cause => Cause_dist_effectCause.isInterruptedOnly(cause) ? Option_dist_effectOption.some(Effect_dist_effectEffect.unit) : Option_dist_effectOption.none()))))));
+      }
+      return Effect_dist_effectEffect.catchSomeCause(Queue_dist_effectQueue.offer(innerQueue, take.chunk(values)), cause => Cause_dist_effectCause.isInterruptedOnly(cause) ? Option_dist_effectOption.some(Effect_dist_effectEffect.unit) : Option_dist_effectOption.none());
+    }, {
+      discard: true
+    })), () => loop(map, outerQueue)),
+    onFailure: cause => sink.fromEffect(Queue_dist_effectQueue.offer(outerQueue, take.failCause(cause))),
+    onDone: () => Function_dist_effectFunction.pipe(sink.fromEffect(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.forEach(map.entries(), ([_, innerQueue]) => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(innerQueue, take.end), Effect_dist_effectEffect.catchSomeCause(cause => Cause_dist_effectCause.isInterruptedOnly(cause) ? Option_dist_effectOption.some(Effect_dist_effectEffect.unit) : Option_dist_effectOption.none())), {
+      discard: true
+    }), Effect_dist_effectEffect.zipRight(Queue_dist_effectQueue.offer(outerQueue, take.end)))))
+  });
+  return make(stream.unwrapScoped(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => new Map()), Effect_dist_effectEffect.flatMap(map => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.unbounded(), queue => Queue_dist_effectQueue.shutdown(queue)), Effect_dist_effectEffect.flatMap(queue => Function_dist_effectFunction.pipe(self, stream.toChannel, sink.pipeTo(loop(map, queue)), sink.drain, sink.runScoped, Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.as(stream.flattenTake(stream.fromQueue(queue, {
+    shutdown: true
+  }))))))))));
+});
+
+/**
+ * A variant of `groupBy` that retains the insertion order of keys.
+ *
+ * @internal
+ */
+const groupByIterable = /*#__PURE__*/Function_dist_effectFunction.dual(2, (iterable, f) => {
+  const builder = [];
+  const iterator = iterable[Symbol.iterator]();
+  const map = new Map();
+  let next;
+  while ((next = iterator.next()) && !next.done) {
+    const value = next.value;
+    const key = f(value);
+    if (map.has(key)) {
+      const innerBuilder = map.get(key);
+      innerBuilder.push(value);
+    } else {
+      const innerBuilder = [value];
+      builder.push([key, innerBuilder]);
+      map.set(key, innerBuilder);
+    }
+  }
+  return Chunk_dist_effectChunk.unsafeFromArray(builder.map(tuple => [tuple[0], Chunk_dist_effectChunk.unsafeFromArray(tuple[1])]));
+});
+
+exports.GroupByTypeId = GroupByTypeId;
+exports.bindEffect = bindEffect;
+exports.evaluate = evaluate;
+exports.filter = filter;
+exports.first = first;
+exports.groupBy = groupBy;
+exports.groupByKey = groupByKey;
+exports.make = make;
+exports.mapEffectOptions = mapEffectOptions;