effect 4.0.0-beta.3 → 4.0.0-beta.30

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
@@ -508,20 +518,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 +590,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 +645,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,10 +671,10 @@ 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)
@@ -681,19 +691,19 @@ 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)
@@ -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)
   }
@@ -1320,7 +1330,7 @@ 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]>> => {
@@ -1360,7 +1370,7 @@ 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]>>> => {

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"
@@ -1454,18 +1454,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 +1499,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 +1513,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 +1834,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
+    })
+  )