effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/Layer.ts

@@ -19,6 +19,7 @@
  */
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "./Array.ts"
 import type * as Cause from "./Cause.ts"
+import type * as Channel from "./Channel.ts"
 import * as Deferred from "./Deferred.ts"
 import type { Effect } from "./Effect.ts"
 import type * as Exit from "./Exit.ts"
@@ -33,6 +34,7 @@ import { hasProperty } from "./Predicate.ts"
 import { CurrentStackFrame } from "./References.ts"
 import * as Scope from "./Scope.ts"
 import * as ServiceMap from "./ServiceMap.ts"
+import type * as Stream from "./Stream.ts"
 import * as Tracer from "./Tracer.ts"
 import type * as Types from "./Types.ts"
 
@@ -129,7 +131,7 @@ const MemoMapTypeId = "~effect/Layer/MemoMap"
  *   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)
  *
@@ -161,7 +163,7 @@ export interface MemoMap {
  * }>()("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" }
  *
@@ -340,7 +342,7 @@ class MemoMapImpl implements MemoMap {
  *   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)
  *
@@ -370,7 +372,7 @@ export const makeMemoMapUnsafe = (): MemoMap => 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)
  *
@@ -422,13 +424,13 @@ export class CurrentMemoMap extends ServiceMap.Service<CurrentMemoMap, MemoMap>(
  *
  *   // 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)
  *
  *   // 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(
  *     loggerLayer,
@@ -470,13 +472,13 @@ export const buildWithMemoMap: {
    *
    *   // 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)
    *
    *   // 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(
    *     loggerLayer,
@@ -518,13 +520,13 @@ export const buildWithMemoMap: {
    *
    *   // 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)
    *
    *   // 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(
    *     loggerLayer,
@@ -568,7 +570,7 @@ export const buildWithMemoMap: {
  * // 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
@@ -620,7 +622,7 @@ export const build = <RIn, E, ROut>(
  *       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
@@ -661,7 +663,7 @@ export const buildWithScope: {
    *       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
@@ -702,7 +704,7 @@ export const buildWithScope: {
    *       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
@@ -747,11 +749,11 @@ export const buildWithScope: {
  *
  * // 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
@@ -790,11 +792,11 @@ export const succeed: {
    *
    * // 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
@@ -815,7 +817,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.
    *
@@ -833,11 +835,11 @@ export const succeed: {
    *
    * // 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
@@ -858,7 +860,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))
@@ -886,7 +888,7 @@ export const succeed: {
  * }>()("Logger") {}
  *
  * const services = ServiceMap.make(Database, {
- *   query: (sql: string) => Effect.succeed("result")
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
  *   .pipe(
  *     ServiceMap.add(Logger, {
@@ -966,7 +968,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 +991,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 +1090,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 +1124,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 +1133,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)))
@@ -1211,7 +1213,7 @@ export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E,
  * }>()("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)
@@ -1263,10 +1265,10 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
  * }>()("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)
@@ -1302,10 +1304,10 @@ export const mergeAll = <Layers extends [Layer<never, any, any>, ...Array<Layer<
  * }>()("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)
@@ -1334,10 +1336,10 @@ export const merge: {
    * }>()("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)
@@ -1366,10 +1368,10 @@ export const merge: {
    * }>()("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)
@@ -1405,10 +1407,10 @@ export const merge: {
    * }>()("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)
@@ -1437,10 +1439,10 @@ export const merge: {
    * }>()("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)
@@ -1507,11 +1509,11 @@ const provideWith = (
  *
  * // 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
@@ -1520,8 +1522,7 @@ const provideWith = (
  *   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}`
@@ -1575,11 +1576,11 @@ export const provide: {
    *
    * // 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
@@ -1588,8 +1589,7 @@ export const provide: {
    *   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}`
@@ -1643,11 +1643,11 @@ export const provide: {
    *
    * // 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
@@ -1656,8 +1656,7 @@ export const provide: {
    *   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}`
@@ -1718,11 +1717,11 @@ export const provide: {
    *
    * // 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
@@ -1731,8 +1730,7 @@ export const provide: {
    *   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}`
@@ -1786,11 +1784,11 @@ export const provide: {
    *
    * // 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
@@ -1799,8 +1797,7 @@ export const provide: {
    *   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}`
@@ -1864,11 +1861,11 @@ export const provide: {
  *
  * // 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
@@ -1877,8 +1874,7 @@ export const provide: {
  *   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}`
@@ -1938,11 +1934,11 @@ export const provideMerge: {
    *
    * // 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
@@ -1951,8 +1947,7 @@ export const provideMerge: {
    *   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}`
@@ -2012,11 +2007,11 @@ export const provideMerge: {
    *
    * // 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
@@ -2025,8 +2020,7 @@ export const provideMerge: {
    *   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}`
@@ -2093,11 +2087,11 @@ export const provideMerge: {
    *
    * // 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
@@ -2106,8 +2100,7 @@ export const provideMerge: {
    *   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}`
@@ -2167,11 +2160,11 @@ export const provideMerge: {
    *
    * // 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
@@ -2180,8 +2173,7 @@ export const provideMerge: {
    *   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}`
@@ -2263,18 +2255,19 @@ export const provideMerge: {
  *
  *     // 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
@@ -2333,18 +2326,19 @@ export const flatMap: {
    *
    *     // 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
@@ -2403,18 +2397,19 @@ export const flatMap: {
    *
    *     // 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
@@ -2454,6 +2449,127 @@ export const flatMap: {
     )
   ))
 
+/**
+ * Performs the specified effect if this layer succeeds.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export const tap: {
+  /**
+   * Performs the specified effect if this layer succeeds.
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <ROut, XR extends ROut, RIn2, E2, X>(f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  /**
+   * Performs the specified effect if this layer succeeds.
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
+    self: Layer<ROut, E, RIn>,
+    f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>
+  ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+} = dual(2, <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
+  self: Layer<ROut, E, RIn>,
+  f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>
+): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.flatMap(
+      self.build(memoMap, scope),
+      (context) => Scope.provide(internalEffect.as(f(context as ServiceMap.ServiceMap<XR>), context), scope)
+    )
+  ))
+
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export const tapError: {
+  /**
+   * Performs the specified effect if this layer fails.
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <E, XE extends E, RIn2, E2, X>(f: (e: XE) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  /**
+   * Performs the specified effect if this layer fails.
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (e: XE) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+} = dual(2, <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+  self: Layer<ROut, E, RIn>,
+  f: (e: XE) => Effect<X, E2, RIn2>
+): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.catch_(
+      self.build(memoMap, scope),
+      (error) => Scope.provide(internalEffect.andThen(f(error as XE), 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: {
+  /**
+   * 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
+   */
+  <E, XE extends E, RIn2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.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
+   */
+  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+    self: Layer<ROut, E, RIn>,
+    f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>
+  ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+} = dual(2, <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+  self: Layer<ROut, E, RIn>,
+  f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>
+): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.catchCause(
+      self.build(memoMap, scope),
+      (cause) =>
+        Scope.provide(internalEffect.andThen(f(cause as Cause.Cause<XE>), 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.
@@ -2475,10 +2591,10 @@ export const flatMap: {
  *   // 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
@@ -2682,8 +2798,8 @@ export const catchTag: {
  *
  * // 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
@@ -2692,11 +2808,12 @@ export const catchTag: {
  *     // 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}`))
+ *         )
  *       })
  *     )
  *   })
@@ -2739,8 +2856,8 @@ export const catchCause: {
    *
    * // 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
@@ -2749,11 +2866,12 @@ export const catchCause: {
    *     // 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}`))
+   *         )
    *       })
    *     )
    *   })
@@ -2796,8 +2914,8 @@ export const catchCause: {
    *
    * // 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
@@ -2806,11 +2924,12 @@ export const catchCause: {
    *     // 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}`))
+   *         )
    *       })
    *     )
    *   })
@@ -2879,7 +2998,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 +3017,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)))
 )
@@ -2929,10 +3044,11 @@ export const updateService: {
  *   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))
  *       )
+ *     )
  *   }
  * }))
  *
@@ -2987,13 +3103,11 @@ export const fresh = <A, E, R>(self: Layer<A, E, R>): Layer<A, E, R> =>
  *   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"
  *       })
