effect 4.0.0-beta.19 → 4.0.0-beta.20

package/src/Channel.ts

@@ -8624,7 +8624,7 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, service: NoInfer<S>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S>(key: ServiceMap.Key<I, S>, service: NoInfer<S>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   ) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>>
   /**
@@ -8633,12 +8633,12 @@ export const provideService: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     service: NoInfer<S>
   ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  key: ServiceMap.Service<I, S>,
+  key: ServiceMap.Key<I, S>,
   service: NoInfer<S>
 ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>> =>
   fromTransform((upstream, scope) =>
@@ -8657,7 +8657,7 @@ export const provideServiceEffect: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S, ES, RS>(key: ServiceMap.Service<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S, ES, RS>(key: ServiceMap.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   ) => Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS>
   /**
@@ -8666,12 +8666,12 @@ export const provideServiceEffect: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S, ES, RS>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     service: Effect.Effect<NoInfer<S>, ES, RS>
   ): Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S, ES, RS>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  key: ServiceMap.Service<I, S>,
+  key: ServiceMap.Key<I, S>,
   service: Effect.Effect<NoInfer<S>, ES, RS>
 ): Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS> =>
   fromTransform((upstream, scope) =>
@@ -8769,7 +8769,7 @@ export const updateService: {
    * @since 2.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, f: (service: NoInfer<S>) => S): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S>(key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I>
   /**
@@ -8778,12 +8778,12 @@ export const updateService: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    service: ServiceMap.Service<I, S>,
+    service: ServiceMap.Key<I, S>,
     f: (service: NoInfer<S>) => S
   ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
   self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  service: ServiceMap.Service<I, S>,
+  service: ServiceMap.Key<I, S>,
   f: (service: NoInfer<S>) => S
 ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I> =>
   updateServices(self, (services) =>

package/src/Config.ts

@@ -75,7 +75,7 @@ import type { Path, SourceError } from "./ConfigProvider.ts"
 import * as ConfigProvider from "./ConfigProvider.ts"
 import * as Duration_ from "./Duration.ts"
 import * as Effect from "./Effect.ts"
-import { dual, type LazyArg } from "./Function.ts"
+import { dual } from "./Function.ts"
 import { PipeInspectableProto, YieldableProto } from "./internal/core.ts"
 import * as LogLevel_ from "./LogLevel.ts"
 import * as Option from "./Option.ts"
@@ -569,7 +569,7 @@ function isMissingDataOnly(issue: Issue.Issue): boolean {
  * ```ts
  * import { Config, ConfigProvider, Effect } from "effect"
  *
- * const port = Config.number("port").pipe(Config.withDefault(() => 3000))
+ * const port = Config.number("port").pipe(Config.withDefault(3000))
  *
  * const provider = ConfigProvider.fromUnknown({})
  * // Effect.runSync(port.parse(provider)) // 3000
@@ -598,7 +598,7 @@ export const withDefault: {
    * ```ts
    * import { Config, ConfigProvider, Effect } from "effect"
    *
-   * const port = Config.number("port").pipe(Config.withDefault(() => 3000))
+   * const port = Config.number("port").pipe(Config.withDefault(3000))
    *
    * const provider = ConfigProvider.fromUnknown({})
    * // Effect.runSync(port.parse(provider)) // 3000
@@ -609,7 +609,7 @@ export const withDefault: {
    *
    * @since 4.0.0
    */
-  <const A2>(defaultValue: LazyArg<A2>): <A>(self: Config<A>) => Config<A2 | A>
+  <const A2>(defaultValue: A2): <A>(self: Config<A>) => Config<A2 | A>
   /**
    * Provides a fallback value when the config fails due to missing data.
    *
@@ -627,7 +627,7 @@ export const withDefault: {
    * ```ts
    * import { Config, ConfigProvider, Effect } from "effect"
    *
-   * const port = Config.number("port").pipe(Config.withDefault(() => 3000))
+   * const port = Config.number("port").pipe(Config.withDefault(3000))
    *
    * const provider = ConfigProvider.fromUnknown({})
    * // Effect.runSync(port.parse(provider)) // 3000
@@ -638,13 +638,13 @@ export const withDefault: {
    *
    * @since 4.0.0
    */
