effect 4.0.0-beta.43 → 4.0.0-beta.44

package/dist/Stream.js

@@ -6,6 +6,7 @@ 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";
@@ -29,7 +30,6 @@ 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";
 /**
@@ -123,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.
  *
@@ -700,9 +770,9 @@ export const fromIterable = (iterable, options) => Array.isArray(iterable) && op
  *
  * @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") {}
  *
@@ -3718,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>
  *   })
@@ -5230,9 +5300,7 @@ export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fr
     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,
@@ -5241,34 +5309,42 @@ export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fr
   // schedule -> buffer
   let lastOutput = Option.none();
   let leftover;
+  let sinkHasInput = false;
   const step = yield* Schedule.toStepWithSleep(schedule);
   const stepToBuffer = Effect.suspend(function loop() {
-    return step(lastOutput).pipe(Effect.flatMap(() => !hadChunk && leftover === undefined ? loop() : Queue.offer(buffer, scheduleStep)), Effect.flatMap(() => Effect.never), Pull.catchDone(() => Cause.done()));
+    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)));
+  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 upstream only pulled a halt
-    if (!hadChunk && buffer.state._tag === "Done") return Cause.done();
+    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)));
 }))));
@@ -6032,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.
  *
@@ -6040,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" })
  *
@@ -6069,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(
@@ -6091,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)
  * })
  *
@@ -6102,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") {}
  *
@@ -6145,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*() {
@@ -6180,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*() {
@@ -6199,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" })
  *   )
  * )
  *
@@ -6218,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 }))
@@ -6244,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.
  *
@@ -6796,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 = 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));
@@ -6855,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.
  *
@@ -6878,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> = []
@@ -6901,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;
@@ -6965,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.
  *
@@ -6991,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.
  *
@@ -7076,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.