effect 4.0.0-beta.38 → 4.0.0-beta.39

package/src/Schedule.ts

@@ -12,7 +12,7 @@
  *
  * // Retry with exponential backoff
  * const retryPolicy = Schedule.exponential("100 millis", 2.0)
- *   .pipe(Schedule.compose(Schedule.recurs(3)))
+ *   .pipe(Schedule.both(Schedule.recurs(3)))
  *
  * const program = Effect.gen(function*() {
  *   // This will retry up to 3 times with exponential backoff
@@ -59,7 +59,7 @@ const randomNext: Effect<number> = random.Random.useSync((random) => random.next
  *
  * // Basic retry schedule - retry up to 3 times with exponential backoff
  * const retrySchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(3))
+ *   Schedule.both(Schedule.recurs(3))
  * )
  *
  * // Basic repeat schedule - repeat every 30 seconds forever
@@ -336,7 +336,7 @@ export const isSchedule = (u: unknown): u is Schedule<unknown, never, unknown, u
  *
  * // These can be combined and transformed as needed
  * const complexSchedule = simpleSchedule.pipe(
- *   Schedule.compose(Schedule.recurs(3))
+ *   Schedule.both(Schedule.recurs(3))
  * )
  * ```
  *
@@ -1953,211 +1953,6 @@ export const bothWith: {
       })
   )))
 
-/**
- * Returns a new `Schedule` that combines two schedules by running them
- * sequentially. First the current schedule runs to completion, then the
- * other schedule runs to completion. The output is a tuple of both results.
- *
- * @example
- * ```ts
- * import { Console, Data, Effect, Schedule } from "effect"
- *
- * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
- *
- * // Compose a quick retry phase followed by slower retry phase
- * const fastRetries = Schedule.exponential("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(3)) // 3 fast retries
- * )
- *
- * const slowRetries = Schedule.exponential("2 seconds").pipe(
- *   Schedule.compose(Schedule.recurs(2)) // 2 slow retries
- * )
- *
- * // Sequential composition: fast retries first, then slow retries
- * const composedRetry = Schedule.compose(fastRetries, slowRetries)
- * // Outputs: [number_from_fast_phase, number_from_slow_phase]
- *
- * const program = Effect.gen(function*() {
- *   let attempt = 0
- *
- *   const result = yield* Effect.retry(
- *     Effect.gen(function*() {
- *       attempt++
- *       yield* Console.log(`Attempt ${attempt}`)
- *
- *       if (attempt < 7) { // Needs both phases to succeed
- *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
- *       }
- *
- *       return `Success on attempt ${attempt}`
- *     }),
- *     composedRetry.pipe(
- *       Schedule.tapOutput(([fastResult, slowResult]) =>
- *         Console.log(`Fast phase: ${fastResult}, Slow phase: ${slowResult}`)
- *       )
- *     )
- *   )
- *
- *   yield* Console.log(`Final result: ${result}`)
- * })
- *
- * // Compose different schedule types
- * const warmupAndMaintenance = Schedule.compose(
- *   Schedule.fixed("500 millis").pipe(Schedule.take(5)), // 5 warmup cycles
- *   Schedule.spaced("5 seconds") // then regular maintenance
- * )
- *
- * // Progressive backoff: fixed first, then exponential
- * const progressiveBackoff = Schedule.compose(
- *   Schedule.fixed("100 millis").pipe(Schedule.take(3)), // Fixed: 100ms, 100ms, 100ms
- *   Schedule.exponential("500 millis").pipe(Schedule.take(3)) // Then exponential: 500ms, 1s, 2s
- * )
- * ```
- *
- * @since 2.0.0
- * @category sequencing
- */
-export const compose: {
-  /**
-   * Returns a new `Schedule` that combines two schedules by running them
-   * sequentially. First the current schedule runs to completion, then the
-   * other schedule runs to completion. The output is a tuple of both results.
-   *
-   * @example
-   * ```ts
-   * import { Console, Data, Effect, Schedule } from "effect"
-   *
-   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
-   *
-   * // Compose a quick retry phase followed by slower retry phase
-   * const fastRetries = Schedule.exponential("100 millis").pipe(
-   *   Schedule.compose(Schedule.recurs(3)) // 3 fast retries
-   * )
-   *
-   * const slowRetries = Schedule.exponential("2 seconds").pipe(
-   *   Schedule.compose(Schedule.recurs(2)) // 2 slow retries
-   * )
-   *
-   * // Sequential composition: fast retries first, then slow retries
-   * const composedRetry = Schedule.compose(fastRetries, slowRetries)
-   * // Outputs: [number_from_fast_phase, number_from_slow_phase]
-   *
-   * const program = Effect.gen(function*() {
-   *   let attempt = 0
-   *
-   *   const result = yield* Effect.retry(
-   *     Effect.gen(function*() {
-   *       attempt++
-   *       yield* Console.log(`Attempt ${attempt}`)
-   *
-   *       if (attempt < 7) { // Needs both phases to succeed
-   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
-   *       }
-   *
-   *       return `Success on attempt ${attempt}`
-   *     }),
-   *     composedRetry.pipe(
-   *       Schedule.tapOutput(([fastResult, slowResult]) =>
-   *         Console.log(`Fast phase: ${fastResult}, Slow phase: ${slowResult}`)
-   *       )
-   *     )
-   *   )
-   *
-   *   yield* Console.log(`Final result: ${result}`)
-   * })
-   *
-   * // Compose different schedule types
-   * const warmupAndMaintenance = Schedule.compose(
-   *   Schedule.fixed("500 millis").pipe(Schedule.take(5)), // 5 warmup cycles
-   *   Schedule.spaced("5 seconds") // then regular maintenance
-   * )
-   *
-   * // Progressive backoff: fixed first, then exponential
-   * const progressiveBackoff = Schedule.compose(
-   *   Schedule.fixed("100 millis").pipe(Schedule.take(3)), // Fixed: 100ms, 100ms, 100ms
-   *   Schedule.exponential("500 millis").pipe(Schedule.take(3)) // Then exponential: 500ms, 1s, 2s
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category sequencing
-   */
-  <Output2, Input2, Error2, Env2>(other: Schedule<Output2, Input2, Error2, Env2>): <Output, Input, Error, Env>(
-    self: Schedule<Output, Input, Error, Env>
-  ) => Schedule<[Output, Output2], Input & Input2, Error | Error2, Env | Env2>
-  /**
-   * Returns a new `Schedule` that combines two schedules by running them
-   * sequentially. First the current schedule runs to completion, then the
-   * other schedule runs to completion. The output is a tuple of both results.
-   *
-   * @example
-   * ```ts
-   * import { Console, Data, Effect, Schedule } from "effect"
-   *
-   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
-   *
-   * // Compose a quick retry phase followed by slower retry phase
-   * const fastRetries = Schedule.exponential("100 millis").pipe(
-   *   Schedule.compose(Schedule.recurs(3)) // 3 fast retries
-   * )
-   *
-   * const slowRetries = Schedule.exponential("2 seconds").pipe(
-   *   Schedule.compose(Schedule.recurs(2)) // 2 slow retries
-   * )
-   *
-   * // Sequential composition: fast retries first, then slow retries
-   * const composedRetry = Schedule.compose(fastRetries, slowRetries)
-   * // Outputs: [number_from_fast_phase, number_from_slow_phase]
-   *
-   * const program = Effect.gen(function*() {
-   *   let attempt = 0
-   *
-   *   const result = yield* Effect.retry(
-   *     Effect.gen(function*() {
-   *       attempt++
-   *       yield* Console.log(`Attempt ${attempt}`)
-   *
-   *       if (attempt < 7) { // Needs both phases to succeed
-   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
-   *       }
-   *
-   *       return `Success on attempt ${attempt}`
-   *     }),
-   *     composedRetry.pipe(
-   *       Schedule.tapOutput(([fastResult, slowResult]) =>
-   *         Console.log(`Fast phase: ${fastResult}, Slow phase: ${slowResult}`)
-   *       )
-   *     )
-   *   )
-   *
-   *   yield* Console.log(`Final result: ${result}`)
-   * })
-   *
-   * // Compose different schedule types
-   * const warmupAndMaintenance = Schedule.compose(
-   *   Schedule.fixed("500 millis").pipe(Schedule.take(5)), // 5 warmup cycles
-   *   Schedule.spaced("5 seconds") // then regular maintenance
-   * )
-   *
-   * // Progressive backoff: fixed first, then exponential
-   * const progressiveBackoff = Schedule.compose(
-   *   Schedule.fixed("100 millis").pipe(Schedule.take(3)), // Fixed: 100ms, 100ms, 100ms
-   *   Schedule.exponential("500 millis").pipe(Schedule.take(3)) // Then exponential: 500ms, 1s, 2s
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category sequencing
-   */
-  <Output, Input, Error, Env, Output2, Input2, Error2, Env2>(
-    self: Schedule<Output, Input, Error, Env>,
-    other: Schedule<Output2, Input2, Error2, Env2>
-  ): Schedule<[Output, Output2], Input & Input2, Error | Error2, Env | Env2>
-} = dual(2, <Output, Input, Error, Env, Output2, Input2, Error2, Env2>(
-  self: Schedule<Output, Input, Error, Env>,
-  other: Schedule<Output2, Input2, Error2, Env2>
-): Schedule<[Output, Output2], Input & Input2, Error | Error2, Env | Env2> => both(self, other))
-
 /**
  * Returns a new `Schedule` that always recurs, collecting all inputs of the
  * schedule into an array.
@@ -3870,7 +3665,7 @@ export const elapsed: Schedule<Duration.Duration> = fromStepWithMetadata(
  *
  * // Retry with exponential backoff (limited to 5 attempts)
  * const retryPolicy = Schedule.exponential("50 millis").pipe(
- *   Schedule.compose(Schedule.recurs(5))
+ *   Schedule.both(Schedule.recurs(5))
  * )
  *
  * const program = Effect.gen(function*() {
@@ -3939,7 +3734,7 @@ export const exponential = (
  *       return `Success on attempt ${attempt}`
  *     }),
  *     Schedule.fibonacci("50 millis").pipe(
- *       Schedule.compose(Schedule.recurs(6)), // Maximum 6 retries
+ *       Schedule.both(Schedule.recurs(6)), // Maximum 6 retries
  *       Schedule.tapOutput((delay) => Console.log(`Next retry in ${delay}`))
  *     )
  *   )
@@ -4505,7 +4300,7 @@ export const passthrough = <Output, Input, Error, Env>(
  *
  * // Combining recurs with other schedules for sophisticated retry logic
  * const complexRetry = Schedule.exponential("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(3)) // At most 3 attempts
+ *   Schedule.both(Schedule.recurs(3)) // At most 3 attempts
  * )
  *
  * // Repeat an effect exactly 10 times
@@ -4932,7 +4727,7 @@ export const reduce: {
  *
  * // Simple spaced schedule with limited repetitions
  * const limitedSpaced = Schedule.spaced("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(5)) // at most 5 times
+ *   Schedule.both(Schedule.recurs(5)) // at most 5 times
  * )
  *
  * const program = Effect.gen(function*() {

package/src/Stream.ts

@@ -1360,7 +1360,7 @@ export const fromAsyncIterable = <A, E>(
  *
  * 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)

package/src/Struct.ts

@@ -157,7 +157,7 @@ export type Mutable<T> = { -readonly [K in keyof T]: T[K] } & {}
  * @category Type-Level Programming
  * @since 4.0.0
  */
-export type Assign<T, U> = keyof T & keyof U extends never ? T & U : Omit<T, keyof T & keyof U> & U
+export type Assign<T, U> = Simplify<keyof T & keyof U extends never ? T & U : Omit<T, keyof T & keyof U> & U>
 
 /**
  * Retrieves the value at `key` from a struct.
@@ -305,7 +305,7 @@ export const pick: {
    * @category filtering
    * @since 2.0.0
    */
-  <S extends object, const Keys extends ReadonlyArray<keyof S>>(keys: Keys): (self: S) => Pick<S, Keys[number]>
+  <S extends object, const Keys extends ReadonlyArray<keyof S>>(keys: Keys): (self: S) => Simplify<Pick<S, Keys[number]>>
   /**
    * Creates a new struct containing only the specified keys.
    *
@@ -329,7 +329,7 @@ export const pick: {
    * @category filtering
    * @since 2.0.0
    */
-  <S extends object, const Keys extends ReadonlyArray<keyof S>>(self: S, keys: Keys): Pick<S, Keys[number]>
+  <S extends object, const Keys extends ReadonlyArray<keyof S>>(self: S, keys: Keys): Simplify<Pick<S, Keys[number]>>
 } = dual(
   2,
   <S extends object, const Keys extends ReadonlyArray<keyof S>>(self: S, keys: Keys) => {
@@ -382,7 +382,7 @@ export const omit: {
    * @category filtering
    * @since 2.0.0
    */
-  <S extends object, const Keys extends ReadonlyArray<keyof S>>(keys: Keys): (self: S) => Omit<S, Keys[number]>
+  <S extends object, const Keys extends ReadonlyArray<keyof S>>(keys: Keys): (self: S) => Simplify<Omit<S, Keys[number]>>
   /**
    * Creates a new struct with the specified keys removed.
    *
@@ -405,7 +405,7 @@ export const omit: {
    * @category filtering
    * @since 2.0.0
    */
-  <S extends object, const Keys extends ReadonlyArray<keyof S>>(self: S, keys: Keys): Omit<S, Keys[number]>
+  <S extends object, const Keys extends ReadonlyArray<keyof S>>(self: S, keys: Keys): Simplify<Omit<S, Keys[number]>>
 } = dual(
   2,
   <S extends object, Keys extends ReadonlyArray<keyof S>>(self: S, keys: Keys) => {
@@ -464,7 +464,7 @@ export const assign: {
    * @category combining
    * @since 4.0.0
    */
-  <O extends object>(that: O): <S extends object>(self: S) => Simplify<Assign<S, O>>
+  <O extends object>(that: O): <S extends object>(self: S) => Assign<S, O>
   /**
    * Merges two structs into a new struct. When both structs share a key, the
    * value from `that` (the second struct) wins.
@@ -490,7 +490,7 @@ export const assign: {
    * @category combining
    * @since 4.0.0
    */
-  <O extends object, S extends object>(self: S, that: O): Simplify<Assign<S, O>>
+  <O extends object, S extends object>(self: S, that: O): Assign<S, O>
 } = dual(
   2,
   <O extends object, S extends object>(self: S, that: O) => {

package/src/index.ts

@@ -3222,7 +3222,7 @@ export * as Runtime from "./Runtime.ts"
  *
  * // Retry with exponential backoff
  * const retryPolicy = Schedule.exponential("100 millis", 2.0)
- *   .pipe(Schedule.compose(Schedule.recurs(3)))
+ *   .pipe(Schedule.both(Schedule.recurs(3)))
  *
  * const program = Effect.gen(function*() {
  *   // This will retry up to 3 times with exponential backoff

package/src/internal/effect.ts

@@ -5,7 +5,6 @@ import type * as Console from "../Console.ts"
 import * as Duration from "../Duration.ts"
 import type * as Effect from "../Effect.ts"
 import * as Equal from "../Equal.ts"
-import type { ErrorReporter } from "../ErrorReporter.ts"
 import type * as Exit from "../Exit.ts"
 import type * as Fiber from "../Fiber.ts"
 import * as Filter from "../Filter.ts"
@@ -25,19 +24,7 @@ import { pipeArguments } from "../Pipeable.ts"
 import type * as Predicate from "../Predicate.ts"
 import { hasProperty, isIterable, isString, isTagged } from "../Predicate.ts"
 import { currentFiberTypeId, redact } from "../Redactable.ts"
-import {
-  CurrentConcurrency,
-  CurrentLogAnnotations,
-  CurrentLogLevel,
-  CurrentLogSpans,
-  CurrentStackFrame,
-  MinimumLogLevel,
-  type StackFrame,
-  TracerEnabled,
-  TracerSpanAnnotations,
-  TracerSpanLinks,
-  TracerTimingEnabled
-} from "../References.ts"
+import type { StackFrame } from "../References.ts"
 import * as Result from "../Result.ts"
 import * as Scheduler from "../Scheduler.ts"
 import type * as Scope from "../Scope.ts"
@@ -97,6 +84,19 @@ import {
 } from "./core.ts"
 import * as doNotation from "./doNotation.ts"
 import * as InternalMetric from "./metric.ts"
+import {
+  CurrentConcurrency,
+  CurrentErrorReporters,
+  CurrentLogAnnotations,
+  CurrentLogLevel,
+  CurrentLogSpans,
+  CurrentStackFrame,
+  MinimumLogLevel,
+  TracerEnabled,
+  TracerSpanAnnotations,
+  TracerSpanLinks,
+  TracerTimingEnabled
+} from "./references.ts"
 import { addSpanStackTrace, type ErrorWithStackTraceLimit, makeStackCleaner } from "./tracer.ts"
 import { version } from "./version.ts"
 
@@ -6192,13 +6192,6 @@ export { undefined_ as undefined }
 // ErrorReporter
 // ----------------------------------------------------------------------------
 
-/** @internal */
-export const CurrentErrorReporters = ServiceMap.Reference<
-  ReadonlySet<ErrorReporter>
->("effect/ErrorReporter/CurrentErrorReporters", {
-  defaultValue: () => new Set()
-})
-
 /** @internal */
 export const withErrorReporting: <
   Arg extends Effect.Effect<any, any, any> | {

package/src/internal/references.ts

@@ -0,0 +1,72 @@
+import type { ErrorReporter } from "../ErrorReporter.ts"
+import { constTrue, constUndefined } from "../Function.ts"
+import type { LogLevel, Severity } from "../LogLevel.ts"
+import type { ReadonlyRecord } from "../Record.ts"
+import type { StackFrame } from "../References.ts"
+import * as ServiceMap from "../ServiceMap.ts"
+import type { SpanLink } from "../Tracer.ts"
+
+/** @internal */
+export const CurrentConcurrency = ServiceMap.Reference<"unbounded" | number>("effect/References/CurrentConcurrency", {
+  defaultValue: () => "unbounded"
+})
+
+/** @internal */
+export const CurrentErrorReporters = ServiceMap.Reference<ReadonlySet<ErrorReporter>>(
+  "effect/ErrorReporter/CurrentErrorReporters",
+  { defaultValue: () => new Set() }
+)
+
+/** @internal */
+export const CurrentStackFrame = ServiceMap.Reference<StackFrame | undefined>("effect/References/CurrentStackFrame", {
+  defaultValue: constUndefined
+})
+
+/** @internal */
+export const TracerEnabled = ServiceMap.Reference<boolean>("effect/References/TracerEnabled", {
+  defaultValue: constTrue
+})
+
+/** @internal */
+export const TracerTimingEnabled = ServiceMap.Reference<boolean>("effect/References/TracerTimingEnabled", {
+  defaultValue: constTrue
+})
+
+/** @internal */
+export const TracerSpanAnnotations = ServiceMap.Reference<ReadonlyRecord<string, unknown>>(
+  "effect/References/TracerSpanAnnotations",
+  { defaultValue: () => ({}) }
+)
+
+/** @internal */
+export const TracerSpanLinks = ServiceMap.Reference<ReadonlyArray<SpanLink>>("effect/References/TracerSpanLinks", {
+  defaultValue: () => []
+})
+
+/** @internal */
+export const CurrentLogAnnotations = ServiceMap.Reference<ReadonlyRecord<string, unknown>>(
+  "effect/References/CurrentLogAnnotations",
+  { defaultValue: () => ({}) }
+)
+
+/** @internal */
+export const CurrentLogLevel: ServiceMap.Reference<Severity> = ServiceMap.Reference<Severity>(
+  "effect/References/CurrentLogLevel",
+  { defaultValue: () => "Info" }
+)
+
+/** @internal */
+export const MinimumLogLevel = ServiceMap.Reference<
+  LogLevel
+>("effect/References/MinimumLogLevel", { defaultValue: () => "Info" })
+
+/** @internal */
+export const UnhandledLogLevel: ServiceMap.Reference<Severity | undefined> = ServiceMap.Reference(
+  "effect/References/UnhandledLogLevel",
+  { defaultValue: (): Severity | undefined => "Error" }
+)
+
+/** @internal */
+export const CurrentLogSpans = ServiceMap.Reference<
+  ReadonlyArray<[label: string, timestamp: number]>
+>("effect/References/CurrentLogSpans", { defaultValue: () => [] })

package/src/unstable/httpapi/HttpApiClient.ts

@@ -526,12 +526,12 @@ export const endpoint = <
  * @since 4.0.0
  * @category constructors
  */
-export const urlBuilder = <Api extends HttpApi.AnyWithProps>(api: Api, options?: {
+export const urlBuilder = <Api extends HttpApi.Any>(api: Api, options?: {
   readonly baseUrl?: URL | string | undefined
 }): UrlBuilder<Api> => {
   const builder: Record<string, any> = {}
 
-  HttpApi.reflect(api, {
+  HttpApi.reflect(api as unknown as HttpApi.AnyWithProps, {
     onGroup({ group }) {
       if (group.topLevel) return
       builder[group.identifier] = {}