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

package/dist/Layer.js

@@ -1,3 +1,4 @@
+import * as Context from "./Context.js";
 import * as Deferred from "./Deferred.js";
 import { constant, constTrue, constUndefined, dual, identity } from "./Function.js";
 import * as core from "./internal/core.js";
@@ -7,7 +8,6 @@ import { pipeArguments } from "./Pipeable.js";
 import { hasProperty } from "./Predicate.js";
 import { CurrentStackFrame } from "./References.js";
 import * as Scope from "./Scope.js";
-import * as ServiceMap from "./ServiceMap.js";
 import * as Tracer from "./Tracer.js";
 const TypeId = "~effect/Layer";
 const MemoMapTypeId = "~effect/Layer/MemoMap";
@@ -16,14 +16,14 @@ const MemoMapTypeId = "~effect/Layer/MemoMap";
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const dbLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed("result")
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
  * const notALayer = { someProperty: "value" }
  *
@@ -58,15 +58,15 @@ const fromBuildUnsafe = build => {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const databaseLayer = Layer.fromBuild(() =>
  *   Effect.sync(() =>
- *     ServiceMap.make(Database, {
+ *     Context.make(Database, {
  *       query: (sql: string) => Effect.succeed("result")
  *     })
  *   )
@@ -89,15 +89,15 @@ export const fromBuild = build => fromBuildUnsafe((memoMap, scope) => {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const databaseLayer = Layer.fromBuildMemo(() =>
  *   Effect.sync(() =>
- *     ServiceMap.make(Database, {
+ *     Context.make(Database, {
  *       query: (sql: string) => Effect.succeed("result")
  *     })
  *   )
@@ -148,9 +148,9 @@ class MemoMapImpl {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -160,11 +160,11 @@ class MemoMapImpl {
  *   const scope = yield* Effect.scope
  *
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const services = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const context = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
- *   return ServiceMap.get(services, Database)
+ *   return Context.get(context, Database)
  * })
  * ```
  *
@@ -177,9 +177,9 @@ export const makeMemoMapUnsafe = () => new MemoMapImpl();
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -189,11 +189,11 @@ export const makeMemoMapUnsafe = () => new MemoMapImpl();
  *   const scope = yield* Effect.scope
  *
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const services = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const context = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
- *   return ServiceMap.get(services, Database)
+ *   return Context.get(context, Database)
  * })
  * ```
  *
@@ -210,8 +210,8 @@ export const makeMemoMap = /*#__PURE__*/internalEffect.sync(makeMemoMapUnsafe);
  * @since 3.13.0
  * @category models
  */
-export class CurrentMemoMap extends /*#__PURE__*/ServiceMap.Service()("effect/Layer/CurrentMemoMap") {
-  static getOrCreate = /*#__PURE__*/ServiceMap.getOrElse(this, makeMemoMapUnsafe);
+export class CurrentMemoMap extends /*#__PURE__*/Context.Service()("effect/Layer/CurrentMemoMap") {
+  static getOrCreate = /*#__PURE__*/Context.getOrElse(this, makeMemoMapUnsafe);
 }
 /**
  * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
@@ -219,13 +219,13 @@ export class CurrentMemoMap extends /*#__PURE__*/ServiceMap.Service()("effect/La
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -236,23 +236,23 @@ export class CurrentMemoMap extends /*#__PURE__*/ServiceMap.Service()("effect/La
  *
  *   // Build database layer with memoization
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const dbServices = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const dbContext = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
  *   // Build logger layer with same memoization (reuses memo if same layer)
  *   const loggerLayer = Layer.succeed(Logger)({
- *     log: (msg: string) => Effect.sync(() => console.log(msg))
+ *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  *   })
- *   const loggerServices = yield* Layer.buildWithMemoMap(
+ *   const loggerContext = yield* Layer.buildWithMemoMap(
  *     loggerLayer,
  *     memoMap,
  *     scope
  *   )
  *
  *   return {
- *     database: ServiceMap.get(dbServices, Database),
- *     logger: ServiceMap.get(loggerServices, Logger)
+ *     database: Context.get(dbContext, Database),
+ *     logger: Context.get(loggerContext, Logger)
  *   }
  * })
  * ```
@@ -260,29 +260,29 @@ export class CurrentMemoMap extends /*#__PURE__*/ServiceMap.Service()("effect/La
  * @since 2.0.0
  * @category memo map
  */
-export const buildWithMemoMap = /*#__PURE__*/dual(3, (self, memoMap, scope) => internalEffect.provideService(internalEffect.map(self.build(memoMap, scope), ServiceMap.add(CurrentMemoMap, memoMap)), CurrentMemoMap, memoMap));
+export const buildWithMemoMap = /*#__PURE__*/dual(3, (self, memoMap, scope) => internalEffect.provideService(internalEffect.map(self.build(memoMap, scope), Context.add(CurrentMemoMap, memoMap)), CurrentMemoMap, memoMap));
 /**
  * Builds a layer into a scoped value.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * // Build a layer to get its services
  * const program = Effect.gen(function*() {
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
  *
- *   // Build the layer into ServiceMap - automatically manages scope and memoization
- *   const services = yield* Layer.build(dbLayer)
+ *   // Build the layer into Context - automatically manages scope and memoization
+ *   const context = yield* Layer.build(dbLayer)
  *
  *   // Extract the specific service from the built layer
- *   const database = ServiceMap.get(services, Database)
+ *   const database = Context.get(context, Database)
  *
  *   return yield* database.query("SELECT * FROM users")
  * })
@@ -291,7 +291,7 @@ export const buildWithMemoMap = /*#__PURE__*/dual(3, (self, memoMap, scope) => i
  * @since 2.0.0
  * @category destructors
  */
-export const build = self => core.withFiber(fiber => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.services), ServiceMap.getUnsafe(fiber.services, Scope.Scope)));
+export const build = self => core.withFiber(fiber => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.context), Context.getUnsafe(fiber.context, Scope.Scope)));
 /**
  * Builds a layer into an `Effect` value. Any resources associated with this
  * layer will be released when the specified scope is closed unless their scope
@@ -301,9 +301,9 @@ export const build = self => core.withFiber(fiber => buildWithMemoMap(self, Curr
  *
  * @example
  * ```ts
- * import { Effect, Layer, Scope, ServiceMap } from "effect"
+ * import { Effect, Layer, Scope, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -317,12 +317,12 @@ export const build = self => core.withFiber(fiber => buildWithMemoMap(self, Curr
  *       scope,
  *       Effect.sync(() => console.log("Database closed"))
  *     )
- *     return { query: (sql: string) => Effect.succeed(`Result: ${sql}`) }
+ *     return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
  *   }))
  *
  *   // Build with specific scope - resources tied to this scope
- *   const services = yield* Layer.buildWithScope(dbLayer, scope)
- *   const database = ServiceMap.get(services, Database)
+ *   const context = yield* Layer.buildWithScope(dbLayer, scope)
+ *   const database = Context.get(context, Database)
  *
  *   return yield* database.query("SELECT * FROM users")
  *   // Database will be closed when scope is closed
@@ -332,29 +332,29 @@ export const build = self => core.withFiber(fiber => buildWithMemoMap(self, Curr
  * @since 2.0.0
  * @category destructors
  */
-export const buildWithScope = /*#__PURE__*/dual(2, (self, scope) => core.withFiber(fiber => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.services), scope)));
+export const buildWithScope = /*#__PURE__*/dual(2, (self, scope) => core.withFiber(fiber => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.context), scope)));
 /**
  * Constructs a layer from the specified value.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * // Create layers from concrete service implementations
  * const databaseLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed(`Query result: ${sql}`)
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Query result: ${sql}`))
  * })
  *
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
  * })
  *
  * // Use the layers in a program
@@ -377,47 +377,46 @@ export const buildWithScope = /*#__PURE__*/dual(2, (self, scope) => core.withFib
  */
 export const succeed = function () {
   if (arguments.length === 1) {
-    return resource => succeedServices(ServiceMap.make(arguments[0], resource));
+    return resource => succeedContext(Context.make(arguments[0], resource));
   }
-  return succeedServices(ServiceMap.make(arguments[0], arguments[1]));
+  return succeedContext(Context.make(arguments[0], arguments[1]));
 };
 /**
  * Constructs a layer from the specified value, which must return one or more
  * services.
  *
  * This is a more general version of `succeed` that allows you to provide multiple
- * services at once through a `ServiceMap`.
+ * services at once through a `Context`.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
- * const services = ServiceMap.make(Database, {
- *   query: (sql: string) => Effect.succeed("result")
- * })
- *   .pipe(
- *     ServiceMap.add(Logger, {
- *       log: (msg: string) => Effect.sync(() => console.log(msg))
- *     })
- *   )
+ * const context = Context.make(Database, {
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
+ * }).pipe(
+ *   Context.add(Logger, {
+ *     log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   })
+ * )
  *
- * const layer = Layer.succeedServices(services)
+ * const layer = Layer.succeedContext(context)
  * ```
  *
  * @since 2.0.0
  * @category constructors
  */
-export const succeedServices = services => fromBuildUnsafe(constant(internalEffect.succeed(services)));
+export const succeedContext = context => fromBuildUnsafe(constant(internalEffect.succeed(context)));
 /**
- * A Layer that constructs an empty ServiceMap.
+ * A Layer that constructs an empty Context.
  *
  * This layer provides no services and can be used as a neutral element
  * in layer composition or as a starting point for building layers.
@@ -432,7 +431,7 @@ export const succeedServices = services => fromBuildUnsafe(constant(internalEffe
  * @since 2.0.0
  * @category constructors
  */
-export const empty = /*#__PURE__*/succeedServices(/*#__PURE__*/ServiceMap.empty());
+export const empty = /*#__PURE__*/succeedContext(/*#__PURE__*/Context.empty());
 /**
  * Lazily constructs a layer from the specified value.
  *
@@ -441,9 +440,9 @@ export const empty = /*#__PURE__*/succeedServices(/*#__PURE__*/ServiceMap.empty(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -457,27 +456,27 @@ export const empty = /*#__PURE__*/succeedServices(/*#__PURE__*/ServiceMap.empty(
  */
 export const sync = function () {
   if (arguments.length === 1) {
-    return evaluate => syncServices(() => ServiceMap.make(arguments[0], evaluate()));
+    return evaluate => syncContext(() => Context.make(arguments[0], evaluate()));
   }
-  return syncServices(() => ServiceMap.make(arguments[0], arguments[1]()));
+  return syncContext(() => Context.make(arguments[0], arguments[1]()));
 };
 /**
  * Lazily constructs a layer from the specified value, which must return one or more
  * services.
  *
- * This is a lazy version of `succeedServices` where the ServiceMap is computed
+ * This is a lazy version of `succeedContext` where the Context is computed
  * synchronously only when the layer is built.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * const layer = Layer.syncServices(() =>
- *   ServiceMap.make(Database, {
+ * const layer = Layer.syncContext(() =>
+ *   Context.make(Database, {
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   })
  * )
@@ -486,7 +485,7 @@ export const sync = function () {
  * @since 2.0.0
  * @category constructors
  */
-export const syncServices = evaluate => fromBuildMemo(constant(internalEffect.sync(evaluate)));
+export const syncContext = evaluate => fromBuildMemo(constant(internalEffect.sync(evaluate)));
 /**
  * Constructs a layer from the specified scoped effect.
  *
@@ -502,9 +501,9 @@ export const syncServices = evaluate => fromBuildMemo(constant(internalEffect.sy
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -524,7 +523,7 @@ export const effect = function () {
   }
   return effectImpl(arguments[0], arguments[1]);
 };
-const effectImpl = (service, effect) => effectServices(internalEffect.map(effect, value => ServiceMap.make(service, value)));
+const effectImpl = (service, effect) => effectContext(internalEffect.map(effect, value => Context.make(service, value)));
 /**
  * Constructs a layer from the specified scoped effect, which must return one
  * or more services.
@@ -534,15 +533,15 @@ const effectImpl = (service, effect) => effectServices(internalEffect.map(effect
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<
+ * class Database extends Context.Service<
  *   Database,
  *   { readonly query: (sql: string) => Effect.Effect<string> }
  * >()("Database") {}
  *
- * const layer = Layer.effectServices(
- *   Effect.succeed(ServiceMap.make(Database, {
+ * const layer = Layer.effectContext(
+ *   Effect.succeed(Context.make(Database, {
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   }))
  * )
@@ -551,7 +550,7 @@ const effectImpl = (service, effect) => effectServices(internalEffect.map(effect
  * @since 2.0.0
  * @category constructors
  */
-export const effectServices = effect => fromBuildMemo((_, scope) => Scope.provide(effect, scope));
+export const effectContext = effect => fromBuildMemo((_, scope) => Scope.provide(effect, scope));
 /**
  * Constructs a layer from the specified scoped effect.
  *
@@ -578,7 +577,32 @@ export const effectServices = effect => fromBuildMemo((_, scope) => Scope.provid
  * @since 2.0.0
  * @category constructors
  */
-export const effectDiscard = effect => effectServices(internalEffect.as(effect, ServiceMap.empty()));
+export const effectDiscard = effect => effectContext(internalEffect.as(effect, Context.empty()));
+/**
+ * Lazily constructs a layer using the specified factory.
+ *
+ * The factory is evaluated only when the suspended layer is first built, and
+ * the result is memoized with normal layer sharing semantics.
+ *
+ * @example
+ * ```ts
+ * import { Layer, Context } from "effect"
+ *
+ * class Config extends Context.Service<Config, string>()("Config") {}
+ *
+ * const useProd = true
+ *
+ * const layer = Layer.suspend(() =>
+ *   useProd
+ *     ? Layer.succeed(Config)("https://api.example.com")
+ *     : Layer.succeed(Config)("http://localhost:3000")
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const suspend = evaluate => fromBuildMemo((memoMap, scope) => internalEffect.suspend(() => evaluate().build(memoMap, scope)));
 /**
  * Unwraps a Layer from an Effect, flattening the nested structure.
  *
@@ -588,14 +612,14 @@ export const effectDiscard = effect => effectServices(internalEffect.as(effect,
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const layerEffect = Effect.succeed(
- *   Layer.succeed(Database)({ query: (sql: string) => Effect.succeed("result") })
+ *   Layer.succeed(Database)({ query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result")) })
  * )
  *
  * const unwrappedLayer = Layer.unwrap(layerEffect)
@@ -605,14 +629,14 @@ export const effectDiscard = effect => effectServices(internalEffect.as(effect,
  * @category utils
  */
 export const unwrap = self => {
-  const service = ServiceMap.Service("effect/Layer/unwrap");
-  return flatMap(effect(service)(self), ServiceMap.get(service));
+  const service = Context.Service("effect/Layer/unwrap");
+  return flatMap(effect(service)(self), Context.get(service));
 };
 const mergeAllEffect = (layers, memoMap, scope) => {
   const parentScope = Scope.forkUnsafe(scope, "parallel");
   return internalEffect.forEach(layers, layer => layer.build(memoMap, Scope.forkUnsafe(parentScope, "sequential")), {
     concurrency: layers.length
-  }).pipe(internalEffect.map(services => ServiceMap.mergeAll(...services)));
+  }).pipe(internalEffect.map(context => Context.mergeAll(...context)));
 };
 /**
  * Combines all the provided layers concurrently, creating a new layer with merged input, error, and output types.
@@ -622,21 +646,21 @@ const mergeAllEffect = (layers, memoMap, scope) => {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * const dbLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed("result")
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  * })
  *
  * const mergedLayer = Layer.mergeAll(dbLayer, loggerLayer)
@@ -654,21 +678,21 @@ export const mergeAll = (...layers) => fromBuild((memoMap, scope) => mergeAllEff
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * const dbLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed("result")
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  * })
  *
  * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
@@ -678,7 +702,7 @@ export const mergeAll = (...layers) => fromBuild((memoMap, scope) => mergeAllEff
  * @category zipping
  */
 export const merge = /*#__PURE__*/dual(2, (self, that) => mergeAll(self, ...(Array.isArray(that) ? that : [that])));
-const provideWith = (self, that, f) => fromBuild((memoMap, scope) => internalEffect.flatMap(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), context => self.build(memoMap, scope).pipe(internalEffect.provideServices(context), internalEffect.map(merged => f(merged, context)))));
+const provideWith = (self, that, f) => fromBuild((memoMap, scope) => internalEffect.flatMap(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), context => self.build(memoMap, scope).pipe(internalEffect.provideContext(context), internalEffect.map(merged => f(merged, context)))));
 /**
  * Feeds the output services of this builder into the input of the specified
  * builder, resulting in a new builder with the inputs of this builder as
@@ -686,30 +710,30 @@ const provideWith = (self, that, f) => fromBuild((memoMap, scope) => internalEff
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class UserService extends ServiceMap.Service<UserService, {
+ * class UserService extends Context.Service<UserService, {
  *   readonly getUser: (id: string) => Effect.Effect<{
  *     id: string
  *     name: string
  *   }>
  * }>()("UserService") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * // Create dependency layers
  * const databaseLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  * })
  *
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
  * })
  *
  * // UserService depends on Database and Logger
@@ -718,8 +742,7 @@ const provideWith = (self, that, f) => fromBuild((memoMap, scope) => internalEff
  *   const logger = yield* Logger
  *
  *   return {
- *     getUser: (id: string) =>
- *       Effect.gen(function*() {
+ *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
  *         yield* logger.log(`Looking up user ${id}`)
  *         const result = yield* database.query(
  *           `SELECT * FROM users WHERE id = ${id}`
@@ -754,17 +777,17 @@ export const provide = /*#__PURE__*/dual(2, (self, that) => provideWith(self, th
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
- * class UserService extends ServiceMap.Service<UserService, {
+ * class UserService extends Context.Service<UserService, {
  *   readonly getUser: (id: string) => Effect.Effect<{
  *     id: string
  *     name: string
@@ -773,11 +796,11 @@ export const provide = /*#__PURE__*/dual(2, (self, that) => provideWith(self, th
  *
  * // Create dependency layers
  * const databaseLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  * })
  *
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
  * })
  *
  * // UserService depends on Database and Logger
@@ -786,8 +809,7 @@ export const provide = /*#__PURE__*/dual(2, (self, that) => provideWith(self, th
  *   const logger = yield* Logger
  *
  *   return {
- *     getUser: (id: string) =>
- *       Effect.gen(function*() {
+ *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
  *         yield* logger.log(`Looking up user ${id}`)
  *         const result = yield* database.query(
  *           `SELECT * FROM users WHERE id = ${id}`
@@ -820,24 +842,24 @@ export const provide = /*#__PURE__*/dual(2, (self, that) => provideWith(self, th
  * @since 2.0.0
  * @category utils
  */
-export const provideMerge = /*#__PURE__*/dual(2, (self, that) => provideWith(self, that, (self, that) => ServiceMap.merge(that, self)));
+export const provideMerge = /*#__PURE__*/dual(2, (self, that) => provideWith(self, that, (self, that) => Context.merge(that, self)));
 /**
  * Constructs a layer dynamically based on the output of this layer.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Config extends ServiceMap.Service<Config, {
+ * class Config extends Context.Service<Config, {
  *   readonly dbUrl: string
  *   readonly logLevel: string
  * }>()("Config") {}
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -849,23 +871,24 @@ export const provideMerge = /*#__PURE__*/dual(2, (self, that) => provideWith(sel
  *
  * // Dynamically create services based on config
  * const dynamicServiceLayer = configLayer.pipe(
- *   Layer.flatMap((services) => {
- *     const config = ServiceMap.get(services, Config)
+ *   Layer.flatMap((context) => {
+ *     const config = Context.get(context, Config)
  *
  *     // Create database layer based on config
  *     const dbLayer = Layer.succeed(Database)({
- *       query: (sql: string) =>
+ *       query: Effect.fn("Database.query")((sql: string) =>
  *         Effect.succeed(
  *           `Querying ${config.dbUrl}: ${sql}`
- *         )
+ *         ))
  *     })
  *
  *     // Create logger layer based on config
  *     const loggerLayer = Layer.succeed(Logger)({
- *       log: (msg: string) =>
+ *       log: Effect.fn("Logger.log")((msg: string) =>
  *         config.logLevel === "debug"
  *           ? Effect.sync(() => console.log(`[DEBUG] ${msg}`))
  *           : Effect.sync(() => console.log(msg))
+ *       )
  *     })
  *
  *     // Return combined layer
@@ -891,19 +914,46 @@ export const provideMerge = /*#__PURE__*/dual(2, (self, that) => provideWith(sel
  * @category sequencing
  */
 export const flatMap = /*#__PURE__*/dual(2, (self, f) => fromBuild((memoMap, scope) => internalEffect.flatMap(self.build(memoMap, scope), context => f(context).build(memoMap, scope))));
+/**
+ * Performs the specified effect if this layer succeeds.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export const tap = /*#__PURE__*/dual(2, (self, f) => fromBuild((memoMap, scope) => internalEffect.flatMap(self.build(memoMap, scope), context => Scope.provide(internalEffect.as(f(context), context), scope))));
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export const tapError = /*#__PURE__*/dual(2, (self, f) => fromBuild((memoMap, scope) => internalEffect.catch_(self.build(memoMap, scope), error => Scope.provide(internalEffect.andThen(f(error), internalEffect.fail(error)), scope))));
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Layer.tapErrorCause`
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export const tapCause = /*#__PURE__*/dual(2, (self, f) => fromBuild((memoMap, scope) => internalEffect.catchCause(self.build(memoMap, scope), cause => Scope.provide(internalEffect.andThen(f(cause), internalEffect.failCause(cause)), scope))));
 /**
  * Translates effect failure into death of the fiber, making all failures
  * unchecked and not a part of the type of the layer.
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class DatabaseError extends Data.TaggedError("DatabaseError")<{
  *   message: string
  * }> {}
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -912,10 +962,10 @@ export const flatMap = /*#__PURE__*/dual(2, (self, f) => fromBuild((memoMap, sco
  *   // Simulate a database connection that might fail
  *   const shouldFail = Math.random() > 0.5
  *   if (shouldFail) {
- *     yield* Effect.fail(new DatabaseError({ message: "Connection failed" }))
+ *     return yield* new DatabaseError({ message: "Connection failed" })
  *   }
  *
- *   return { query: (sql: string) => Effect.succeed(`Result: ${sql}`) }
+ *   return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
  * }))
  *
  * // Convert failures to fiber death - removes error from type
@@ -951,11 +1001,11 @@ catch_ as catch };
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class ConfigError extends Data.TaggedError("ConfigError") {}
  *
- * class Config extends ServiceMap.Service<Config, {
+ * class Config extends Context.Service<Config, {
  *   readonly apiUrl: string
  * }>()("Config") {}
  *
@@ -977,7 +1027,7 @@ export const catchTag = /*#__PURE__*/dual(3, (self, k, f) => fromBuildUnsafe((me
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class DatabaseError extends Data.TaggedError("DatabaseError")<{
  *   message: string
@@ -987,18 +1037,18 @@ export const catchTag = /*#__PURE__*/dual(3, (self, k, f) => fromBuildUnsafe((me
  *   reason: string
  * }> {}
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * // Primary database layer that might fail
  * const primaryDatabaseLayer = Layer.effect(Database)(Effect.gen(function*() {
- *   yield* Effect.fail(new DatabaseError({ message: "Primary DB unreachable" }))
- *   return { query: (sql: string) => Effect.succeed(`Primary: ${sql}`) }
+ *   return yield* new DatabaseError({ message: "Primary DB unreachable" })
+ *   return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Primary: ${sql}`)) }
  * }))
  *
  * // Fallback layers for different error causes
@@ -1007,11 +1057,12 @@ export const catchTag = /*#__PURE__*/dual(3, (self, k, f) => fromBuildUnsafe((me
  *     // For any cause/error, fallback to in-memory database
  *     return Layer.mergeAll(
  *       Layer.succeed(Database)({
- *         query: (sql: string) => Effect.succeed(`Memory: ${sql}`)
+ *         query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Memory: ${sql}`))
  *       }),
  *       Layer.succeed(Logger)({
- *         log: (msg: string) =>
+ *         log: Effect.fn("Logger.log")((msg: string) =>
  *           Effect.sync(() => console.log(`[FALLBACK] ${msg}`))
+ *         )
  *       })
  *     )
  *   })
@@ -1047,15 +1098,15 @@ export const catchCause = /*#__PURE__*/dual(2, (self, onError) => fromBuildUnsaf
  * @since 3.13.0
  * @category utils
  */
-export const updateService = /*#__PURE__*/dual(3, (layer, service, f) => provide(layer, effect(service)(internalEffect.map(service.asEffect(), f))));
+export const updateService = /*#__PURE__*/dual(3, (layer, service, f) => provide(layer, effect(service, internalEffect.map(service.asEffect(), f))));
 /**
  * Creates a fresh version of this layer that will not be shared.
  *
  * @example
  * ```ts
- * import { Effect, Layer, Ref, ServiceMap } from "effect"
+ * import { Effect, Layer, Ref, Context } from "effect"
  *
- * class Counter extends ServiceMap.Service<Counter, {
+ * class Counter extends Context.Service<Counter, {
  *   readonly count: number
  *   readonly increment: () => Effect.Effect<number>
  * }>()("Counter") {}
@@ -1065,10 +1116,11 @@ export const updateService = /*#__PURE__*/dual(3, (layer, service, f) => provide
  *   const ref = yield* Ref.make(0)
  *   return {
  *     count: 0,
- *     increment: () =>
+ *     increment: Effect.fn("Counter.increment")(() =>
  *       Ref.update(ref, (n) => n + 1).pipe(
  *         Effect.flatMap(() => Ref.get(ref))
  *       )
+ *     )
  *   }
  * }))
  *
@@ -1105,14 +1157,14 @@ export const fresh = self => fromBuildUnsafe((_, scope) => self.build(makeMemoMa
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap } from "effect"
+ * import { Console, Effect, Layer, Context } from "effect"
  *
- * class HttpServer extends ServiceMap.Service<HttpServer, {
+ * class HttpServer extends Context.Service<HttpServer, {
  *   readonly start: () => Effect.Effect<string>
  *   readonly stop: () => Effect.Effect<string>
  * }>()("HttpServer") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -1121,13 +1173,11 @@ export const fresh = self => fromBuildUnsafe((_, scope) => self.build(makeMemoMa
  *   yield* Console.log("Starting HTTP server...")
  *
  *   return {
- *     start: () =>
- *       Effect.gen(function*() {
+ *     start: Effect.fn("HttpServer.start")(function*() {
  *         yield* Console.log("Server listening on port 3000")
  *         return "Server started"
  *       }),
- *     stop: () =>
- *       Effect.gen(function*() {
+ *     stop: Effect.fn("HttpServer.stop")(function*() {
  *         yield* Console.log("Server stopped gracefully")
  *         return "Server stopped"
  *       })
@@ -1135,7 +1185,7 @@ export const fresh = self => fromBuildUnsafe((_, scope) => self.build(makeMemoMa
  * }))
  *
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Console.log(`[LOG] ${msg}`)
+ *   log: Effect.fn("Logger.log")((msg: string) => Console.log(`[LOG] ${msg}`))
  * })
  *
  * // Application layer combining all services
@@ -1163,9 +1213,9 @@ export const launch = self => internalEffect.scoped(internalEffect.andThen(build
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class UserService extends ServiceMap.Service<UserService, {
+ * class UserService extends Context.Service<UserService, {
  *   readonly config: { apiUrl: string }
  *   readonly getUser: (
  *     id: string
@@ -1178,7 +1228,7 @@ export const launch = self => internalEffect.scoped(internalEffect.andThen(build
  * }>()("UserService") {}
  *
  * // Create a partial mock - only implement what you need for testing
- * const testUserLayer = Layer.mock(UserService)({
+ * const testUserLayer = Layer.mock(UserService, {
  *   config: { apiUrl: "https://test-api.com" }, // Required - non-Effect property
  *   getUser: (id: string) => Effect.succeed({ id, name: "Test User" }) // Mock implementation
  *   // deleteUser and updateUser are omitted - will throw UnimplementedError if called
@@ -1202,7 +1252,13 @@ export const launch = self => internalEffect.scoped(internalEffect.andThen(build
  * @since 4.0.0
  * @category Testing
  */
-export const mock = service => implementation => succeed(service)(new Proxy({
+export const mock = function () {
+  if (arguments.length === 1) {
+    return implementation => mockImpl(arguments[0], implementation);
+  }
+  return mockImpl(arguments[0], arguments[1]);
+};
+const mockImpl = (service, implementation) => succeed(service)(new Proxy({
   ...implementation
 }, {
   get(target, prop, _receiver) {
@@ -1219,7 +1275,18 @@ export const mock = service => implementation => succeed(service)(new Proxy({
   has: constTrue
 }));
 const makeUnimplemented = error => {
-  const dead = internalEffect.die(error);
+  const dead = Object.assign(internalEffect.die(error), {
+    [StreamTypeId]: StreamTypeId,
+    channel: {
+      [ChannelTypeId]: ChannelTypeId,
+      transform: () => internalEffect.succeed(dead),
+      pipe() {
+        return pipeArguments(this, arguments);
+      }
+    },
+    [ChannelTypeId]: ChannelTypeId,
+    transform: () => internalEffect.succeed(dead)
+  });
   function unimplemented() {
     return dead;
   }
@@ -1228,6 +1295,8 @@ const makeUnimplemented = error => {
   Object.setPrototypeOf(unimplemented, Object.getPrototypeOf(dead));
   return unimplemented;
 };
+const StreamTypeId = "~effect/Stream";
+const ChannelTypeId = "~effect/Channel";
 // -----------------------------------------------------------------------------
 // Type constraints
 // -----------------------------------------------------------------------------
@@ -1329,9 +1398,9 @@ export const satisfiesServicesType = () => layer => layer;
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, type Tracer } from "effect"
+ * import { Console, Effect, Layer, Context, type Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -1347,7 +1416,7 @@ export const satisfiesServicesType = () => layer => layer;
  *   yield* Console.log((parentSpan as Tracer.Span).name) // "database-init"
  *
  *   return {
- *     query: (sql: string) => Effect.succeed(`Result: ${sql}`)
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *   }
  * })).pipe(Layer.provide(Layer.span("database-init")))
  *
@@ -1378,9 +1447,9 @@ export const span = (name, options) => {
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, Tracer } from "effect"
+ * import { Console, Effect, Layer, Context, Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -1394,7 +1463,7 @@ export const span = (name, options) => {
  *     yield* Console.log(parentSpan.spanId) // "42"
  *
  *     return {
- *       query: (sql: string) => Effect.succeed(`Result: ${sql}`)
+ *       query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *     }
  *   })
  * ).pipe(Layer.provide(Layer.parentSpan(Tracer.externalSpan({
@@ -1406,7 +1475,7 @@ export const span = (name, options) => {
  * @since 4.0.0
  * @category tracing
  */
-export const parentSpan = span => succeedServices(Tracer.ParentSpan.serviceMap(span));
+export const parentSpan = span => succeedContext(Tracer.ParentSpan.context(span));
 /**
  * Wraps a Layer with a new tracing span, making all operations in the layer
  * constructor part of the named trace span.
@@ -1417,13 +1486,13 @@ export const parentSpan = span => succeedServices(Tracer.ParentSpan.serviceMap(s
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -1432,14 +1501,14 @@ export const parentSpan = span => succeedServices(Tracer.ParentSpan.serviceMap(s
  *   yield* Effect.log("Connecting to database")
  *   yield* Effect.sleep("100 millis")
  *   return {
- *     query: (sql: string) => Effect.succeed(`Result: ${sql}`)
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *   }
  * })).pipe(Layer.withSpan("database-initialization", {
  *   attributes: { dbType: "postgres" }
  * }))
  *
  * const loggerLayer = Layer.succeed(Logger, {
- *   log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  * }).pipe(Layer.withSpan("logger-initialization"))
  *
  * // Combine traced layers
@@ -1484,13 +1553,13 @@ export const withSpan = function () {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap, Tracer } from "effect"
+ * import { Effect, Layer, Context, Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Cache extends ServiceMap.Service<Cache, {
+ * class Cache extends Context.Service<Cache, {
  *   readonly get: (key: string) => Effect.Effect<string | null>
  * }>()("Cache") {}
  *
@@ -1498,14 +1567,14 @@ export const withSpan = function () {
  * const DatabaseLayer = Layer.effect(Database, Effect.gen(function*() {
  *   yield* Effect.log("Connecting to database")
  *   return {
- *     query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  *   }
  * }))
  *
  * const CacheLayer = Layer.effect(Cache, Effect.gen(function*() {
  *   yield* Effect.log("Connecting to cache")
  *   return {
- *     get: (key: string) => Effect.succeed(`Cache: ${key}`)
+ *     get: Effect.fn("Cache.get")((key: string) => Effect.succeed(`Cache: ${key}`))
  *   }
  * }))
  *
@@ -1519,9 +1588,9 @@ export const withSpan = function () {
  *       Layer.withParentSpan(parentSpan)
  *     )
  *
- *     const services = yield* Layer.build(AppLayer)
- *     const database = ServiceMap.get(services, Database)
- *     const cache = ServiceMap.get(services, Cache)
+ *     const context = yield* Layer.build(AppLayer)
+ *     const database = Context.get(context, Database)
+ *     const cache = Context.get(context, Cache)
  *
  *     const dbResult = yield* database.query("SELECT * FROM users")
  *     const cacheResult = yield* cache.get("user:123")