effect 4.0.0-beta.5 → 4.0.0-beta.50

package/dist/Stream.js

@@ -6,18 +6,19 @@ import * as Arr from "./Array.js";
 import * as Cause from "./Cause.js";
 import * as Channel from "./Channel.js";
 import { Clock } from "./Clock.js";
+import * as Context from "./Context.js";
 import * as Duration from "./Duration.js";
 import * as Effect from "./Effect.js";
 import * as Equal from "./Equal.js";
 import * as ExecutionPlan from "./ExecutionPlan.js";
 import * as Exit from "./Exit.js";
 import * as Fiber from "./Fiber.js";
-import * as Filter from "./Filter.js";
 import { constant, constTrue, constVoid, dual, identity } from "./Function.js";
 import * as internalExecutionPlan from "./internal/executionPlan.js";
 import * as internal from "./internal/stream.js";
 import { addSpanStackTrace } from "./internal/tracer.js";
 import * as Iterable from "./Iterable.js";
+import * as Latch from "./Latch.js";
 import * as MutableHashMap from "./MutableHashMap.js";
 import * as MutableList from "./MutableList.js";
 import * as Option from "./Option.js";
@@ -29,10 +30,13 @@ import * as RcRef from "./RcRef.js";
 import * as Result from "./Result.js";
 import * as Schedule from "./Schedule.js";
 import * as Scope from "./Scope.js";
-import * as ServiceMap from "./ServiceMap.js";
 import * as Sink from "./Sink.js";
 import { isString } from "./String.js";
-const TypeId = "~effect/Stream";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const TypeId = "~effect/Stream";
 /**
  * Checks whether a value is a Stream.
  *
@@ -119,6 +123,76 @@ export const fromChannel = internal.fromChannel;
  * @category Constructors
  */
 export const fromEffect = effect => fromChannel(Channel.fromEffect(Effect.map(effect, Arr.of)));
+/**
+ * Accesses a service from the context and emits it as a single element.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Context, Stream } from "effect"
+ *
+ * class Greeter extends Context.Service<Greeter, {
+ *   readonly greet: (name: string) => string
+ * }>()("Greeter") {}
+ *
+ * const stream = Stream.service(Greeter).pipe(
+ *   Stream.map((greeter) => greeter.greet("World"))
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   return yield* stream.pipe(
+ *     Stream.provideService(Greeter, {
+ *       greet: (name) => `Hello, ${name}!`
+ *     }),
+ *     Stream.runCollect
+ *   )
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output: [ "Hello, World!" ]
+ * ```
+ *
+ * @since 4.0.0
+ * @category Context
+ */
+export const service = service => fromEffect(Effect.service(service));
+/**
+ * Optionally accesses a service from the context and emits the result as a
+ * single element.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option, Context, Stream } from "effect"
+ *
+ * class Greeter extends Context.Service<Greeter, {
+ *   readonly greet: (name: string) => string
+ * }>()("Greeter") {}
+ *
+ * const stream = Stream.serviceOption(Greeter).pipe(
+ *   Stream.map((maybeGreeter) =>
+ *     Option.match(maybeGreeter, {
+ *       onNone: () => "No greeter",
+ *       onSome: (greeter) => greeter.greet("World")
+ *     })
+ *   )
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   return yield* stream.pipe(
+ *     Stream.provideService(Greeter, {
+ *       greet: (name) => `Hello, ${name}!`
+ *     }),
+ *     Stream.runCollect
+ *   )
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output: [ "Hello, World!" ]
+ * ```
+ *
+ * @since 4.0.0
+ * @category Context
+ */
+export const serviceOption = service => fromEffect(Effect.serviceOption(service));
 /**
  * Creates a stream that runs the effect and emits no elements.
  *
@@ -667,6 +741,10 @@ export const fromIteratorSucceed = (iterator, maxChunkSize) => fromChannel(Chann
 /**
  * Creates a new `Stream` from an iterable collection of values.
  *
+ * **Options**
+ *
+ * - `chunkSize`: Maximum number of values emitted per chunk.
+ *
  * @example
  * ```ts
  * import { Console, Effect, Stream } from "effect"
@@ -686,15 +764,15 @@ export const fromIteratorSucceed = (iterator, maxChunkSize) => fromChannel(Chann
  * @since 2.0.0
  * @category Constructors
  */
