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

package/src/LayerMap.ts

@@ -27,7 +27,7 @@ const TypeId = "~effect/LayerMap"
  * // Create a LayerMap that provides different database configurations
  * const createDatabaseLayerMap = LayerMap.make((env: string) =>
  *   Layer.succeed(DatabaseService)({
- *     query: (sql) => Effect.succeed(`${env}: ${sql}`)
+ *     query: Effect.fn("DatabaseService.query")((sql) => Effect.succeed(`${env}: ${sql}`))
  *   })
  * )
  *
@@ -91,7 +91,7 @@ export interface LayerMap<in out K, in out I, in out E = never> {
  *   const layerMap = yield* LayerMap.make(
  *     (env: string) =>
  *       Layer.succeed(DatabaseService)({
- *         query: (sql) => Effect.succeed(`${env}: ${sql}`)
+ *         query: Effect.fn("DatabaseService.query")((sql) => Effect.succeed(`${env}: ${sql}`))
  *       }),
  *     { idleTimeToLive: "5 seconds" }
  *   )
@@ -119,7 +119,7 @@ export const make: <
 >(
   lookup: (key: K) => L,
   options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
     readonly preloadKeys?: PreloadKeys
   } | undefined
 ) => Effect.Effect<
@@ -129,7 +129,7 @@ export const make: <
 > = Effect.fnUntraced(function*<I, K, EL, RL>(
   lookup: (key: K) => Layer.Layer<I, EL, RL>,
   options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   } | undefined
 ) {
   const services = yield* Effect.services<never>()
@@ -171,10 +171,10 @@ export const make: <
  * // Create predefined layers
  * const layers = {
  *   development: Layer.succeed(DevDatabase)({
- *     query: (sql) => Effect.succeed(`DEV: ${sql}`)
+ *     query: Effect.fn("DevDatabase.query")((sql) => Effect.succeed(`DEV: ${sql}`))
  *   }),
  *   production: Layer.succeed(ProdDatabase)({
- *     query: (sql) => Effect.succeed(`PROD: ${sql}`)
+ *     query: Effect.fn("ProdDatabase.query")((sql) => Effect.succeed(`PROD: ${sql}`))
  *   })
  * } as const
  *
@@ -198,7 +198,7 @@ export const fromRecord = <
 >(
   layers: Layers,
   options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
     readonly preload?: Preload | undefined
   } | undefined
 ): Effect.Effect<
