effect 4.0.0-beta.42 → 4.0.0-beta.44

package/src/LayerMap.ts

@@ -1,13 +1,13 @@
 /**
  * @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"
@@ -19,10 +19,10 @@ type IdleTimeToLiveInput<K> = Duration.Input | ((key: K) => Duration.Input)
  * @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")
  *
@@ -40,8 +40,8 @@ type IdleTimeToLiveInput<K> = Duration.Input | ((key: K) => Duration.Input)
  *   // 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")
@@ -54,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.
@@ -62,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.
@@ -81,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")
  *
@@ -134,13 +134,13 @@ export const make: <
     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
   })
@@ -148,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)
   })
 })
@@ -159,14 +159,14 @@ 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")
  *
@@ -230,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.
    */
@@ -252,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.
@@ -271,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")
  *
@@ -348,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() {
@@ -366,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/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,7 +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 type * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/Logger"
 
@@ -226,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.

package/src/ManagedRuntime.ts

@@ -1,13 +1,13 @@
 /**
  * @since 2.0.0
  */
+import type * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
 import * as Layer from "./Layer.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Scope from "./Scope.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 import type { Mutable } from "./Types.ts"
 
 const TypeId = "~effect/ManagedRuntime"
@@ -45,13 +45,13 @@ export declare namespace ManagedRuntime {
 export interface ManagedRuntime<in R, out ER> {
   readonly [TypeId]: typeof TypeId
   readonly memoMap: Layer.MemoMap
-  readonly servicesEffect: Effect.Effect<ServiceMap.ServiceMap<R>, ER>
-  readonly services: () => Promise<ServiceMap.ServiceMap<R>>
+  readonly contextEffect: Effect.Effect<Context.Context<R>, ER>
+  readonly context: () => Promise<Context.Context<R>>
 
   // internal
   readonly scope: Scope.Closeable
   // internal
-  cachedServices: ServiceMap.ServiceMap<R> | undefined
+  cachedContext: Context.Context<R> | undefined
 
   /**
    * Executes the effect using the provided Scheduler or using the global
@@ -135,9 +135,9 @@ export interface ManagedRuntime<in R, out ER> {
  * @category runtime class
  * @example
  * ```ts
- * import { Console, Effect, Layer, ManagedRuntime, ServiceMap } from "effect"
+ * import { Console, Effect, Layer, ManagedRuntime, Context } from "effect"
  *
- * class Notifications extends ServiceMap.Service<Notifications, {
+ * class Notifications extends Context.Service<Notifications, {
  *   readonly notify: (message: string) => Effect.Effect<void>
  * }>()("Notifications") {
  *   static readonly layer = Layer.succeed(this)({
@@ -181,15 +181,15 @@ export const make = <R, ER>(
           defaultRunOptions.onFiberStart
       }
       : defaultRunOptions as O
-  let buildFiber: Fiber.Fiber<ServiceMap.ServiceMap<R>, ER> | undefined
-  const servicesEffect = Effect.withFiber<ServiceMap.ServiceMap<R>, ER>((fiber) => {
+  let buildFiber: Fiber.Fiber<Context.Context<R>, ER> | undefined
+  const contextEffect = Effect.withFiber<Context.Context<R>, ER>((fiber) => {
     if (!buildFiber) {
       buildFiber = Effect.runFork(
         Effect.tap(
           Layer.buildWithMemoMap(layer, memoMap, layerScope),
-          (services) =>
+          (context) =>
             Effect.sync(() => {
-              self.cachedServices = services
+              self.cachedContext = context
             })
         ),
         { ...defaultRunOptions, scheduler: fiber.currentScheduler }
@@ -201,25 +201,25 @@ export const make = <R, ER>(
     [TypeId]: TypeId,
     memoMap,
     scope,
-    servicesEffect,
-    cachedServices: undefined,
-    services() {
-      return self.cachedServices === undefined ?
-        Effect.runPromise(self.servicesEffect) :
-        Promise.resolve(self.cachedServices)
+    contextEffect: contextEffect,
+    cachedContext: undefined,
+    context() {
+      return self.cachedContext === undefined ?
+        Effect.runPromise(self.contextEffect) :
+        Promise.resolve(self.cachedContext)
     },
     dispose(): Promise<void> {
       return Effect.runPromise(self.disposeEffect)
     },
     disposeEffect: Effect.suspend(() => {
-      ;(self as Mutable<ManagedRuntime<R, ER>>).servicesEffect = Effect.die("ManagedRuntime disposed")
-      self.cachedServices = undefined
+      ;(self as Mutable<ManagedRuntime<R, ER>>).contextEffect = Effect.die("ManagedRuntime disposed")
+      self.cachedContext = undefined
       return Scope.close(self.scope, Exit.void)
     }),
     runFork<A, E>(effect: Effect.Effect<A, E, R>, options?: Effect.RunOptions): Fiber.Fiber<A, E | ER> {
-      return self.cachedServices === undefined ?
+      return self.cachedContext === undefined ?
         Effect.runFork(provide(self, effect), mergeRunOptions(options)) :
-        Effect.runForkWith(self.cachedServices)(effect, mergeRunOptions(options))
+        Effect.runForkWith(self.cachedContext)(effect, mergeRunOptions(options))
     },
     runCallback<A, E>(
       effect: Effect.Effect<A, E, R>,
@@ -227,31 +227,31 @@ export const make = <R, ER>(
         readonly onExit: (exit: Exit.Exit<A, E | ER>) => void
       }
     ): (interruptor?: number | undefined) => void {
-      return self.cachedServices === undefined ?
+      return self.cachedContext === undefined ?
         Effect.runCallback(provide(self, effect), mergeRunOptions(options)) :
-        Effect.runCallbackWith(self.cachedServices)(effect, mergeRunOptions(options))
+        Effect.runCallbackWith(self.cachedContext)(effect, mergeRunOptions(options))
     },
     runSyncExit<A, E>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E | ER> {
-      return self.cachedServices === undefined ?
+      return self.cachedContext === undefined ?
         Effect.runSyncExit(provide(self, effect)) :
-        Effect.runSyncExitWith(self.cachedServices)(effect)
+        Effect.runSyncExitWith(self.cachedContext)(effect)
     },
     runSync<A, E>(effect: Effect.Effect<A, E, R>): A {
-      return self.cachedServices === undefined ?
+      return self.cachedContext === undefined ?
         Effect.runSync(provide(self, effect)) :
-        Effect.runSyncWith(self.cachedServices)(effect)
+        Effect.runSyncWith(self.cachedContext)(effect)
     },
     runPromiseExit<A, E>(effect: Effect.Effect<A, E, R>, options?: Effect.RunOptions): Promise<Exit.Exit<A, E | ER>> {
-      return self.cachedServices === undefined ?
+      return self.cachedContext === undefined ?
         Effect.runPromiseExit(provide(self, effect), mergeRunOptions(options)) :
-        Effect.runPromiseExitWith(self.cachedServices)(effect, mergeRunOptions(options))
+        Effect.runPromiseExitWith(self.cachedContext)(effect, mergeRunOptions(options))
     },
     runPromise<A, E>(effect: Effect.Effect<A, E, R>, options?: {
       readonly signal?: AbortSignal | undefined
     }): Promise<A> {
-      return self.cachedServices === undefined ?
+      return self.cachedContext === undefined ?
         Effect.runPromise(provide(self, effect), mergeRunOptions(options)) :
-        Effect.runPromiseWith(self.cachedServices)(effect, mergeRunOptions(options))
+        Effect.runPromiseWith(self.cachedContext)(effect, mergeRunOptions(options))
     }
   }
   return self
@@ -262,7 +262,7 @@ function provide<R, ER, A, E>(
   effect: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E | ER> {
   return Effect.flatMap(
-    managed.servicesEffect,
-    (services) => Effect.provideServices(effect, services)
+    managed.contextEffect,
+    (context) => Effect.provideContext(effect, context)
   )
 }