effect 4.0.0-beta.2 → 4.0.0-beta.20

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/LayerMap.ts

@@ -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>()
@@ -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,7 +140,7 @@ 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)({
+ *   static readonly layer = Layer.succeed(this)({
  *     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)