effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/ServiceMap.ts

@@ -24,6 +24,24 @@ import type * as Types from "./Types.ts"
 
 const ServiceTypeId = "~effect/ServiceMap/Service" as const
 
+/**
+ * The base type used for all ServiceMap keys.
+ *
+ * @since 4.0.0
+ * @category Models
+ */
+export interface Key<in out Identifier, in out Shape> extends Pipeable, Inspectable {
+  readonly [ServiceTypeId]: {
+    readonly _Service: Types.Invariant<Shape>
+    readonly _Identifier: Types.Invariant<Identifier>
+  }
+  readonly Service: Shape
+  readonly Identifier: Identifier
+  readonly key: string
+  readonly stack?: string | undefined
+  asEffect(): Effect<Shape, never, Identifier>
+}
+
 /**
  * @example
  * ```ts
@@ -42,21 +60,12 @@ const ServiceTypeId = "~effect/ServiceMap/Service" as const
  * @category Models
  */
 export interface Service<in out Identifier, in out Shape>
-  extends Pipeable, Inspectable, Yieldable<Service<Identifier, Shape>, Shape, never, Identifier>
+  extends Key<Identifier, Shape>, Yieldable<Service<Identifier, Shape>, Shape, never, Identifier>
 {
-  readonly [ServiceTypeId]: {
-    readonly _Service: Types.Invariant<Shape>
-    readonly _Identifier: Types.Invariant<Identifier>
-  }
-  readonly Service: Shape
-  readonly Identifier: Identifier
-  of(self: Shape): Shape
+  of(this: void, self: Shape): Shape
   serviceMap(self: Shape): ServiceMap<Identifier>
   use<A, E, R>(f: (service: Shape) => Effect<A, E, R>): Effect<A, E, R | Identifier>
   useSync<A>(f: (service: Shape) => A): Effect<A, never, Identifier>
-
-  readonly stack?: string | undefined
-  readonly key: string
 }
 
 /**
@@ -270,7 +279,7 @@ const ServiceProto: any = {
     const fn = this.asEffect = constant(withFiber((fiber) => exitSucceed(get(fiber.services, this))))
     return fn()
   },
-  of<Service>(self: Service): Service {
+  of<Service>(this: void, self: Service): Service {
     return self
   },
   serviceMap<Identifier, Shape>(
@@ -312,6 +321,7 @@ export interface Reference<in out Shape> extends Service<never, Shape> {
   readonly [ReferenceTypeId]: typeof ReferenceTypeId
   readonly defaultValue: () => Shape
   [Symbol.iterator](): EffectIterator<Reference<Shape>>
+  new(_: never): {}
 }
 
 /**
@@ -368,7 +378,7 @@ export declare namespace Service {
    * @since 4.0.0
    * @category Models
    */
-  export type Any = Service<never, any> | Service<any, any>
+  export type Any = Key<never, any> | Key<any, any>
 
   /**
    * @example
@@ -436,6 +446,7 @@ export interface ServiceMap<in Services> extends Equal.Equal, Pipeable, Inspecta
     readonly _Services: Types.Contravariant<Services>
   }
   readonly mapUnsafe: ReadonlyMap<string, any>
+  mutable: boolean
 }
 
 /**
@@ -457,10 +468,11 @@ export interface ServiceMap<in Services> extends Equal.Equal, Pipeable, Inspecta
 export const makeUnsafe = <Services = never>(mapUnsafe: ReadonlyMap<string, any>): ServiceMap<Services> => {
   const self = Object.create(Proto)
   self.mapUnsafe = mapUnsafe
+  self.mutable = false
   return self
 }
 
-const Proto: Omit<ServiceMap<never>, "mapUnsafe"> = {
+const Proto: Omit<ServiceMap<never>, "mapUnsafe" | "mutable"> = {
   ...PipeInspectableProto,
   [TypeId]: {
     _Services: (_: never) => _
@@ -508,20 +520,20 @@ const Proto: Omit<ServiceMap<never>, "mapUnsafe"> = {
 export const isServiceMap = (u: unknown): u is ServiceMap<never> => hasProperty(u, TypeId)
 
 /**
- * Checks if the provided argument is a `Service`.
+ * Checks if the provided argument is a `Key`.
  *
  * @example
  * ```ts
  * import { ServiceMap } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.strictEqual(ServiceMap.isService(ServiceMap.Service("Service")), true)
+ * assert.strictEqual(ServiceMap.isKey(ServiceMap.Service("Service")), true)
  * ```
  *
  * @since 4.0.0
  * @category Guards
  */