@@ -3001,7 +3115,7 @@ export const fresh = <A, E, R>(self: Layer<A, E, R>): Layer<A, E, R> =>
  * }))
  *
  * 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
@@ -3036,19 +3150,21 @@ export const launch = <RIn, E, ROut>(self: Layer<ROut, E, RIn>): Effect<never, E
  */
 export type PartialEffectful<A extends object> = Types.Simplify<
   & {
-    [
-      K in keyof A as A[K] extends Effect<any, any, any> | ((...args: any) => Effect<any, any, any>) ? K
-        : never
-    ]?: A[K]
+    [K in keyof A as A[K] extends AnyEffectOrStream ? K : never]?: A[K]
   }
   & {
-    [
-      K in keyof A as A[K] extends Effect<any, any, any> | ((...args: any) => Effect<any, any, any>) ? never
-        : K
-    ]: A[K]
+    [K in keyof A as A[K] extends AnyEffectOrStream ? never : K]: A[K]
   }
 >
 
+type AnyEffectOrStream =
+  | Effect<any, any, any>
+  | Stream.Stream<any, any, any>
+  | Channel.Channel<any, any, any, any, any, any, any>
+  | ((...args: any) => Effect<any, any, any>)
+  | ((...args: any) => Stream.Stream<any, any, any>)
+  | ((...args: any) => Channel.Channel<any, any, any, any, any, any, any>)
+
 /**
  * Creates a mock layer for testing purposes. You can provide a partial
  * implementation of the service, and any methods not provided will
@@ -3071,7 +3187,7 @@ export type PartialEffectful<A extends object> = Types.Simplify<
  * }>()("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
@@ -3095,27 +3211,142 @@ export type PartialEffectful<A extends object> = Types.Simplify<
  * @since 4.0.0
  * @category Testing
  */