-export const fromIterable = iterable => Array.isArray(iterable) ? fromArray(iterable) : fromChannel(Channel.fromIterableArray(iterable));
+export const fromIterable = (iterable, options) => Array.isArray(iterable) && options?.chunkSize === undefined ? fromArray(iterable) : fromChannel(Channel.fromIterableArray(iterable, options?.chunkSize));
 /**
  * Creates a stream from an effect producing an iterable of values.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class UserRepo extends ServiceMap.Service<UserRepo, {
+ * class UserRepo extends Context.Service<UserRepo, {
  *   readonly list: Effect.Effect<ReadonlyArray<string>>
  * }>()("UserRepo") {}
  *
@@ -927,7 +1005,9 @@ export const fromPubSubTake = pubsub => fromChannel(Channel.fromPubSubTake(pubsu
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Data, Effect, Stream } from "effect"
+ *
+ * class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
  *
  * const readableStream = new ReadableStream({
  *   start(controller) {
@@ -941,7 +1021,7 @@ export const fromPubSubTake = pubsub => fromChannel(Channel.fromPubSubTake(pubsu
  * const program = Effect.gen(function*() {
  *   const stream = Stream.fromReadableStream({
  *     evaluate: () => readableStream,
- *     onError: (error) => new Error(String(error))
+ *     onError: (cause) => new StreamError({ cause })
  *   })
  *   const values = yield* Stream.runCollect(stream)
  *   yield* Console.log(values)
@@ -970,7 +1050,9 @@ export const fromReadableStream = options => fromChannel(Channel.fromTransform(E
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Data, Effect, Stream } from "effect"
+ *
+ * class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
  *
  * const iterable = (async function*() {
  *   yield 1
@@ -979,7 +1061,7 @@ export const fromReadableStream = options => fromChannel(Channel.fromTransform(E
  * })()
  *
  * const program = Effect.gen(function*() {
- *   const stream = Stream.fromAsyncIterable(iterable, (error) => new Error(String(error)))
+ *   const stream = Stream.fromAsyncIterable(iterable, (cause) => new StreamError({ cause }))
  *   const values = yield* Stream.runCollect(stream)
  *   yield* Console.log(values)
  * })
@@ -1002,7 +1084,7 @@ export const fromAsyncIterable = (iterable, onError) => fromChannel(Channel.from
  *
  * const program = Effect.gen(function*() {
  *   const schedule = Schedule.spaced("50 millis").pipe(
- *     Schedule.compose(Schedule.recurs(2))
+ *     Schedule.both(Schedule.recurs(2))
  *   )
  *   const stream = Stream.fromSchedule(schedule)
  *   const values = yield* Stream.runCollect(stream)
@@ -1588,8 +1670,8 @@ export const tapBoth = /*#__PURE__*/dual(2, (self, options) => self.pipe(tapErro
  * @category Sequencing
  */
 export const tapSink = /*#__PURE__*/dual(2, (self, sink) => transformPullBracket(self, Effect.fnUntraced(function* (pull, _, scope) {
-  const upstreamLatch = Effect.makeLatchUnsafe();
-  const sinkLatch = Effect.makeLatchUnsafe();
+  const upstreamLatch = Latch.makeUnsafe();
+  const sinkLatch = Latch.makeUnsafe();
   let chunk = undefined;
   let causeSink = undefined;
   let sinkDone = false;
@@ -1851,10 +1933,52 @@ export const schedule = /*#__PURE__*/dual(2, (self, schedule) => self.channel.pi
  * @since 2.0.0
  * @category Rate Limiting
  */
-export const timeout = /*#__PURE__*/dual(2, (self, duration) => transformPull(self, (pull, _scope) => Effect.succeed(Effect.timeoutOrElse(pull, {
+export const timeout = /*#__PURE__*/dual(2, (self, duration) => timeoutOrElse(self, {
   duration,
-  onTimeout: () => Cause.done()
-}))));
+  orElse: () => empty
+}));
+/**
+ * @since 2.0.0
+ * @category Rate Limiting
+ */
+export const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => {
+  const duration = Duration.fromInputUnsafe(options.duration);
+  if (!Duration.isFinite(duration)) return self;
+  if (Duration.isZero(duration)) return suspend(options.orElse);
+  const timeoutSymbol = Symbol();
+  return catchCause(suspend(() => {
+    const parent = Fiber.getCurrent();
+    const clock = parent.getRef(Clock);
+    const durationMs = Duration.toMillis(duration);
+    let deadline = undefined;
+    const latch = Latch.makeUnsafe(false);
+    return merge(transformPull(self, (pull, _scope) => Effect.suspend(() => {
+      deadline = clock.currentTimeMillisUnsafe() + durationMs;
+      latch.openUnsafe();
+      return pull;
+    }).pipe(Effect.map(arr => {
+      latch.closeUnsafe();
+      deadline = undefined;
+      return arr;
+    }), Effect.succeed)), fromEffectDrain(Effect.gen(function* () {
+      while (true) {
+        yield* latch.await;
+        if (deadline === undefined) continue;
+        yield* Effect.sleep(deadline - clock.currentTimeMillisUnsafe());
+        if (deadline === undefined) continue;
+        const remaining = deadline - clock.currentTimeMillisUnsafe();
+        if (remaining > 0) continue;
+        return yield* Effect.die(timeoutSymbol);
+      }
+    })), {
+      haltStrategy: "left"
+    });
+  }), cause => {
+    const isTimeout = cause.reasons.find(r => r._tag === "Die" && r.defect === timeoutSymbol);
+    if (isTimeout) return options.orElse();
+    return failCause(cause);
+  });
+});
 /**
  * Repeats each element of the stream according to the provided schedule,
  * including the original emission.
@@ -2040,7 +2164,7 @@ export const prepend = /*#__PURE__*/dual(2, (self, values) => concat(fromIterabl
  * @since 2.0.0
  * @category Merging
  */
-export const merge = /*#__PURE__*/dual(2, (self, that, options) => fromChannel(Channel.merge(toChannel(self), toChannel(that), options)));
+export const merge = /*#__PURE__*/dual(args => isStream(args[0]) && isStream(args[1]), (self, that, options) => fromChannel(Channel.merge(toChannel(self), toChannel(that), options)));
 /**
  * Merges this stream with a background effect, keeping the stream's elements.
  *
@@ -2647,7 +2771,7 @@ export const zipWithPreviousAndNext = self => mapAccumArray(self, () => ({
 export const zipLatestAll = (...streams) => fromChannel(Channel.suspend(() => {
   const latest = [];
   const emitted = new Set();
-  const readyLatch = Effect.makeLatchUnsafe();
+  const readyLatch = Latch.makeUnsafe();
   return Channel.mergeAll(Channel.fromArray(streams.map((s, i) => s.channel.pipe(Channel.flattenArray, Channel.mapEffect(a => {
     latest[i] = a;
     if (!emitted.has(i)) {
@@ -2807,19 +2931,22 @@ export const race = /*#__PURE__*/dual(2, (left, right) => raceAll(left, right));
  * @since 2.0.0
  * @category Filtering
  */
-export const filter = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterArray(toChannel(self), filter)));
+export const filter = /*#__PURE__*/dual(2, (self, predicate) => fromChannel(Channel.filterArray(toChannel(self), predicate)));
 /**
- * Effectfully filters and maps elements in a single pass.
+ * Filters and maps stream elements in one pass using a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMap = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterMapArray(toChannel(self), filter)));
+/**
+ * Effectfully filters elements in a single pass.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
- *
- * const filter = Filter.makeEffect((n: number) =>
- *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
- * )
+ * import { Console, Effect, Stream } from "effect"
  *
- * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+ * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
  *
  * const program = Effect.gen(function*() {
  *   const result = yield* Stream.runCollect(stream)
@@ -2827,27 +2954,32 @@ export const filter = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel
  * })
  *
  * Effect.runPromise(program)
- * // Output: [ 4, 5 ]
+ * // Output: [ 3, 4 ]
  * ```
  *
  * @since 2.0.0
  * @category Filtering
  */
-export const filterEffect = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterArrayEffect(toChannel(self), filter)));
+export const filterEffect = /*#__PURE__*/dual(2, (self, predicate) => fromChannel(Channel.filterArrayEffect(toChannel(self), predicate)));
 /**
- * Partitions a stream using a Filter and exposes passing and failing values as queues.
+ * Effectfully filters and maps elements in a single pass.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapEffect = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterMapArrayEffect(toChannel(self), filter)));
+/**
+ * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
  *
  * Each queue fails with the stream error or `Cause.Done` when the source ends.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
- *     Stream.partitionQueue(
- *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
- *     )
+ *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
  *   )
  *
  *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -2875,11 +3007,19 @@ export const partitionQueue = /*#__PURE__*/dual(args => isStream(args[0]), /*#__
   const fails = yield* Queue.make({
     capacity
   });
-  const partitionArr = Arr.partition(filter);
   yield* Effect.gen(function* () {
     while (true) {
       const chunk = yield* pull;
-      const [excluded, satisfying] = partitionArr(chunk);
+      const excluded = [];
+      const satisfying = [];
+      for (let i = 0; i < chunk.length; i++) {
+        const result = filter(chunk[i]);
+        if (Result.isFailure(result)) {
+          excluded.push(result.failure);
+        } else {
+          satisfying.push(result.success);
+        }
+      }
       let passFiber = undefined;
       if (satisfying.length > 0) {
         const leftover = Queue.offerAllUnsafe(passes, satisfying);
@@ -2903,38 +3043,14 @@ export const partitionQueue = /*#__PURE__*/dual(args => isStream(args[0]), /*#__
   return [passes, fails];
 }));
 /**
- * Splits a stream using an effectful filter, producing pass and fail streams.
+ * Splits a stream using an effectful `Filter`, producing pass and fail streams.
  *
  * @since 4.0.0
  * @category Filtering
- *
- * @example
- * ```ts
- * import { Console, Effect, Result, Stream } from "effect"
- *
- * const program = Effect.scoped(
- *   Effect.gen(function*() {
- *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
- *       Stream.partitionEffect((n) =>
- *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- *       )
- *     )
- *     const result = yield* Effect.all({
- *       evens: Stream.runCollect(evens),
- *       odds: Stream.runCollect(odds)
- *     })
- *     yield* Console.log(result)
- *   })
- * )
- *
- * Effect.runPromise(program)
- * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
- * ```
  */
-export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(self.pipe(mapEffect(filter, options), partitionQueue(identity, options)), ([passes, fails]) => [fromQueue(passes), fromQueue(fails)]));
+export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(mapEffect(self, a => filter(a), options), result => result, options), ([passes, fails]) => [fromQueue(passes), fromQueue(fails)]));
 /**
- * Splits a stream into excluded and satisfying substreams using a predicate,
- * refinement, or Filter.
+ * Splits a stream into excluded and satisfying substreams using a `Filter`.
  *
  * The faster stream may advance up to `bufferSize` elements ahead of the slower
  * one.
@@ -2944,12 +3060,12 @@ export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [excluded, satisfying] = yield* Stream.partition(
  *     Stream.make(1, 2, 3, 4),
- *     (n) => n % 2 === 0
+ *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
  *   )
  *   const left = yield* Stream.runCollect(excluded)
  *   const right = yield* Stream.runCollect(satisfying)
@@ -2960,9 +3076,9 @@ export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  * })
  * ```
  */
-export const partition = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(filter, {
+export const partition = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(self, filter, {
   capacity: options?.bufferSize ?? 16
-})(self), ([passes, fails]) => [fromQueue(fails), fromQueue(passes)]));
+}), ([passes, fails]) => [fromQueue(fails), fromQueue(passes)]));
 /**
  * Returns the specified stream if the given condition is satisfied, otherwise
  * returns an empty stream.
@@ -3218,7 +3334,7 @@ catch_ as catch };
  */
 export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Channel.tapError(f), fromChannel));
 /**
- * Recovers from errors that match a filter by switching to a recovery stream.
+ * Recovers from errors that match a predicate by switching to a recovery stream.
  *
  * When a failure matches the filter, the stream switches to the recovery
  * stream. Non-matching failures propagate downstream, so the error type is
@@ -3232,12 +3348,12 @@ export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Chan
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Stream } from "effect"
+ * import { Console, Effect, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2).pipe(
  *   Stream.concat(Stream.fail(42)),
  *   Stream.catchIf(
- *     Filter.fromPredicate((error): error is 42 => error === 42),
+ *     (error): error is 42 => error === 42,
  *     () => Stream.make(999)
  *   )
  * )
@@ -3254,7 +3370,15 @@ export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Chan
  * @since 4.0.0
  * @category Error Handling
  */