-export const isService = (u: unknown): u is Service<any, any> => hasProperty(u, ServiceTypeId)
+export const isKey = (u: unknown): u is Key<any, any> => hasProperty(u, ServiceTypeId)
 
 /**
  * Checks if the provided argument is a `Reference`.
@@ -580,7 +592,7 @@ const emptyServiceMap = makeUnsafe(new Map())
  * @category Constructors
  */
 export const make = <I, S>(
-  key: Service<I, S>,
+  key: Key<I, S>,
   service: Types.NoInfer<S>
 ): ServiceMap<I> => makeUnsafe(new Map([[key.key, service]]))
 
@@ -635,7 +647,7 @@ export const add: {
    * @since 4.0.0
    * @category Adders
    */
-  <I, S>(key: Service<I, S>, service: Types.NoInfer<S>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>
+  <I, S>(key: Key<I, S>, service: Types.NoInfer<S>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>
   /**
    * Adds a service to a given `ServiceMap`.
    *
@@ -661,16 +673,15 @@ export const add: {
    * @since 4.0.0
    * @category Adders
    */
-  <Services, I, S>(self: ServiceMap<Services>, key: Service<I, S>, service: Types.NoInfer<S>): ServiceMap<Services | I>
+  <Services, I, S>(self: ServiceMap<Services>, key: Key<I, S>, service: Types.NoInfer<S>): ServiceMap<Services | I>
 } = dual(3, <Services, I, S>(
   self: ServiceMap<Services>,
-  key: Service<I, S>,
+  key: Key<I, S>,
   service: Types.NoInfer<S>
-): ServiceMap<Services | I> => {
-  const map = new Map(self.mapUnsafe)
-  map.set(key.key, service)
-  return makeUnsafe(map)
-})
+): ServiceMap<Services | I> =>
+  withMapUnsafe(self, (map) => {
+    map.set(key.key, service)
+  }))
 
 /**
  * @since 4.0.0
@@ -681,29 +692,28 @@ export const addOrOmit: {
    * @since 4.0.0
    * @category Adders
    */
-  <I, S>(key: Service<I, S>, service: Option.Option<Types.NoInfer<S>>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>
+  <I, S>(key: Key<I, S>, service: Option.Option<Types.NoInfer<S>>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>
   /**
    * @since 4.0.0
    * @category Adders
    */
   <Services, I, S>(
     self: ServiceMap<Services>,
-    key: Service<I, S>,
+    key: Key<I, S>,
     service: Option.Option<Types.NoInfer<S>>
   ): ServiceMap<Services | I>
 } = dual(3, <Services, I, S>(
   self: ServiceMap<Services>,
-  key: Service<I, S>,
+  key: Key<I, S>,
   service: Option.Option<Types.NoInfer<S>>
-): ServiceMap<Services | I> => {
-  const map = new Map(self.mapUnsafe)
-  if (service._tag === "None") {
-    map.delete(key.key)
-  } else {
-    map.set(key.key, service.value)
-  }
-  return makeUnsafe(map)
-})
+): ServiceMap<Services | I> =>
+  withMapUnsafe(self, (map) => {
+    if (service._tag === "None") {
+      map.delete(key.key)
+    } else {
+      map.set(key.key, service.value)
+    }
+  }))
 
 /**
  * Get a service from the context that corresponds to the given key, or
@@ -770,7 +780,7 @@ export const getOrElse: {
    * @since 4.0.0
    * @category Getters
    */