@@ -309,7 +309,7 @@ export const Service = <Self>() =>
     | NoExcessProperties<{
       readonly lookup: (key: any) => Layer.Layer<any, any, any>
       readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>> | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
       readonly preloadKeys?:
         | Iterable<Options extends { readonly lookup: (key: infer K) => any } ? K : never>
         | undefined
@@ -317,7 +317,7 @@ export const Service = <Self>() =>
     | NoExcessProperties<{
       readonly layers: Record<string, Layer.Layer<any, any, any>>
       readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>> | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
       readonly preload?: boolean | undefined
     }, Options>
 >(

package/src/LogLevel.ts

@@ -98,9 +98,12 @@
  * })
  * ```
  */
+import type * as Effect from "./Effect.ts"
 import * as Equ from "./Equivalence.ts"
+import * as core from "./internal/core.ts"
 import * as effect from "./internal/effect.ts"
 import * as Ord from "./Order.ts"
+import * as References from "./References.ts"
 
 /**
  * Represents the severity level of a log message.
@@ -139,6 +142,12 @@ import * as Ord from "./Order.ts"
  */
 export type LogLevel = "All" | "Fatal" | "Error" | "Warn" | "Info" | "Debug" | "Trace" | "None"
 
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type Severity = "Fatal" | "Error" | "Warn" | "Info" | "Debug" | "Trace"
+
 /**
  * @since 4.0.0
  * @category models
@@ -623,3 +632,31 @@ export const isLessThanOrEqualTo: {
    */
   (self: LogLevel, that: LogLevel): boolean
 } = Ord.isLessThanOrEqualTo(Order)
+
+/**
+ * Checks whether a given log level is enabled for the current fiber.
+ *
+ * A log level is enabled when it is greater than or equal to
+ * `References.MinimumLogLevel`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, LogLevel, References } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const debugEnabled = yield* LogLevel.isEnabled("Debug")
+ *   const errorEnabled = yield* LogLevel.isEnabled("Error")
+ *
+ *   console.log({ debugEnabled, errorEnabled })
+ * })
+ *
+ * const warnOnly = program.pipe(
+ *   Effect.provideService(References.MinimumLogLevel, "Warn")
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category filtering
+ */
+export const isEnabled = (self: LogLevel): Effect.Effect<boolean> =>
+  core.withFiber((fiber) => effect.succeed(!isGreaterThan(fiber.getRef(References.MinimumLogLevel), self)))

package/src/Logger.ts

@@ -115,8 +115,7 @@ import type { PlatformError } from "./PlatformError.ts"
 import * as Predicate from "./Predicate.ts"
 import { CurrentLogAnnotations, CurrentLogSpans } from "./References.ts"
 import type * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
-import type * as Types from "./Types.ts"
+import type * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/Logger"
 
@@ -144,8 +143,9 @@ const TypeId = "~effect/Logger"
  * @since 2.0.0
  * @category models
  */
-export interface Logger<in Message, out Output> extends Logger.Variance<Message, Output>, Pipeable {
-  log: (options: Logger.Options<Message>) => Output
+export interface Logger<in Message, out Output> extends Pipeable {
+  readonly [TypeId]: typeof TypeId
+  log(options: Options<Message>): Output
 }
 
 /**
@@ -153,100 +153,32 @@ export interface Logger<in Message, out Output> extends Logger.Variance<Message,
  * ```ts
  * import { Effect, Logger } from "effect"
  *