-export const catchIf = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, f, orElse) => fromChannel(Channel.catchIf(toChannel(self), filter, e => f(e).channel, orElse && (e => orElse(e).channel))));
+export const catchIf = /*#__PURE__*/dual(args => isStream(args[0]), (self, predicate, f, orElse) => fromChannel(Channel.catchIf(toChannel(self), predicate, e => f(e).channel, orElse && (e => orElse(e).channel))));
+/**
+ * Recovers from errors that match a `Filter` by switching to a recovery
+ * stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const catchFilter = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, f, orElse) => fromChannel(Channel.catchFilter(toChannel(self), filter, e => f(e).channel, orElse && (e => orElse(e).channel))));
 /**
  * Recovers from failures whose `_tag` matches the provided value by switching to
  * the stream returned by `f`.
@@ -3330,7 +3454,7 @@ export const catchTag = /*#__PURE__*/dual(args => isStream(args[0]), (self, k, f
  */
 export const catchTags = /*#__PURE__*/dual(args => isStream(args[0]), (self, cases, orElse) => {
   let keys;
-  return catchIf(self, e => {
+  return catchFilter(self, e => {
     keys ??= Object.keys(cases);
     return hasProperty(e, "_tag") && isString(e["_tag"]) && keys.includes(e["_tag"]) ? Result.succeed(e) : Result.fail(e);
   }, e => cases[e["_tag"]](e), orElse);
@@ -3378,7 +3502,7 @@ export const catchTags = /*#__PURE__*/dual(args => isStream(args[0]), (self, cas
  * @since 4.0.0
  * @category Error Handling
  */
-export const catchReason = /*#__PURE__*/dual(args => isStream(args[0]), (self, errorTag, reasonTag, f, orElse) => fromChannel(Channel.catchReason(toChannel(self), errorTag, reasonTag, reason => f(reason).channel, orElse && (reason => orElse(reason).channel))));
+export const catchReason = /*#__PURE__*/dual(args => isStream(args[0]), (self, errorTag, reasonTag, f, orElse) => fromChannel(Channel.catchReason(toChannel(self), errorTag, reasonTag, (reason, error) => f(reason, error).channel, orElse && ((reason, error) => orElse(reason, error).channel))));
 /**
  * Catches multiple reasons within a tagged error using an object of handlers.
  *
@@ -3424,9 +3548,9 @@ export const catchReasons = /*#__PURE__*/dual(args => isStream(args[0]), (self,
   const handlers = {};
   for (const key of Object.keys(cases)) {
     const handler = cases[key];
-    handlers[key] = reason => handler(reason).channel;
+    handlers[key] = (reason, error) => handler(reason, error).channel;
   }
-  const orElseHandler = orElse && (reason => orElse(reason).channel);
+  const orElseHandler = orElse && ((reason, error) => orElse(reason, error).channel);
   return fromChannel(Channel.catchReasons(self.channel, errorTag, handlers, orElseHandler));
 });
 /**
@@ -3486,7 +3610,15 @@ export const mapError = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.ma
  * @since 4.0.0
  * @category Error Handling
  */
-export const catchCauseIf = /*#__PURE__*/dual(3, (self, filter, f) => fromChannel(Channel.catchCauseIf(self.channel, filter, (failure, cause) => f(failure, cause).channel)));
+export const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => fromChannel(Channel.catchCauseIf(self.channel, predicate, cause => f(cause).channel)));
+/**
+ * Recovers from stream failures by filtering the `Cause` and switching to a
+ * recovery stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const catchCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => fromChannel(Channel.catchCauseFilter(self.channel, filter, (failure, cause) => f(failure, cause).channel)));
 /**
  * Switches to a fallback stream if this stream is empty.
  *
@@ -3656,9 +3788,9 @@ export const retry = /*#__PURE__*/dual(2, (self, policy) => fromChannel(Channel.
  *
  * @example
  * ```ts
- * import { Console, Effect, ExecutionPlan, Layer, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, ExecutionPlan, Layer, Context, Stream } from "effect"
  *
- * class Service extends ServiceMap.Service<Service>()("Service", {
+ * class Service extends Context.Service<Service>()("Service", {
  *   make: Effect.succeed({
  *     stream: Stream.fail("A") as Stream.Stream<number, string>
  *   })
@@ -3900,13 +4032,34 @@ export const takeUntilEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  * @since 2.0.0
  * @category Filtering
  */
-export const takeWhile = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+export const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {
   let i = 0;
   let done = false;
   const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {
     const out = [];
     for (let j = 0; j < chunk.length; j++) {
-      const result = Filter.apply(f, chunk[j], i++);
+      if (!predicate(chunk[j], i++)) {
+        done = true;
+        break;
+      }
+      out.push(chunk[j]);
+    }
+    return Arr.isReadonlyArrayNonEmpty(out) ? Effect.succeed(out) : done ? Cause.done() : pump;
+  });
+  return pump;
+})));
+/**
+ * Takes the longest initial prefix of elements that satisfy the filter.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const takeWhileFilter = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+  let done = false;
+  const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {
+    const out = [];
+    for (let j = 0; j < chunk.length; j++) {
+      const result = filter(chunk[j]);
       if (Result.isFailure(result)) {
         done = true;
         break;
@@ -4043,11 +4196,27 @@ export const dropUntilEffect = /*#__PURE__*/dual(2, (self, predicate) => drop(dr
  * @since 2.0.0
  * @category Filtering
  */
-export const dropWhile = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+export const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {
   let dropping = true;
   let index = 0;
   const filtered = Effect.flatMap(pull, arr => {
-    const found = arr.findIndex(a => Result.isFailure(Filter.apply(f, a, index++)));
+    const found = arr.findIndex(a => !predicate(a, index++));
+    if (found === -1) return filtered;
+    dropping = false;
+    return Effect.succeed(arr.slice(found));
+  });
+  return Effect.suspend(() => dropping ? filtered : pull);
+})));
+/**
+ * Drops elements while the filter succeeds.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const dropWhileFilter = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+  let dropping = true;
+  const filtered = Effect.flatMap(pull, arr => {
+    const found = arr.findIndex(a => Result.isFailure(filter(a)));
     if (found === -1) return filtered;
     dropping = false;
     return Effect.succeed(arr.slice(found));
@@ -4639,13 +4808,13 @@ export const scanEffect = /*#__PURE__*/dual(3, (self, initial, f) => self.channe
  */
 export const debounce = /*#__PURE__*/dual(2, (self, duration) => transformPull(self, Effect.fnUntraced(function* (pull, scope) {
   const clock = yield* Clock;
-  const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration));
+  const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));
   let lastArr;
   let cause;
   let emitAtMs = Infinity;
-  const pullLatch = Effect.makeLatchUnsafe();
-  const emitLatch = Effect.makeLatchUnsafe();
-  const endLatch = Effect.makeLatchUnsafe();
+  const pullLatch = Latch.makeUnsafe();
+  const emitLatch = Latch.makeUnsafe();
+  const endLatch = Latch.makeUnsafe();
   yield* pull.pipe(pullLatch.whenOpen, Effect.flatMap(arr => {
     emitLatch.openUnsafe();
     lastArr = arr;
@@ -4736,7 +4905,7 @@ export const throttleEffect = /*#__PURE__*/dual(2, (self, options) => {
   return throttleShapeEffect(self, options.cost, options.units, options.duration, burst);
 });
 const throttleEnforceEffect = (self, cost, units, duration, burst) => transformPull(self, pull => Effect.clockWith(clock => {
-  const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration));
+  const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));
   const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;
   let tokens = units;
   let timestampMs = clock.currentTimeMillisUnsafe();
@@ -4758,7 +4927,7 @@ const throttleEnforceEffect = (self, cost, units, duration, burst) => transformP
   }));
 }));
 const throttleShapeEffect = (self, cost, units, duration, burst) => transformPull(self, pull => Effect.clockWith(clock => {
-  const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration));
+  const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));
   const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;
   let tokens = units;
   let timestampMs = clock.currentTimeMillisUnsafe();
@@ -5125,15 +5294,13 @@ export const aggregate = /*#__PURE__*/dual(2, (self, sink) => aggregateWithin(se
  */
 export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fromChannel(Channel.fromTransformBracket(Effect.fnUntraced(function* (_upstream, _, scope) {
   const pull = yield* Channel.toPullScoped(self.channel, _);
-  const pullLatch = Effect.makeLatchUnsafe(false);
+  const pullLatch = Latch.makeUnsafe(false);
   const scheduleStep = Symbol();
   const buffer = yield* Queue.make({
     capacity: 0
   });
   // upstream -> buffer
-  let hadChunk = false;
   yield* pull.pipe(pullLatch.whenOpen, Effect.flatMap(arr => {
-    hadChunk = true;
     pullLatch.closeUnsafe();
     return Queue.offer(buffer, arr);
   }), Effect.forever,
@@ -5141,33 +5308,43 @@ export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fr
   Effect.catchCause(cause => Queue.failCause(buffer, cause)), Effect.forkIn(scope));
   // schedule -> buffer
   let lastOutput = Option.none();
+  let leftover;
+  let sinkHasInput = false;
   const step = yield* Schedule.toStepWithSleep(schedule);
-  const stepToBuffer = Effect.suspend(() => step(lastOutput)).pipe(Effect.flatMap(() => Queue.offer(buffer, scheduleStep)), Effect.flatMap(() => Effect.never), Pull.catchDone(() => Cause.done()));
+  const stepToBuffer = Effect.suspend(function loop() {
+    return step(lastOutput).pipe(Effect.flatMap(() => !sinkHasInput ? loop() : Queue.offer(buffer, scheduleStep)), Effect.flatMap(() => Effect.never), Pull.catchDone(() => Cause.done()));
+  });
   // buffer -> sink
-  const pullFromBuffer = Queue.take(buffer).pipe(Effect.flatMap(arr => arr === scheduleStep ? Cause.done() : Effect.succeed(arr)));
-  let leftover;
+  const pullFromBuffer = Queue.take(buffer).pipe(Effect.flatMap(arr => {
+    if (arr === scheduleStep) {
+      return Cause.done();
+    }
+    sinkHasInput = true;
+    return Effect.succeed(arr);
+  }));
   const sinkUpstream = Effect.suspend(() => {
     if (leftover !== undefined) {
       const chunk = leftover;
       leftover = undefined;
+      sinkHasInput = true;
       return Effect.succeed(chunk);
     }
-    hadChunk = false;
     pullLatch.openUnsafe();
     return pullFromBuffer;
   });
   const catchSinkHalt = Effect.flatMap(([value, leftover_]) => {
-    // ignore the last output if the upsteam only pulled a halt
-    if (!hadChunk && buffer.state._tag === "Done") return Cause.done();
+    // ignore the last output if the upstream only pulled a halt
+    if (!sinkHasInput && buffer.state._tag === "Done") return Cause.done();
     lastOutput = Option.some(value);
     leftover = leftover_;
     return Effect.succeed(Arr.of(value));
   });
   return Effect.suspend(() => {
     // if the buffer has exited and there is no more data to process
-    if (buffer.state._tag === "Done") {
+    if (buffer.state._tag === "Done" && leftover === undefined) {
       return buffer.state.exit;
     }
+    sinkHasInput = leftover !== undefined;
     return Effect.succeed(Effect.suspend(() => sink.transform(sinkUpstream, scope)));
   }).pipe(Effect.flatMap(pull => Effect.raceFirst(catchSinkHalt(pull), stepToBuffer)));
 }))));
@@ -5931,7 +6108,7 @@ export const onEnd = /*#__PURE__*/dual(2, (self, onEnd) => fromChannel(Channel.o
  */
 export const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => fromChannel(Channel.ensuring(self.channel, finalizer)));
 /**
- * Provides a layer or service map to the stream, removing the corresponding
+ * Provides a layer or context to the stream, removing the corresponding
  * service requirements. Use `options.local` to build the layer every time; by
  * default, layers are shared between provide calls.
  *
@@ -5939,9 +6116,9 @@ export const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => fromChannel(Ch
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Layer, Context, Stream } from "effect"
  *
- * class Env extends ServiceMap.Service<Env, { readonly name: string }>()("Env") {}
+ * class Env extends Context.Service<Env, { readonly name: string }>()("Env") {}
  *
  * const layer = Layer.succeed(Env)({ name: "Ada" })
  *
@@ -5968,17 +6145,17 @@ export const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => fromChannel(Ch
  */
 export const provide = /*#__PURE__*/dual(args => isStream(args[0]), (self, layer, options) => fromChannel(Channel.provide(self.channel, layer, options)));
 /**
- * Provides multiple services to the stream using a service map.
+ * Provides multiple services to the stream using a context.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Config extends ServiceMap.Service<Config, { readonly prefix: string }>()("Config") {}
- * class Greeter extends ServiceMap.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
+ * class Config extends Context.Service<Config, { readonly prefix: string }>()("Config") {}
+ * class Greeter extends Context.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
  *
- * const services = ServiceMap.make(Config, { prefix: "Hello" }).pipe(
- *   ServiceMap.add(Greeter, { greet: (name: string) => `${name}!` })
+ * const context = Context.make(Config, { prefix: "Hello" }).pipe(
+ *   Context.add(Greeter, { greet: (name: string) => `${name}!` })
  * )
  *
  * const stream = Stream.fromEffect(
@@ -5990,7 +6167,7 @@ export const provide = /*#__PURE__*/dual(args => isStream(args[0]), (self, layer
  * )
  *
  * const program = Effect.gen(function*() {
- *   const result = yield* Stream.runCollect(Stream.provideServices(stream, services))
+ *   const result = yield* Stream.runCollect(Stream.provideContext(stream, context))
  *   yield* Console.log(result)
  * })
  *
@@ -6001,16 +6178,16 @@ export const provide = /*#__PURE__*/dual(args => isStream(args[0]), (self, layer
  * @since 4.0.0
  * @category Services
  */
-export const provideServices = /*#__PURE__*/dual(2, (self, services) => fromChannel(Channel.provideServices(self.channel, services)));
+export const provideContext = /*#__PURE__*/dual(2, (self, context) => fromChannel(Channel.provideContext(self.channel, context)));
 /**
  * Provides the stream with a single required service, eliminating that
  * requirement from its environment.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Greeter extends ServiceMap.Service<Greeter, {
+ * class Greeter extends Context.Service<Greeter, {
  *   greet: (name: string) => string
  * }>()("Greeter") {}
  *
@@ -6044,9 +6221,9 @@ export const provideService = /*#__PURE__*/dual(3, (self, key, service) => fromC
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class ApiConfig extends ServiceMap.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
+ * class ApiConfig extends Context.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
  *
  * const stream = Stream.fromEffect(
  *   Effect.gen(function*() {
@@ -6079,15 +6256,15 @@ export const provideService = /*#__PURE__*/dual(3, (self, key, service) => fromC
  */
 export const provideServiceEffect = /*#__PURE__*/dual(3, (self, key, service) => fromChannel(Channel.provideServiceEffect(self.channel, key, service)));
 /**
- * Transforms the stream's required services by mapping the current service map
+ * Transforms the stream's required services by mapping the current context
  * to a new one.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Logger extends ServiceMap.Service<Logger, { prefix: string }>()("Logger") {}
- * class Config extends ServiceMap.Service<Config, { name: string }>()("Config") {}
+ * class Logger extends Context.Service<Logger, { prefix: string }>()("Logger") {}
+ * class Config extends Context.Service<Config, { name: string }>()("Config") {}
  *
  * const stream = Stream.fromEffect(
  *   Effect.gen(function*() {
@@ -6098,8 +6275,8 @@ export const provideServiceEffect = /*#__PURE__*/dual(3, (self, key, service) =>
  * )
  *
  * const updated = stream.pipe(
- *   Stream.updateServices((services: ServiceMap.ServiceMap<Logger>) =>
- *     ServiceMap.add(services, Config, { name: "World" })
+ *   Stream.updateContext((context: Context.Context<Logger>) =>
+ *     Context.add(context, Config, { name: "World" })
  *   )
  * )
  *
@@ -6117,15 +6294,15 @@ export const provideServiceEffect = /*#__PURE__*/dual(3, (self, key, service) =>
  * @since 2.0.0
  * @category Services
  */
-export const updateServices = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.updateServices(self.channel, f)));
+export const updateContext = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.updateContext(self.channel, f)));
 /**
  * Updates a single service in the stream environment by applying a function.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Counter extends ServiceMap.Service<Counter, { count: number }>()("Counter") {}
+ * class Counter extends Context.Service<Counter, { count: number }>()("Counter") {}
  *
  * const stream = Stream.fromEffect(Effect.service(Counter)).pipe(
  *   Stream.updateService(Counter, (counter) => ({ count: counter.count + 1 }))
@@ -6143,7 +6320,7 @@ export const updateServices = /*#__PURE__*/dual(2, (self, f) => fromChannel(Chan
  * @since 2.0.0
  * @category Services
  */
-export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateServices(self, services => ServiceMap.add(services, service, f(ServiceMap.get(services, service)))));
+export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateContext(self, context => Context.add(context, service, f(Context.get(context, service)))));
 /**
  * Wraps the stream with a new span for tracing.
  *
@@ -6168,7 +6345,7 @@ export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateSe
 export const withSpan = function () {
   const dataFirst = isStream(arguments[0]);
   const name = dataFirst ? arguments[1] : arguments[0];
-  const options = addSpanStackTrace(dataFirst ? arguments[1] : arguments[2]);
+  const options = addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]);
   if (dataFirst) {
     const self = arguments[0];
     return fromChannel(Channel.withSpan(self.channel, name, options));
@@ -6695,29 +6872,29 @@ export const mkUint8Array = self => Channel.runFold(self.channel, () => new Uint
  *
  * @example
  * ```ts
- * import { ServiceMap, Stream } from "effect"
+ * import { Context, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2, 3, 4, 5)
- * const readableStream = Stream.toReadableStreamWith(stream, ServiceMap.empty())
+ * const readableStream = Stream.toReadableStreamWith(stream, Context.empty())
  * ```
  *
  * @since 2.0.0
  * @category Destructors
  */
-export const toReadableStreamWith = /*#__PURE__*/dual(args => isStream(args[0]), (self, services, options) => {
+export const toReadableStreamWith = /*#__PURE__*/dual(args => isStream(args[0]), (self, context, options) => {
   let currentResolve = undefined;
   let fiber = undefined;
-  const latch = Effect.makeLatchUnsafe(false);
+  const latch = Latch.makeUnsafe(false);
   return new ReadableStream({
     start(controller) {
-      fiber = Effect.runFork(Effect.provideServices(runForEachArray(self, chunk => latch.whenOpen(Effect.sync(() => {
+      fiber = Effect.runFork(Effect.provideContext(runForEachArray(self, chunk => latch.whenOpen(Effect.sync(() => {
         latch.closeUnsafe();
         for (let i = 0; i < chunk.length; i++) {
           controller.enqueue(chunk[i]);
         }
         currentResolve();
         currentResolve = undefined;
-      }))), services));
+      }))), context));
       fiber.addObserver(exit => {
         if (exit._tag === "Failure") {
           controller.error(Cause.squash(exit.cause));
@@ -6754,7 +6931,7 @@ export const toReadableStreamWith = /*#__PURE__*/dual(args => isStream(args[0]),
  * @since 2.0.0
  * @category Destructors
  */
-export const toReadableStream = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => toReadableStreamWith(self, ServiceMap.empty(), options));
+export const toReadableStream = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => toReadableStreamWith(self, Context.empty(), options));
 /**
  * Creates an Effect that builds a ReadableStream from the stream.
  *
@@ -6777,16 +6954,16 @@ export const toReadableStream = /*#__PURE__*/dual(args => isStream(args[0]), (se
  * @since 2.0.0
  * @category Destructors
  */
-export const toReadableStreamEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => Effect.map(Effect.services(), context => toReadableStreamWith(self, context, options)));
+export const toReadableStreamEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => Effect.map(Effect.context(), context => toReadableStreamWith(self, context, options)));
 /**
  * Converts the stream to an `AsyncIterable` using the provided services.
  *
  * @example
  * ```ts
- * import { ServiceMap, Stream } from "effect"
+ * import { Context, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2, 3)
- * const iterable = Stream.toAsyncIterableWith(stream, ServiceMap.empty())
+ * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
  *
  * const collect = async () => {
  *   const results: Array<number> = []
@@ -6800,10 +6977,10 @@ export const toReadableStreamEffect = /*#__PURE__*/dual(args => isStream(args[0]
  * @since 2.0.0
  * @category Destructors
  */
-export const toAsyncIterableWith = /*#__PURE__*/dual(2, (self, services) => ({
+export const toAsyncIterableWith = /*#__PURE__*/dual(2, (self, context) => ({
   [Symbol.asyncIterator]() {
-    const runPromise = Effect.runPromiseWith(services);
-    const runPromiseExit = Effect.runPromiseExitWith(services);
+    const runPromise = Effect.runPromiseWith(context);
+    const runPromiseExit = Effect.runPromiseExitWith(context);
     const scope = Scope.makeUnsafe();
     let pull;
     let currentIter;
@@ -6864,7 +7041,7 @@ export const toAsyncIterableWith = /*#__PURE__*/dual(2, (self, services) => ({
  * @since 2.0.0
  * @category Destructors
  */
-export const toAsyncIterableEffect = self => Effect.map(Effect.services(), services => toAsyncIterableWith(self, services));
+export const toAsyncIterableEffect = self => Effect.map(Effect.context(), context => toAsyncIterableWith(self, context));
 /**
  * Converts a stream to an `AsyncIterable` for `for await...of` consumption.
  *
@@ -6890,7 +7067,7 @@ export const toAsyncIterableEffect = self => Effect.map(Effect.services(), servi
  * @since 2.0.0
  * @category Destructors
  */
-export const toAsyncIterable = self => toAsyncIterableWith(self, ServiceMap.empty());
+export const toAsyncIterable = self => toAsyncIterableWith(self, Context.empty());
 /**
  * Runs the stream, publishing elements into the provided PubSub.
  *
@@ -6975,23 +7152,23 @@ export const toPubSub = /*#__PURE__*/dual(2, (self, options) => Channel.toPubSub
  */
 export const toPubSubTake = /*#__PURE__*/dual(2, (self, options) => Channel.toPubSubTake(self.channel, options));
 /**
- * Converts a stream to a PubSub for concurrent consumption.
+ * Converts a stream to a Queue for concurrent consumption.
  *
  * @example
  * ```ts
- * import { Effect, PubSub, Stream } from "effect"
+ * import { Effect, Queue, Stream } from "effect"
  *
  * const program = Effect.gen(function* () {
- *   const pubSub = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
- *   const subscription = yield* PubSub.subscribe(pubSub)
- *   return subscription
+ *   const queue = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
+ *   const chunk = yield* Queue.takeBetween(queue, 1, 3)
+ *   return chunk
  * })
  * ```
  *
  * @since 2.0.0
  * @category Destructors
  */
-export const toQueue = /*#__PURE__*/dual(2, (self, options) => Channel.toPubSubArray(self.channel, options));
+export const toQueue = /*#__PURE__*/dual(2, (self, options) => Channel.toQueueArray(self.channel, options));
 /**
  * Runs the stream, offering each element to the provided queue and ending it
  * with `Cause.Done` when the stream completes.