-  <S, I, B>(key: Service<I, S>, orElse: LazyArg<B>): <Services>(self: ServiceMap<Services>) => S | B
+  <S, I, B>(key: Key<I, S>, orElse: LazyArg<B>): <Services>(self: ServiceMap<Services>) => S | B
   /**
    * Get a service from the context that corresponds to the given key, or
    * use the fallback value.
@@ -803,8 +813,8 @@ export const getOrElse: {
    * @since 4.0.0
    * @category Getters
    */
-  <Services, S, I, B>(self: ServiceMap<Services>, key: Service<I, S>, orElse: LazyArg<B>): S | B
-} = dual(3, <Services, S, I, B>(self: ServiceMap<Services>, key: Service<I, S>, orElse: LazyArg<B>): S | B => {
+  <Services, S, I, B>(self: ServiceMap<Services>, key: Key<I, S>, orElse: LazyArg<B>): S | B
+} = dual(3, <Services, S, I, B>(self: ServiceMap<Services>, key: Key<I, S>, orElse: LazyArg<B>): S | B => {
   if (self.mapUnsafe.has(key.key)) {
     return self.mapUnsafe.get(key.key)! as any
   }
@@ -820,15 +830,15 @@ export const getOrUndefined: {
    * @since 4.0.0
    * @category Getters
    */
-  <S, I>(key: Service<I, S>): <Services>(self: ServiceMap<Services>) => S | undefined
+  <S, I>(key: Key<I, S>): <Services>(self: ServiceMap<Services>) => S | undefined
   /**
    * @since 4.0.0
    * @category Getters
    */
-  <Services, S, I>(self: ServiceMap<Services>, key: Service<I, S>): S | undefined
+  <Services, S, I>(self: ServiceMap<Services>, key: Key<I, S>): S | undefined
 } = dual(
   2,
-  <Services, S, I>(self: ServiceMap<Services>, key: Service<I, S>): S | undefined => self.mapUnsafe.get(key.key)
+  <Services, S, I>(self: ServiceMap<Services>, key: Key<I, S>): S | undefined => self.mapUnsafe.get(key.key)
 )
 
 /**
@@ -888,7 +898,7 @@ export const getUnsafe: {
    * @since 4.0.0
    * @category unsafe
    */
-  <S, I>(service: Service<I, S>): <Services>(self: ServiceMap<Services>) => S
+  <S, I>(service: Key<I, S>): <Services>(self: ServiceMap<Services>) => S
   /**
    * Get a service from the context that corresponds to the given key.
    *
@@ -917,10 +927,10 @@ export const getUnsafe: {
    * @since 4.0.0
    * @category unsafe
    */
-  <Services, S, I>(self: ServiceMap<Services>, services: Service<I, S>): S
+  <Services, S, I>(self: ServiceMap<Services>, services: Key<I, S>): S
 } = dual(
   2,
-  <Services, I extends Services, S>(self: ServiceMap<Services>, service: Service<I, S>): S => {
+  <Services, I extends Services, S>(self: ServiceMap<Services>, service: Key<I, S>): S => {
     if (!self.mapUnsafe.has(service.key)) {
       if (ReferenceTypeId in service) return getDefaultValue(service as any)
       throw serviceNotFoundError(service)
@@ -980,7 +990,7 @@ export const get: {
    * @since 4.0.0
    * @category Getters
    */
-  <Services, I extends Services, S>(service: Service<I, S>): (self: ServiceMap<Services>) => S
+  <Services, I extends Services, S>(service: Key<I, S>): (self: ServiceMap<Services>) => S
   /**
    * Get a service from the context that corresponds to the given key.
    *
@@ -1006,7 +1016,7 @@ export const get: {
    * @since 4.0.0
    * @category Getters
    */
-  <Services, I extends Services, S>(self: ServiceMap<Services>, service: Service<I, S>): S
+  <Services, I extends Services, S>(self: ServiceMap<Services>, service: Key<I, S>): S
 } = getUnsafe
 
 /**
@@ -1044,7 +1054,7 @@ const getDefaultValue = (ref: Reference<any>) => {
   return (ref as any)[defaultValueCacheKey] = ref.defaultValue()
 }
 
-const serviceNotFoundError = (service: Service<any, any>) => {
+const serviceNotFoundError = (service: Key<any, any>) => {
   const error = new Error(
     `Service not found${service.key ? `: ${String(service.key)}` : ""}`
   )
@@ -1122,7 +1132,7 @@ export const getOption: {
    * @since 4.0.0
    * @category Getters
    */
-  <S, I>(service: Service<I, S>): <Services>(self: ServiceMap<Services>) => Option.Option<S>
+  <S, I>(service: Key<I, S>): <Services>(self: ServiceMap<Services>) => Option.Option<S>
   /**
    * Get the value associated with the specified key from the context wrapped in
    * an `Option` object. If the key is not found, the `Option` object will be
@@ -1151,8 +1161,8 @@ export const getOption: {
    * @since 4.0.0
    * @category Getters
    */
-  <Services, S, I>(self: ServiceMap<Services>, service: Service<I, S>): Option.Option<S>
-} = dual(2, <Services, I extends Services, S>(self: ServiceMap<Services>, service: Service<I, S>): Option.Option<S> => {
+  <Services, S, I>(self: ServiceMap<Services>, service: Key<I, S>): Option.Option<S>
+} = dual(2, <Services, I extends Services, S>(self: ServiceMap<Services>, service: Key<I, S>): Option.Option<S> => {
   if (self.mapUnsafe.has(service.key)) {
     return Option.some(self.mapUnsafe.get(service.key)! as any)
   }
@@ -1243,9 +1253,9 @@ export const merge: {
 } = dual(2, <Services, R1>(self: ServiceMap<Services>, that: ServiceMap<R1>): ServiceMap<Services | R1> => {
   if (self.mapUnsafe.size === 0) return that as any
   if (that.mapUnsafe.size === 0) return self as any
-  const map = new Map(self.mapUnsafe)
-  that.mapUnsafe.forEach((value, key) => map.set(key, value))
-  return makeUnsafe(map)
+  return withMapUnsafe(self, (map) => {
+    that.mapUnsafe.forEach((value, key) => map.set(key, value))
+  })
 })
 
 /**
@@ -1320,19 +1330,17 @@ export const mergeAll = <T extends Array<unknown>>(
  * @since 4.0.0
  * @category Utils
  */
-export const pick = <S extends ReadonlyArray<Service<any, any>>>(
+export const pick = <S extends ReadonlyArray<Key<any, any>>>(
   ...services: S
 ) =>
-<Services>(self: ServiceMap<Services>): ServiceMap<Services & Service.Identifier<S[number]>> => {
-  const map = new Map<string, any>()
-  const keySet = new Set(services.map((key) => key.key))
-  self.mapUnsafe.forEach((value, key) => {
-    if (keySet.has(key)) {
-      map.set(key, value)
-    }
+<Services>(self: ServiceMap<Services>): ServiceMap<Services & Service.Identifier<S[number]>> =>
+  withMapUnsafe(self, (map) => {
+    const keySet = new Set(services.map((key) => key.key))
+    map.forEach((_, key) => {
+      if (keySet.has(key)) return
+      map.delete(key)
+    })
   })
-  return makeUnsafe(map)
-}
 
 /**
  * @example
@@ -1360,14 +1368,68 @@ export const pick = <S extends ReadonlyArray<Service<any, any>>>(
  * @since 4.0.0
  * @category Utils
  */
-export const omit = <S extends ReadonlyArray<Service<any, any>>>(
+export const omit = <S extends ReadonlyArray<Key<any, any>>>(
   ...keys: S
 ) =>
-<Services>(self: ServiceMap<Services>): ServiceMap<Exclude<Services, Service.Identifier<S[number]>>> => {
-  const map = new Map(self.mapUnsafe)
-  for (let i = 0; i < keys.length; i++) {
-    map.delete(keys[i].key)
+<Services>(self: ServiceMap<Services>): ServiceMap<Exclude<Services, Service.Identifier<S[number]>>> =>
+  withMapUnsafe(self, (map) => {
+    for (let i = 0; i < keys.length; i++) {
+      map.delete(keys[i].key)
+    }
+  })
+
+/**
+ * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+ * of the underlying map when multiple mutations are needed.
+ *
+ * @since 4.0.0
+ * @category Utils
+ */
+export const mutate: {
+  /**
+   * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+   * of the underlying map when multiple mutations are needed.
+   *
+   * @since 4.0.0
+   * @category Utils
+   */
+  <Services, B>(f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>): <Services>(self: ServiceMap<Services>) => ServiceMap<B>
+  /**
+   * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+   * of the underlying map when multiple mutations are needed.
+   *
+   * @since 4.0.0
+   * @category Utils
+   */
+  <Services, B>(
+    self: ServiceMap<Services>,
+    f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>
+  ): ServiceMap<B>
+} = dual(
+  2,
+  <Services, B>(self: ServiceMap<Services>, f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>): ServiceMap<B> => {
+    const next = makeUnsafe</**
+     * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+     * of the underlying map when multiple mutations are needed.
+     *
+     * @since 4.0.0
+     * @category Utils
+     */
+    Services>(new Map(self.mapUnsafe))
+    next.mutable = true
+    const result = f(next)
+    result.mutable = false
+    return result
   }
+)
+
+const withMapUnsafe = <Services, B>(self: ServiceMap<Services>, f: (map: Map<string, any>) => void): ServiceMap<B> => {
+  if (self.mutable) {
+    f(self.mapUnsafe as any)
+    return self as any
+  }
+  const map = new Map(self.mapUnsafe)
+  f(map)
   return makeUnsafe(map)
 }
 

package/src/Sink.ts

@@ -9,7 +9,7 @@ import * as Clock from "./Clock.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
-import * as Filter from "./Filter.ts"
+import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, constFalse, constTrue, constVoid, dual, identity, pipe } from "./Function.ts"
 import * as internalStream from "./internal/stream.ts"
@@ -63,6 +63,9 @@ export interface Sink<out A, in In = unknown, out L = never, out E = never, out
     upstream: Pull.Pull<NonEmptyReadonlyArray<In>, never, void>,
     scope: Scope.Scope
   ) => Effect.Effect<End<A, L>, E, R>
+  [Unify.typeSymbol]?: unknown
+  [Unify.unifySymbol]?: SinkUnify<this>
+  [Unify.ignoreSymbol]?: SinkUnifyIgnore
 }
 
 /**
@@ -122,8 +125,8 @@ export interface SinkUnify<A extends { [Unify.typeSymbol]?: any }> extends Effec
  * @category models
  * @since 2.0.0
  */
-export interface SinkUnifyIgnore extends Effect.EffectUnifyIgnore {
-  Sink?: true
+export interface SinkUnifyIgnore {
+  Effect?: true
 }
 
 /**
@@ -1454,18 +1457,40 @@ export const takeWhile: {
    * @category constructors
    */
   <In>(predicate: Predicate<In>): Sink<Array<In>, In, In>
-  /**
-   * @since 4.0.0
-   * @category constructors
-   */
-  <In, Out, X>(filter: Filter.Filter<In, Out, X>): Sink<Array<Out>, In, In>
-} = <In>(filter: Filter.Filter<In, any, any> | Predicate<In>): Sink<Array<any>, In, In> =>
+} = <In>(predicate: Predicate<In>): Sink<Array<In>, In, In> =>
   fromTransform((upstream) => {
-    const out = Arr.empty<any>()
+    const out = Arr.empty<In>()
     return upstream.pipe(
       Effect.flatMap((arr) => {
         for (let i = 0; i < arr.length; i++) {
-          const result = Filter.apply(filter as any, arr[i])
+          if (!predicate(arr[i])) {
+            const leftover: Arr.NonEmptyReadonlyArray<In> | undefined = (i + 1) < arr.length
+              ? arr.slice(i + 1) as any
+              : undefined
+            return Cause.done([out, leftover] as const)
+          }
+          out.push(arr[i])
+        }
+        return Effect.void
+      }),
+      Effect.forever({ disableYield: true }),
+      Pull.catchDone((end) => Effect.succeed<End<Array<In>, In>>(end ?? [out]))
+    )
+  })
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const takeWhileFilter = <In, Out, X>(
+  filter: Filter.Filter<In, Out, X>
+): Sink<Array<Out>, In, In> =>
+  fromTransform((upstream) => {
+    const out = Arr.empty<Out>()
+    return upstream.pipe(
+      Effect.flatMap((arr) => {
+        for (let i = 0; i < arr.length; i++) {
+          const result = filter(arr[i])
           if (Result.isFailure(result)) {
             const leftover: Arr.NonEmptyReadonlyArray<In> | undefined = (i + 1) < arr.length
               ? arr.slice(i + 1) as any
@@ -1477,7 +1502,7 @@ export const takeWhile: {
         return Effect.void
       }),
       Effect.forever({ disableYield: true }),
-      Pull.catchDone((end) => Effect.succeed<End<Array<any>, In>>(end ?? [out]))
+      Pull.catchDone((end) => Effect.succeed<End<Array<Out>, In>>(end ?? [out]))
     )
   })
 
@@ -1491,27 +1516,57 @@ export const takeWhileEffect: {
    * @category constructors
    */
   <In, E, R>(predicate: (input: In) => Effect.Effect<boolean, E, R>): Sink<Array<In>, In, In, E, R>
-  /**
-   * @since 4.0.0
-   * @category constructors
-   */
-  <In, Out, X, E, R>(filter: Filter.FilterEffect<In, Out, X, E, R>): Sink<Array<Out>, In, In, E, R>
-} = <In, Out, X, E, R>(
-  filter: Filter.FilterEffect<In, Out, X, E, R> | ((input: In) => Effect.Effect<boolean, E, R>)
+} = <In, E, R>(
+  predicate: (input: In) => Effect.Effect<boolean, E, R>
+): Sink<Array<In>, In, In, E, R> =>
+  fromTransform((upstream) => {
+    const out = Arr.empty<In>()
+    let leftover: Arr.NonEmptyReadonlyArray<In> | undefined = undefined
+    return upstream.pipe(
+      Effect.flatMap((arr) => {
+        let i = 0
+        return Effect.whileLoop({
+          while: () => i < arr.length,
+          body: constant(Effect.flatMap(
+            Effect.suspend(() => {
+              const input = arr[i++]
+              return Effect.map(predicate(input), (passes) => [input, passes] as const)
+            }),
+            ([input, passes]) => {
+              if (!passes) {
+                if (i < arr.length) {
+                  leftover = arr.slice(i) as any
+                }
+                return Cause.done()
+              }
+              out.push(input)
+              return Effect.void
+            }
+          )),
+          step: constVoid
+        })
+      }),
+      Effect.forever({ disableYield: true }),
+      Pull.catchDone(() => Effect.succeed([out, leftover] as const))
+    )
+  })
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const takeWhileFilterEffect = <In, Out, X, E, R>(
+  filter: Filter.FilterEffect<In, Out, X, E, R>
 ): Sink<Array<Out>, In, In, E, R> =>
   fromTransform((upstream) => {
-    const f: Filter.FilterEffect<In, any, any, E, R> = (input: In) =>
-      Effect.map((filter as any)(input), (b: any) =>
-        typeof b === "boolean" ? (b ? Result.succeed(input) : Result.fail(undefined)) : b)
     const out = Arr.empty<Out>()
     let leftover: Arr.NonEmptyReadonlyArray<In> | undefined = undefined
     return upstream.pipe(
       Effect.flatMap((arr) => {
         let i = 0
         return Effect.whileLoop({
-          while: () =>
-            i < arr.length,
-          body: constant(Effect.flatMap(Effect.suspend(() => f(arr[i++])), (result) => {
+          while: () => i < arr.length,
+          body: constant(Effect.flatMap(Effect.suspend(() => filter(arr[i++])), (result) => {
             if (Result.isFailure(result)) {
               if (i < arr.length) {
                 leftover = arr.slice(i) as any
@@ -1782,19 +1837,19 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, value: Types.NoInfer<S>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, Exclude<R, I>>
+  <I, S>(key: ServiceMap.Key<I, S>, value: Types.NoInfer<S>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, Exclude<R, I>>
   /**
    * @since 4.0.0
    * @category Services
    */
   <A, In, L, E, R, I, S>(
     self: Sink<A, In, L, E, R>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     value: Types.NoInfer<S>
   ): Sink<A, In, L, E, Exclude<R, I>>
 } = dual(3, <A, In, L, E, R, I, S>(
   self: Sink<A, In, L, E, R>,
-  key: ServiceMap.Service<I, S>,
+  key: ServiceMap.Key<I, S>,
   value: Types.NoInfer<S>
 ): Sink<A, In, L, E, Exclude<R, I>> =>
   fromTransform((upstream, scope) =>

package/src/Stdio.ts

@@ -1,10 +1,12 @@
 /**
  * @since 4.0.0
  */
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
 import type { PlatformError } from "./PlatformError.ts"
 import * as ServiceMap from "./ServiceMap.ts"
-import type * as Sink from "./Sink.ts"
-import type * as Stream from "./Stream.ts"
+import * as Sink from "./Sink.ts"
+import * as Stream from "./Stream.ts"
 
 /**
  * @since 4.0.0
@@ -24,8 +26,13 @@ export const TypeId: TypeId = "~effect/Stdio"
  */
 export interface Stdio {
   readonly [TypeId]: TypeId
-  readonly stdout: Sink.Sink<void, string | Uint8Array, never, PlatformError>
-  readonly stderr: Sink.Sink<void, string | Uint8Array, never, PlatformError>
+  readonly args: Effect.Effect<ReadonlyArray<string>>
+  stdout(options?: {
+    readonly endOnDone?: boolean | undefined
+  }): Sink.Sink<void, string | Uint8Array, never, PlatformError>
+  stderr(options?: {
+    readonly endOnDone?: boolean | undefined
+  }): Sink.Sink<void, string | Uint8Array, never, PlatformError>
   readonly stdin: Stream.Stream<Uint8Array, PlatformError>
 }
 /**
@@ -42,3 +49,19 @@ export const make = (options: Omit<Stdio, TypeId>): Stdio => ({
   [TypeId]: TypeId,
   ...options
 })
+
+/**
+ * @since 4.0.0
+ * @category Layers
+ */
+export const layerTest = (impl: Partial<Stdio>): Layer.Layer<Stdio> =>
+  Layer.succeed(
+    Stdio,
+    make({
+      args: Effect.succeed([]),
+      stdout: () => Sink.drain,
+      stderr: () => Sink.drain,
+      stdin: Stream.empty,
+      ...impl
+    })
+  )