- * // Access Logger namespace types and functionality
- * const customLogger = Logger.make((options) => {
- *   console.log(`Message: ${options.message}`)
- *   console.log(`Level: ${options.logLevel}`)
- *   console.log(`Date: ${options.date.toISOString()}`)
- *   console.log(`Fiber ID: ${options.fiber.id}`)
+ * // Options interface provides all logging context
+ * const detailedLogger = Logger.make((options) => {
+ *   const output = {
+ *     message: options.message,
+ *     level: options.logLevel,
+ *     timestamp: options.date.toISOString(),
+ *     fiberId: options.fiber.id,
+ *     hasCause: options.cause !== undefined
+ *   }
+ *   console.log(JSON.stringify(output))
  * })
  *
- * // The Logger namespace contains types like Options, Variance, etc.
- * const program = Effect.log("Hello World").pipe(
- *   Effect.provide(Logger.layer([customLogger]))
+ * const program = Effect.log("Processing request").pipe(
+ *   Effect.provide(Logger.layer([detailedLogger]))
  * )
  * ```
  *
  * @since 2.0.0
  * @category models
  */
-export declare namespace Logger {
-  /**
-   * @example
-   * ```ts
-   * import { Logger } from "effect"
-   *
-   * // Variance interface defines contravariance for Message and covariance for Output
-   * const customLogger = Logger.make<unknown, void>((options) => {
-   *   console.log(options.message)
-   * })
-   *
-   * // The logger can accept more specific message types (contravariance)
-   * // and can be used where less specific output types are expected (covariance)
-   * ```
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<in Message, out Output> {
-    readonly [TypeId]: VarianceStruct<Message, Output>
-  }
-
-  /**
-   * @example
-   * ```ts
-   * import { Logger } from "effect"
-   *
-   * // VarianceStruct defines the actual variance structure used internally
-   * // This structure ensures proper typing and variance behavior
-   * const logger = Logger.make<unknown, void>((options) => {
-   *   console.log(options.message)
-   * })
-   *
-   * // The variance structure handles contravariance for input Message type
-   * // and covariance for output Output type
-   * ```
-   *
-   * @since 4.0.0
-   * @category models
-   */
-  export interface VarianceStruct<in Message, out Output> {
-    _Message: Types.Contravariant<Message>
-    _Output: Types.Covariant<Output>
-  }
-
-  /**
-   * @example
-   * ```ts
-   * import { Effect, Logger } from "effect"
-   *
-   * // Options interface provides all logging context
-   * const detailedLogger = Logger.make((options) => {
-   *   const output = {
-   *     message: options.message,
-   *     level: options.logLevel,
-   *     timestamp: options.date.toISOString(),
-   *     fiberId: options.fiber.id,
-   *     hasCause: options.cause !== undefined
-   *   }
-   *   console.log(JSON.stringify(output))
-   * })
-   *
-   * const program = Effect.log("Processing request").pipe(
-   *   Effect.provide(Logger.layer([detailedLogger]))
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Options<out Message> {
-    readonly message: Message
-    readonly logLevel: LogLevel.LogLevel
-    readonly cause: Cause.Cause<unknown>
-    readonly fiber: Fiber.Fiber<unknown, unknown>
-    readonly date: Date
-  }
+export interface Options<out Message> {
+  readonly message: Message
+  readonly logLevel: LogLevel.LogLevel
+  readonly cause: Cause.Cause<unknown>
+  readonly fiber: Fiber.Fiber<unknown, unknown>
+  readonly date: Date
 }
 
 /**
@@ -562,7 +494,7 @@ const format = (
   quoteValue: (s: string) => string,
   space?: number | string | undefined
 ) =>
-({ cause, date, fiber, logLevel, message }: Logger.Options<unknown>): string => {
+({ cause, date, fiber, logLevel, message }: Options<unknown>): string => {
   const formatValue = (value: string): string => value.match(textOnly) ? value : quoteValue(value)
   const format = (label: string, value: string): string => `${effect.formatLabel(label)}=${formatValue(value)}`
   const append = (label: string, value: string): string => " " + format(label, value)
@@ -636,7 +568,7 @@ const format = (
  * @category constructors
  */
 export const make: <Message, Output>(
-  log: (options: Logger.Options<Message>) => Output
+  log: (options: Options<Message>) => Output
 ) => Logger<Message, Output> = effect.loggerMake
 
 /**
@@ -975,7 +907,7 @@ export const batched = dual<
    */
   <Output>(
     options: {
-      readonly window: Duration.DurationInput
+      readonly window: Duration.Input
       readonly flush: (messages: Array<NoInfer<Output>>) => Effect.Effect<void>
     }
   ) => <Message>(
@@ -1036,14 +968,14 @@ export const batched = dual<
   <Message, Output>(
     self: Logger<Message, Output>,
     options: {
-      readonly window: Duration.DurationInput
+      readonly window: Duration.Input
       readonly flush: (messages: Array<NoInfer<Output>>) => Effect.Effect<void>
     }
   ) => Effect.Effect<Logger<Message, void>, never, Scope.Scope>
 >(2, <Message, Output>(
   self: Logger<Message, Output>,
   options: {
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly flush: (messages: Array<NoInfer<Output>>) => Effect.Effect<void>
   }
 ): Effect.Effect<Logger<Message, void>, never, Scope.Scope> =>
@@ -1389,7 +1321,7 @@ export const layer = <
   const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>
 >(
   loggers: Loggers,
-  options?: { mergeWithExisting: boolean }
+  options?: { readonly mergeWithExisting?: boolean | undefined } | undefined
 ): Layer.Layer<
   never,
   Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>,
@@ -1398,13 +1330,14 @@ export const layer = <
     Scope.Scope
   >
 > =>
-  Layer.effectServices(
+  Layer.effect(
+    CurrentLoggers,
     withFiber(effect.fnUntraced(function*(fiber) {
       const currentLoggers = new Set(options?.mergeWithExisting === true ? fiber.getRef(effect.CurrentLoggers) : [])
       for (const logger of loggers) {
         currentLoggers.add(isEffect(logger) ? yield* logger : logger)
       }
-      return ServiceMap.make(effect.CurrentLoggers, currentLoggers)
+      return currentLoggers
     }))
   )
 
@@ -1582,7 +1515,7 @@ export const toFile = dual<
     options?: {
       readonly flag?: FileSystem.OpenFlag | undefined
       readonly mode?: number | undefined
-      readonly batchWindow?: Duration.DurationInput | undefined
+      readonly batchWindow?: Duration.Input | undefined
     } | undefined
   ) => <Message>(
     self: Logger<Message, string>
@@ -1677,7 +1610,7 @@ export const toFile = dual<
     options?: {
       readonly flag?: FileSystem.OpenFlag | undefined
       readonly mode?: number | undefined
-      readonly batchWindow?: Duration.DurationInput | undefined
+      readonly batchWindow?: Duration.Input | undefined
     } | undefined
   ) => Effect.Effect<Logger<Message, void>, PlatformError, Scope.Scope | FileSystem.FileSystem>
 >(

package/src/ManagedRuntime.ts

@@ -140,8 +140,8 @@ export interface ManagedRuntime<in R, out ER> {
  * class Notifications extends ServiceMap.Service<Notifications, {
  *   readonly notify: (message: string) => Effect.Effect<void>
  * }>()("Notifications") {
- *   static layer = Layer.succeed(this)({
- *     notify: (message) => Console.log(message)
+ *   static readonly layer = Layer.succeed(this)({
+ *     notify: Effect.fn("Notifications.notify")((message) => Console.log(message))
  *   })
  * }
  *

package/src/Metric.ts

@@ -2035,12 +2035,12 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
   constructor(id: string, options: {
     readonly description?: string | undefined
     readonly attributes?: Metric.Attributes | undefined
-    readonly maxAge: Duration.DurationInput
+    readonly maxAge: Duration.Input
     readonly maxSize: number
     readonly quantiles: ReadonlyArray<number>
   }) {
     super(id, options?.description, attributesToRecord(options?.attributes))
-    this.#maxAge = Math.max(Duration.toMillis(Duration.fromDurationInputUnsafe(options.maxAge)), 0)
+    this.#maxAge = Math.max(Duration.toMillis(Duration.fromInputUnsafe(options.maxAge)), 0)
     this.#maxSize = options.maxSize
     this.#quantiles = options.quantiles
   }
@@ -2808,7 +2808,7 @@ export const histogram = (name: string, options: {
 export const summary = (name: string, options: {
   readonly description?: string | undefined
   readonly attributes?: Metric.Attributes | undefined
-  readonly maxAge: Duration.DurationInput
+  readonly maxAge: Duration.Input
   readonly maxSize: number
   readonly quantiles: ReadonlyArray<number>
 }): Summary<number> =>
@@ -2854,7 +2854,7 @@ export const summary = (name: string, options: {
 export const summaryWithTimestamp = (name: string, options: {
   readonly description?: string | undefined
   readonly attributes?: Metric.Attributes | undefined
-  readonly maxAge: Duration.DurationInput
+  readonly maxAge: Duration.Input
   readonly maxSize: number
   readonly quantiles: ReadonlyArray<number>
 }): Summary<[value: number, timestamp: number]> => new SummaryMetric(name, options)
@@ -4801,7 +4801,7 @@ export const FiberRuntimeMetricsImpl: FiberRuntimeMetricsService = {
  *     Effect.gen(function*() {
  *       yield* Effect.sleep(`${50 + id * 10} millis`)
  *       if (id % 7 === 0) {
- *         yield* Effect.fail(new AppError({ operation: `fetch-user-${id}` }))
+ *         return yield* new AppError({ operation: `fetch-user-${id}` })
  *       }
  *       return { id, name: `User ${id}`, email: `user${id}@example.com` }
  *     })
@@ -4940,9 +4940,7 @@ export const disableRuntimeMetricsLayer = Layer.succeed(FiberRuntimeMetrics)(und
  *         yield* Effect.sleep(`${100 + i * 50} millis`)
  *         if (i % 4 === 0) {
  *           // Simulate some failures
- *           yield* Effect.fail(
- *             new RuntimeMetricsError({ operation: `task-${i}` })
- *           )
+ *           return yield* new RuntimeMetricsError({ operation: `task-${i}` })
  *         }
  *         return `Task ${i} completed`
  *       }).pipe(