-  <A, const A2>(self: Config<A>, defaultValue: LazyArg<A2>): Config<A | A2>
-} = dual(2, <A, const A2>(self: Config<A>, defaultValue: LazyArg<A2>): Config<A | A2> => {
+  <A, const A2>(self: Config<A>, defaultValue: A2): Config<A | A2>
+} = dual(2, <A, const A2>(self: Config<A>, defaultValue: A2): Config<A | A2> => {
   return orElse(self, (err) => {
     if (Schema.isSchemaError(err.cause)) {
       const issue = err.cause.issue
       if (isMissingDataOnly(issue)) {
-        return succeed(defaultValue())
+        return succeed(defaultValue)
       }
     }
     return fail(err.cause)
@@ -678,7 +678,7 @@ export const withDefault: {
  * @since 4.0.0
  */
 export const option = <A>(self: Config<A>): Config<Option.Option<A>> =>
-  self.pipe(map(Option.some), withDefault(() => Option.none()))
+  self.pipe(map(Option.some), withDefault(Option.none()))
 
 /**
  * Utility type that recursively replaces primitives with `Config` in a nested

package/src/Effect.ts

@@ -763,7 +763,7 @@ export const all: <
 ) => All.Return<Arg, O> = internal.all
 
 /**
- * Applies an effectful `Filter` to each element and partitions failures and
+ * Applies an effectful function to each element and partitions failures and
  * successes.
  *
  * The returned tuple is `[excluded, satisfying]`, where:
@@ -776,10 +776,10 @@ export const all: <
  *
  * @example
  * ```ts
- * import { Effect, Result } from "effect"
+ * import { Effect } from "effect"
  *
  * const program = Effect.partition([0, 1, 2, 3], (n) =>
- *   Effect.succeed(n % 2 === 0 ? Result.fail(`${n} is even`) : Result.succeed(n))
+ *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
  * )
  *
  * Effect.runPromise(program).then(console.log)
@@ -791,7 +791,7 @@ export const all: <
  */
 export const partition: {
   /**
-   * Applies an effectful `Filter` to each element and partitions failures and
+   * Applies an effectful function to each element and partitions failures and
    * successes.
    *
    * The returned tuple is `[excluded, satisfying]`, where:
@@ -804,10 +804,10 @@ export const partition: {
    *
    * @example
    * ```ts
-   * import { Effect, Result } from "effect"
+   * import { Effect } from "effect"
    *
    * const program = Effect.partition([0, 1, 2, 3], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.fail(`${n} is even`) : Result.succeed(n))
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
    * )
    *
    * Effect.runPromise(program).then(console.log)
@@ -817,12 +817,12 @@ export const partition: {
    * @since 3.0.0
    * @category Collecting
    */
-  <A, Pass, Fail, E, R>(
-    filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, E, R, [i: number]>,
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R>
+  ): (elements: Iterable<A>) => Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
   /**
-   * Applies an effectful `Filter` to each element and partitions failures and
+   * Applies an effectful function to each element and partitions failures and
    * successes.
    *
    * The returned tuple is `[excluded, satisfying]`, where:
@@ -835,10 +835,10 @@ export const partition: {
    *
    * @example
    * ```ts
-   * import { Effect, Result } from "effect"
+   * import { Effect } from "effect"
    *
    * const program = Effect.partition([0, 1, 2, 3], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.fail(`${n} is even`) : Result.succeed(n))
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
    * )
    *
    * Effect.runPromise(program).then(console.log)
@@ -848,11 +848,11 @@ export const partition: {
    * @since 3.0.0
    * @category Collecting
    */
-  <A, Pass, Fail, E, R>(
+  <A, B, E, R>(
     elements: Iterable<A>,
-    filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, E, R, [i: number]>,
+    f: (a: A, i: number) => Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R>
+  ): Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
 } = internal.partition
 
 /**
@@ -10787,7 +10787,7 @@ export const provideServices: {
  * @since 4.0.0
  * @category ServiceMap
  */
-export const service: <I, S>(service: ServiceMap.Service<I, S>) => Effect<S, never, I> = internal.service
+export const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S, never, I> = internal.service
 
 /**
  * Optionally accesses a service from the environment.
@@ -10823,7 +10823,7 @@ export const service: <I, S>(service: ServiceMap.Service<I, S>) => Effect<S, nev
  * @since 2.0.0
  * @category ServiceMap
  */
-export const serviceOption: <I, S>(key: ServiceMap.Service<I, S>) => Effect<Option<S>> = internal.serviceOption
+export const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<Option<S>> = internal.serviceOption
 
 /**
  * Provides part of the required context while leaving the rest unchanged.
@@ -11012,7 +11012,7 @@ export const updateService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <I, A>(service: ServiceMap.Service<I, A>, f: (value: A) => A): <XA, E, R>(self: Effect<XA, E, R>) => Effect<XA, E, R | I>
+  <I, A>(service: ServiceMap.Key<I, A>, f: (value: A) => A): <XA, E, R>(self: Effect<XA, E, R>) => Effect<XA, E, R | I>
   /**
    * Updates the service with the required service entry.
    *
@@ -11041,11 +11041,7 @@ export const updateService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <XA, E, R, I, A>(
-    self: Effect<XA, E, R>,
-    service: ServiceMap.Service<I, A>,
-    f: (value: A) => A
-  ): Effect<XA, E, R | I>
+  <XA, E, R, I, A>(self: Effect<XA, E, R>, service: ServiceMap.Key<I, A>, f: (value: A) => A): Effect<XA, E, R | I>
 } = internal.updateService
 
 /**
@@ -11139,7 +11135,7 @@ export const provideService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <I, S>(service: ServiceMap.Service<I, S>): {
+  <I, S>(service: ServiceMap.Key<I, S>): {
     /**
      * The `provideService` function is used to provide an actual
      * implementation for a service in the context of an effect.
@@ -11278,7 +11274,7 @@ export const provideService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <I, S>(service: ServiceMap.Service<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>
+  <I, S>(service: ServiceMap.Key<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>
   /**
    * The `provideService` function is used to provide an actual
    * implementation for a service in the context of an effect.
@@ -11324,11 +11320,7 @@ export const provideService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <A, E, R, I, S>(
-    self: Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
-    implementation: S
-  ): Effect<A, E, Exclude<R, I>>
+  <A, E, R, I, S>(self: Effect<A, E, R>, service: ServiceMap.Key<I, S>, implementation: S): Effect<A, E, Exclude<R, I>>
 } = internal.provideService
 
 /**
@@ -11436,7 +11428,7 @@ export const provideServiceEffect: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <I, S, E2, R2>(service: ServiceMap.Service<I, S>, acquire: Effect<S, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, Exclude<R, I> | R2>
+  <I, S, E2, R2>(service: ServiceMap.Key<I, S>, acquire: Effect<S, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, Exclude<R, I> | R2>
   /**
    * Provides the effect with the single service it requires. If the effect
    * requires more than one service use `provide` instead.
@@ -11491,7 +11483,7 @@ export const provideServiceEffect: {
    */
   <A, E, R, I, S, E2, R2>(
     self: Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
+    service: ServiceMap.Key<I, S>,
     acquire: Effect<S, E2, R2>
   ): Effect<A, E | E2, Exclude<R, I> | R2>
 } = internal.provideServiceEffect

package/src/ErrorReporter.ts

@@ -145,7 +145,7 @@ export const make = (
         report({
           ...options,
           error: pretty,
-          severity: isObject ? getSeverity(original) : "Error",
+          severity: isObject ? getSeverity(original) : "Info",
           attributes: isObject ? getAttributes(original) : emptyAttributes
         })
       }
@@ -392,7 +392,7 @@ export const getSeverity = (error: object): Severity => {
   if (severity in error && LogLevel.values.includes(error[severity] as Severity)) {
     return error[severity] as Severity
   }
-  return "Error"
+  return "Info"
 }
 
 /**

package/src/Layer.ts

@@ -815,7 +815,7 @@ export const succeed: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Service<I, S>): (resource: S) => Layer<I>
+  <I, S>(service: ServiceMap.Key<I, S>): (resource: S) => Layer<I>
   /**
    * Constructs a layer from the specified value.
    *
@@ -858,7 +858,7 @@ export const succeed: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Service<I, S>, resource: Types.NoInfer<S>): Layer<I>
+  <I, S>(service: ServiceMap.Key<I, S>, resource: Types.NoInfer<S>): Layer<I>
 } = function() {
   if (arguments.length === 1) {
     return (resource: any) => succeedServices(ServiceMap.make(arguments[0], resource))
@@ -966,7 +966,7 @@ export const sync: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Service<I, S>): (evaluate: LazyArg<S>) => Layer<I>
+  <I, S>(service: ServiceMap.Key<I, S>): (evaluate: LazyArg<S>) => Layer<I>
   /**
    * Lazily constructs a layer from the specified value.
    *
@@ -989,7 +989,7 @@ export const sync: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Service<I, S>, evaluate: LazyArg<S>): Layer<I>
+  <I, S>(service: ServiceMap.Key<I, S>, evaluate: LazyArg<S>): Layer<I>
 } = function() {
   if (arguments.length === 1) {
     return (evaluate: LazyArg<any>) => syncServices(() => ServiceMap.make(arguments[0], evaluate()))
@@ -1088,7 +1088,7 @@ export const effect: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Service<I, S>): <E, R>(
+  <I, S>(service: ServiceMap.Key<I, S>): <E, R>(
     effect: Effect<S, E, R>
   ) => Layer<I, E, Exclude<R, Scope.Scope>>
   /**
@@ -1122,7 +1122,7 @@ export const effect: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S, E, R>(service: ServiceMap.Service<I, S>, effect: Effect<S, E, R>): Layer<I, E, Exclude<R, Scope.Scope>>
+  <I, S, E, R>(service: ServiceMap.Key<I, S>, effect: Effect<S, E, R>): Layer<I, E, Exclude<R, Scope.Scope>>
 } = function() {
   if (arguments.length === 1) {
     return (effect: any) => effectImpl(arguments[0], effect)
@@ -1131,7 +1131,7 @@ export const effect: {
 } as any
 
 const effectImpl = <I, S, E, R>(
-  service: ServiceMap.Service<I, S>,
+  service: ServiceMap.Key<I, S>,
   effect: Effect<S, E, R>
 ): Layer<I, E, Exclude<R, Scope.Scope>> =>
   effectServices(internalEffect.map(effect, (value) => ServiceMap.make(service, value)))
@@ -2879,7 +2879,7 @@ export const updateService: {
    * @since 3.13.0
    * @category utils
    */
-  <I, A>(service: ServiceMap.Service<I, A>, f: (a: A) => A): <A1, E1, R1>(layer: Layer<A1, E1, R1>) => Layer<A1, E1, I | R1>
+  <I, A>(service: ServiceMap.Key<I, A>, f: (a: A) => A): <A1, E1, R1>(layer: Layer<A1, E1, R1>) => Layer<A1, E1, I | R1>
   /**
    * Updates a service in the context with a new implementation.
    *
@@ -2898,16 +2898,12 @@ export const updateService: {
    * @since 3.13.0
    * @category utils
    */
-  <A1, E1, R1, I, A>(
-    layer: Layer<A1, E1, R1>,
-    service: ServiceMap.Service<I, A>,
-    f: (a: A) => A
-  ): Layer<A1, E1, I | R1>
+  <A1, E1, R1, I, A>(layer: Layer<A1, E1, R1>, service: ServiceMap.Key<I, A>, f: (a: A) => A): Layer<A1, E1, I | R1>
 } = dual(
   3,
   <A1, E1, R1, I, A>(
     layer: Layer<A1, E1, R1>,
-    service: ServiceMap.Service<I, A>,
+    service: ServiceMap.Key<I, A>,
     f: (a: A) => A
   ): Layer<A1, E1, I | R1> => provide(layer, effect(service)(internalEffect.map(service.asEffect(), f)))
 )
@@ -3096,7 +3092,7 @@ export type PartialEffectful<A extends object> = Types.Simplify<
  * @category Testing
  */
 export const mock =
-  <I, S extends object>(service: ServiceMap.Service<I, S>) => (implementation: PartialEffectful<S>): Layer<I> =>
+  <I, S extends object>(service: ServiceMap.Key<I, S>) => (implementation: PartialEffectful<S>): Layer<I> =>
     succeed(service)(
       new Proxy({ ...implementation as object } as S, {
         get(target, prop, _receiver) {

package/src/Schedule.ts

@@ -2410,7 +2410,7 @@ export const collectWhile: {
   <Input, Output, Error2 = never, Env2 = never>(
     predicate: (
       metadata: Metadata<Output, Input>
-    ) => Effect<boolean, Error2, Env2>
+    ) => boolean | Effect<boolean, Error2, Env2>
   ): <Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Array<Output>, Input, Error | Error2, Env | Env2>
@@ -2522,19 +2522,18 @@ export const collectWhile: {
     self: Schedule<Output, Input, Error, Env>,
     predicate: (
       metadata: Metadata<Output, Input>
-    ) => Effect<boolean, Error2, Env2>
+    ) => boolean | Effect<boolean, Error2, Env2>
   ): Schedule<Array<Output>, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
   predicate: (
     metadata: Metadata<Output, Input>
-  ) => Effect<boolean, Error2, Env2>
+  ) => boolean | Effect<boolean, Error2, Env2>
 ): Schedule<Array<Output>, Input, Error | Error2, Env | Env2> =>
-  reduce(while_(self, predicate), () => [] as Array<Output>, (outputs, output) =>
-    effect.succeed((() => {
-      outputs.push(output)
-      return outputs
-    })())))
+  reduce(while_(self, predicate), () => [] as Array<Output>, (outputs, output) => {
+    outputs.push(output)
+    return outputs
+  }))
 
 /**
  * Returns a new `Schedule` that recurs on the specified `Cron` schedule and
@@ -4698,7 +4697,7 @@ export const reduce: {
    */
   <State, Output, Error2 = never, Env2 = never>(
     initial: LazyArg<State>,
-    combine: (state: State, output: Output) => Effect<State, Error2, Env2>
+    combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>
   ): <Input, Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<State, Input, Error | Error2, Env | Env2>
@@ -4816,24 +4815,30 @@ export const reduce: {
   <Output, Input, Error, Env, State, Error2 = never, Env2 = never>(
     self: Schedule<Output, Input, Error, Env>,
     initial: LazyArg<State>,
-    combine: (state: State, output: Output) => Effect<State, Error2, Env2>
+    combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>
   ): Schedule<State, Input, Error | Error2, Env | Env2>
 } = dual(3, <Output, Input, Error, Env, State, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
   initial: LazyArg<State>,
-  combine: (state: State, output: Output) => Effect<State, Error2, Env2>
+  combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>
 ): Schedule<State, Input, Error | Error2, Env | Env2> =>
   fromStep(effect.map(toStep(self), (step) => {
     let state = initial()
     return (now, input) =>
       Pull.matchEffect(step(now, input), {
-        onSuccess: ([output, delay]) =>
-          effect.map(combine(state, output), (nextState) => {
+        onSuccess([output, delay]) {
+          const next = combine(state, output)
+          if (!isEffect(next)) return effect.succeed([next, delay] as [State, Duration.Duration])
+          return effect.map(next, (nextState) => {
             state = nextState
             return [nextState, delay]
-          }),
+          })
+        },
         onFailure: effect.failCause,
-        onDone: (output) => effect.flatMap(combine(state, output), Cause.done)
+        onDone(output) {
+          const next = combine(state, output)
+          return isEffect(next) ? effect.flatMap(next, Cause.done) : Cause.done(next)
+        }
       })
   })))
 
@@ -5900,7 +5905,7 @@ const while_: {
   <Input, Output, Error2 = never, Env2 = never>(
     predicate: (
       metadata: Metadata<Output, Input>
-    ) => Effect<boolean, Error2, Env2>
+    ) => boolean | Effect<boolean, Error2, Env2>
   ): <Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Output, Input, Error | Error2, Env | Env2>
@@ -5908,21 +5913,22 @@ const while_: {
     self: Schedule<Output, Input, Error, Env>,
     predicate: (
       metadata: Metadata<Output, Input>
-    ) => Effect<boolean, Error2, Env2>
+    ) => boolean | Effect<boolean, Error2, Env2>
   ): Schedule<Output, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
   predicate: (
     metadata: Metadata<Output, Input>
-  ) => Effect<boolean, Error2, Env2>
+  ) => boolean | Effect<boolean, Error2, Env2>
 ): Schedule<Output, Input, Error | Error2, Env | Env2> =>
   fromStep(effect.map(toStep(self), (step) => {
     const meta = metadataFn()
     return (now, input) =>
       effect.flatMap(step(now, input), (result) => {
         const [output, duration] = result
+        const eff = predicate({ ...meta(now, input), output, duration })
         return effect.flatMap(
-          predicate({ ...meta(now, input), output, duration }),
+          isEffect(eff) ? eff : effect.succeed(eff),
           (check) => (check ? effect.succeed(result) : Cause.done(output))
         )
       })
@@ -6068,6 +6074,16 @@ export const satisfiesInputType = <T>() =>
   self: Schedule<Output, Input, Error, Env>
 ): Schedule<Output, Input, Error, Env> => self
 
+/**
+ * Sets the input type of the provided schedule to a specified type, without
+ * altering the schedule's behavior.
+ *
+ * @since 2.0.0
+ * @category ensuring types
+ */
+export const setInputType =
+  <T>() => <Output, Error, Env>(self: Schedule<Output, T, Error, Env>): Schedule<Output, T, Error, Env> => self
+
 /**
  * Ensures that the provided schedule respects a specified output type.
  *

package/src/Schema.ts

@@ -1636,6 +1636,27 @@ export interface Struct<Fields extends Struct.Fields> extends
   >
 {
   readonly "~rebuild.out": this
+  /**
+   * The field definitions of this struct. Spread them into a new struct to
+   * reuse fields across schemas.
+   *
+   * **Example** (Reusing fields across structs)
+   *
+   * ```ts
+   * import { Schema } from "effect"
+   *
+   * const Timestamped = Schema.Struct({
+   *   createdAt: Schema.Date,
+   *   updatedAt: Schema.Date
+   * })
+   *
+   * const User = Schema.Struct({
+   *   ...Timestamped.fields,
+   *   name: Schema.String,
+   *   email: Schema.String
+   * })
+   * ```
+   */
   readonly fields: Fields
   /**
    * Returns a new struct with the fields modified by the provided function.