-export const mock =
-  <I, S extends object>(service: ServiceMap.Service<I, S>) => (implementation: PartialEffectful<S>): Layer<I> =>
-    succeed(service)(
-      new Proxy({ ...implementation as object } as S, {
-        get(target, prop, _receiver) {
-          if (prop in target) {
-            return target[prop as keyof S]
-          }
-          const prevLimit = (Error as ErrorWithStackTraceLimit).stackTraceLimit
-          ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = 2
-          const error = new Error(`${service.key}: Unimplemented method "${prop.toString()}"`)
-          ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = prevLimit
-          error.name = "UnimplementedError"
-          return makeUnimplemented(error)
-        },
-        has: constTrue
-      })
-    )
+export const mock: {
+  /**
+   * Creates a mock layer for testing purposes. You can provide a partial
+   * implementation of the service, and any methods not provided will
+   * throw an unimplemented defect when called.
+   *
+   * @example
+   * ```ts
+   * import { Effect, Layer, ServiceMap } from "effect"
+   *
+   * class UserService extends ServiceMap.Service<UserService, {
+   *   readonly config: { apiUrl: string }
+   *   readonly getUser: (
+   *     id: string
+   *   ) => Effect.Effect<{ id: string; name: string }, Error>
+   *   readonly deleteUser: (id: string) => Effect.Effect<void, Error>
+   *   readonly updateUser: (
+   *     id: string,
+   *     data: object
+   *   ) => Effect.Effect<{ id: string; name: string }, Error>
+   * }>()("UserService") {}
+   *
+   * // Create a partial mock - only implement what you need for testing
+   * 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
+   * })
+   *
+   * // Use in tests
+   * const testProgram = Effect.gen(function*() {
+   *   const userService = yield* UserService
+   *
+   *   // This works - we provided an implementation
+   *   const user = yield* userService.getUser("123")
+   *   console.log(user.name) // "Test User"
+   *
+   *   // This would throw - we didn't implement deleteUser
+   *   // yield* userService.deleteUser("123") // UnimplementedError
+   * }).pipe(
+   *   Effect.provide(testUserLayer)
+   * )
+   * ```
+   *
+   * @since 4.0.0
+   * @category Testing
+   */
+  <I, S extends object>(service: ServiceMap.Key<I, S>): (implementation: PartialEffectful<S>) => Layer<I>
+  /**
+   * Creates a mock layer for testing purposes. You can provide a partial
+   * implementation of the service, and any methods not provided will
+   * throw an unimplemented defect when called.
+   *
+   * @example
+   * ```ts
+   * import { Effect, Layer, ServiceMap } from "effect"
+   *
+   * class UserService extends ServiceMap.Service<UserService, {
+   *   readonly config: { apiUrl: string }
+   *   readonly getUser: (
+   *     id: string
+   *   ) => Effect.Effect<{ id: string; name: string }, Error>
+   *   readonly deleteUser: (id: string) => Effect.Effect<void, Error>
+   *   readonly updateUser: (
+   *     id: string,
+   *     data: object
+   *   ) => Effect.Effect<{ id: string; name: string }, Error>
+   * }>()("UserService") {}
+   *
+   * // Create a partial mock - only implement what you need for testing
+   * 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
+   * })
+   *
+   * // Use in tests
+   * const testProgram = Effect.gen(function*() {
+   *   const userService = yield* UserService
+   *
+   *   // This works - we provided an implementation
+   *   const user = yield* userService.getUser("123")
+   *   console.log(user.name) // "Test User"
+   *
+   *   // This would throw - we didn't implement deleteUser
+   *   // yield* userService.deleteUser("123") // UnimplementedError
+   * }).pipe(
+   *   Effect.provide(testUserLayer)
+   * )
+   * ```
+   *
+   * @since 4.0.0
+   * @category Testing
+   */
+  <I, S extends object>(
+    service: ServiceMap.Key<I, S>,
+    implementation: Types.NoInfer<PartialEffectful<S>>
+  ): Layer<I>
+} = function() {
+  if (arguments.length === 1) {
+    return (implementation: any) => mockImpl(arguments[0], implementation)
+  }
+  return mockImpl(arguments[0], arguments[1])
+} as any
+
+const mockImpl = <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) {
+        if (prop in target) {
+          return target[prop as keyof S]
+        }
+        const prevLimit = (Error as ErrorWithStackTraceLimit).stackTraceLimit
+        ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = 2
+        const error = new Error(`${service.key}: Unimplemented method "${prop.toString()}"`)
+        ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = prevLimit
+        error.name = "UnimplementedError"
+        return makeUnimplemented(error)
+      },
+      has: constTrue
+    })
+  )
 
 const makeUnimplemented = (error: globalThis.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
   }
@@ -3125,6 +3356,9 @@ const makeUnimplemented = (error: globalThis.Error) => {
   return unimplemented
 }
 
+const StreamTypeId: Stream.TypeId = "~effect/Stream"
+const ChannelTypeId: Channel.TypeId = "~effect/Channel"
+
 // -----------------------------------------------------------------------------
 // Type constraints
 // -----------------------------------------------------------------------------
@@ -3272,7 +3506,7 @@ export interface SpanOptions extends Tracer.SpanOptions {
  *   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")))
  *
@@ -3331,7 +3565,7 @@ export const span = (
  *     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({
@@ -3371,14 +3605,14 @@ export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
  *   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
@@ -3430,14 +3664,14 @@ export const withSpan: {
    *   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
@@ -3491,14 +3725,14 @@ export const withSpan: {
    *   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
@@ -3580,14 +3814,14 @@ export const withSpan: {
  * 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}`))
  *   }
  * }))
  *
@@ -3640,14 +3874,14 @@ export const withParentSpan: {
    * 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}`))
    *   }
    * }))
    *
@@ -3702,14 +3936,14 @@ export const withParentSpan: {
    * 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}`))
    *   }
    * }))
    *