effect 4.0.0-beta.5 → 4.0.0-beta.51

package/src/LayerMap.ts

@@ -1,33 +1,35 @@
 /**
  * @since 3.14.0
  */
+import * as Context from "./Context.ts"
 import type * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import { identity } from "./Function.ts"
 import * as Layer from "./Layer.ts"
 import * as RcMap from "./RcMap.ts"
 import * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import type { Mutable, NoExcessProperties } from "./Types.ts"
 
 const TypeId = "~effect/LayerMap"
 
+type IdleTimeToLiveInput<K> = Duration.Input | ((key: K) => Duration.Input)
+
 /**
  * @since 3.14.0
  * @category Models
  * @example
  * ```ts
- * import { Effect, Layer, LayerMap, ServiceMap } from "effect"
+ * import { Effect, Layer, LayerMap, Context } from "effect"
  *
  * // Define a service key
- * const DatabaseService = ServiceMap.Service<{
+ * const DatabaseService = Context.Service<{
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>("Database")
  *
  * // 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}`))
  *   })
  * )
  *
@@ -38,8 +40,8 @@ const TypeId = "~effect/LayerMap"
  *   // Get a layer for a specific environment
  *   const devLayer = layerMap.get("development")
  *
- *   // Get services directly
- *   const services = yield* layerMap.services("production")
+ *   // Get context directly
+ *   const context = yield* layerMap.contextEffect("production")
  *
  *   // Invalidate a cached layer
  *   yield* layerMap.invalidate("development")
@@ -52,7 +54,7 @@ export interface LayerMap<in out K, in out I, in out E = never> {
   /**
    * The internal RcMap that stores the resources.
    */
-  readonly rcMap: RcMap.RcMap<K, ServiceMap.ServiceMap<I>, E>
+  readonly rcMap: RcMap.RcMap<K, Context.Context<I>, E>
 
   /**
    * Retrieves a Layer for the resources associated with the key.
@@ -60,9 +62,9 @@ export interface LayerMap<in out K, in out I, in out E = never> {
   get(key: K): Layer.Layer<I, E>
 
   /**
-   * Retrieves the services associated with the key.
+   * Retrieves the context associated with the key.
    */
-  services(key: K): Effect.Effect<ServiceMap.ServiceMap<I>, E, Scope.Scope>
+  contextEffect(key: K): Effect.Effect<Context.Context<I>, E, Scope.Scope>
 
   /**
    * Invalidates the resource associated with the key.
@@ -79,10 +81,10 @@ export interface LayerMap<in out K, in out I, in out E = never> {
  *
  * @example
  * ```ts
- * import { Effect, Layer, LayerMap, ServiceMap } from "effect"
+ * import { Effect, Layer, LayerMap, Context } from "effect"
  *
  * // Define a service key
- * const DatabaseService = ServiceMap.Service<{
+ * const DatabaseService = Context.Service<{
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>("Database")
  *
@@ -91,7 +93,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 +121,7 @@ export const make: <
 >(
   lookup: (key: K) => L,
   options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: IdleTimeToLiveInput<K> | undefined
     readonly preloadKeys?: PreloadKeys
   } | undefined
 ) => Effect.Effect<
@@ -129,16 +131,16 @@ 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?: IdleTimeToLiveInput<K> | undefined
   } | undefined
 ) {
-  const services = yield* Effect.services<never>()
-  const memoMap = Layer.CurrentMemoMap.getOrCreate(services)
+  const context = yield* Effect.context<never>()
+  const memoMap = Layer.CurrentMemoMap.getOrCreate(context)
 
   const rcMap = yield* RcMap.make({
     lookup: (key: K) =>
-      Effect.servicesWith((_: ServiceMap.ServiceMap<Scope.Scope>) =>
-        Layer.buildWithMemoMap(lookup(key), memoMap, ServiceMap.get(_, Scope.Scope))
+      Effect.contextWith((_: Context.Context<Scope.Scope>) =>
+        Layer.buildWithMemoMap(lookup(key), memoMap, Context.get(_, Scope.Scope))
       ),
     idleTimeToLive: options?.idleTimeToLive
   })
@@ -146,8 +148,8 @@ export const make: <
   return identity<LayerMap<K, I, any>>({
     [TypeId]: TypeId,
     rcMap,
-    get: (key) => Layer.effectServices(RcMap.get(rcMap, key)),
-    services: (key) => RcMap.get(rcMap, key),
+    get: (key) => Layer.effectContext(RcMap.get(rcMap, key)),
+    contextEffect: (key) => RcMap.get(rcMap, key),
     invalidate: (key) => RcMap.invalidate(rcMap, key)
   })
 })
@@ -157,24 +159,24 @@ export const make: <
  * @category Constructors
  * @example
  * ```ts
- * import { Effect, Layer, LayerMap, ServiceMap } from "effect"
+ * import { Effect, Layer, LayerMap, Context } from "effect"
  *
  * // Define service keys
- * const DevDatabase = ServiceMap.Service<{
+ * const DevDatabase = Context.Service<{
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>("DevDatabase")
  *
- * const ProdDatabase = ServiceMap.Service<{
+ * const ProdDatabase = Context.Service<{
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>("ProdDatabase")
  *
  * // 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 +200,7 @@ export const fromRecord = <
 >(
   layers: Layers,
   options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: IdleTimeToLiveInput<keyof Layers> | undefined
     readonly preload?: Preload | undefined
   } | undefined
 ): Effect.Effect<
@@ -228,7 +230,7 @@ export interface TagClass<
   in out R,
   in out LE,
   in out Deps extends Layer.Layer<any, any, any>
-> extends ServiceMap.ServiceClass<Self, Id, LayerMap<K, I, E>> {
+> extends Context.ServiceClass<Self, Id, LayerMap<K, I, E>> {
   /**
    * A default layer for the `LayerMap` service.
    */
@@ -250,9 +252,9 @@ export interface TagClass<
   readonly get: (key: K) => Layer.Layer<I, E, Self>
 
   /**
-   * Retrieves the services associated with the key.
+   * Retrieves the context associated with the key.
    */
-  readonly services: (key: K) => Effect.Effect<ServiceMap.ServiceMap<I>, E, Scope.Scope | Self>
+  readonly contextEffect: (key: K) => Effect.Effect<Context.Context<I>, E, Scope.Scope | Self>
 
   /**
    * Invalidates the resource associated with the key.
@@ -269,10 +271,10 @@ export interface TagClass<
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, LayerMap, ServiceMap } from "effect"
+ * import { Console, Effect, Layer, LayerMap, Context } from "effect"
  *
  * // Define a service key
- * const Greeter = ServiceMap.Service<{
+ * const Greeter = Context.Service<{
  *   readonly greet: Effect.Effect<string>
  * }>("Greeter")
  *
@@ -309,7 +311,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?: IdleTimeToLiveInput<any> | undefined
       readonly preloadKeys?:
         | Iterable<Options extends { readonly lookup: (key: infer K) => any } ? K : never>
         | undefined
@@ -317,7 +319,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?: IdleTimeToLiveInput<any> | undefined
       readonly preload?: boolean | undefined
     }, Options>
 >(
@@ -346,7 +348,7 @@ export const Service = <Self>() =>
 
   function TagClass() {}
   const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, string, any, any, any, any, any>>
-  Object.setPrototypeOf(TagClass, Object.getPrototypeOf(ServiceMap.Service<Self, any>(id)))
+  Object.setPrototypeOf(TagClass, Object.getPrototypeOf(Context.Service<Self, any>(id)))
   TagClass.key = id
   Object.defineProperty(TagClass, "stack", {
     get() {
@@ -364,7 +366,8 @@ export const Service = <Self>() =>
     TagClass_.layerNoDeps
 
   TagClass_.get = (key: string) => Layer.unwrap(Effect.map(TagClass_.asEffect(), (layerMap) => layerMap.get(key)))
-  TagClass_.services = (key: string) => Effect.flatMap(TagClass_.asEffect(), (layerMap) => layerMap.services(key))
+  TagClass_.contextEffect = (key: string) =>
+    Effect.flatMap(TagClass_.asEffect(), (layerMap) => layerMap.contextEffect(key))
   TagClass_.invalidate = (key: string) => Effect.flatMap(TagClass_.asEffect(), (layerMap) => layerMap.invalidate(key))
 
   return TagClass as any

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

@@ -100,6 +100,7 @@
  */
 import * as Array from "./Array.ts"
 import type * as Cause from "./Cause.ts"
+import type * as Context from "./Context.ts"
 import type * as Duration from "./Duration.ts"
 import type * as Effect from "./Effect.ts"
 import type * as Fiber from "./Fiber.ts"
@@ -115,8 +116,6 @@ 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"
 
 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
 }
 
 /**
@@ -294,13 +226,13 @@ export const isLogger = (u: unknown): u is Logger<unknown, unknown> => Predicate
  * @since 4.0.0
  * @category references
  */
-export const CurrentLoggers: ServiceMap.Reference<ReadonlySet<Logger<unknown, any>>> = effect.CurrentLoggers
+export const CurrentLoggers: Context.Reference<ReadonlySet<Logger<unknown, any>>> = effect.CurrentLoggers
 
 /**
  * @since 4.0.0
  * @category references
  */
-export const LogToStderr: ServiceMap.Reference<boolean> = effect.LogToStderr
+export const LogToStderr: Context.Reference<boolean> = effect.LogToStderr
 
 /**
  * Transforms the output of a `Logger` using the provided function.
@@ -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>
 >(