effect 4.0.0-beta.6 → 4.0.0-beta.60

package/dist/{ServiceMap.js → Context.js}

@@ -4,27 +4,31 @@ import * as Hash from "./Hash.js";
 import { exitSucceed, PipeInspectableProto, withFiber, YieldableProto } from "./internal/core.js";
 import * as Option from "./Option.js";
 import { hasProperty } from "./Predicate.js";
-const ServiceTypeId = "~effect/ServiceMap/Service";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const ServiceTypeId = "~effect/Context/Service";
 /**
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  *
  * // Create a simple service
- * const Database = ServiceMap.Service<{
+ * const Database = Context.Service<{
  *   query: (sql: string) => string
  * }>("Database")
  *
  * // Create a service class
- * class Config extends ServiceMap.Service<Config, {
+ * class Config extends Context.Service<Config, {
  *   port: number
  * }>()("Config") {}
  *
- * // Use the services to create service maps
- * const db = ServiceMap.make(Database, {
+ * // Use the services to create contexts
+ * const db = Context.make(Database, {
  *   query: (sql) => `Result: ${sql}`
  * })
- * const config = ServiceMap.make(Config, { port: 8080 })
+ * const config = Context.make(Config, { port: 8080 })
  * ```
  *
  * @since 4.0.0
@@ -61,10 +65,7 @@ export const Service = function () {
   };
 };
 const ServiceProto = {
-  [ServiceTypeId]: {
-    _Service: _ => _,
-    _Identifier: _ => _
-  },
+  [ServiceTypeId]: ServiceTypeId,
   ...PipeInspectableProto,
   ...YieldableProto,
   toJSON() {
@@ -75,35 +76,35 @@ const ServiceProto = {
     };
   },
   asEffect() {
-    const fn = this.asEffect = constant(withFiber(fiber => exitSucceed(get(fiber.services, this))));
+    const fn = this.asEffect = constant(withFiber(fiber => exitSucceed(get(fiber.context, this))));
     return fn();
   },
   of(self) {
     return self;
   },
-  serviceMap(self) {
+  context(self) {
     return make(this, self);
   },
   use(f) {
-    return withFiber(fiber => f(get(fiber.services, this)));
+    return withFiber(fiber => f(get(fiber.context, this)));
   },
   useSync(f) {
-    return withFiber(fiber => exitSucceed(f(get(fiber.services, this))));
+    return withFiber(fiber => exitSucceed(f(get(fiber.context, this))));
   }
 };
-const ReferenceTypeId = "~effect/ServiceMap/Reference";
-const TypeId = "~effect/ServiceMap";
+const ReferenceTypeId = "~effect/Context/Reference";
+const TypeId = "~effect/Context";
 /**
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  *
- * // Create a service map from a Map (unsafe)
+ * // Create a context from a Map (unsafe)
  * const map = new Map([
  *   ["Logger", { log: (msg: string) => console.log(msg) }]
  * ])
  *
- * const services = ServiceMap.makeUnsafe(map)
+ * const context = Context.makeUnsafe(map)
  * ```
  *
  * @since 4.0.0
@@ -112,6 +113,7 @@ const TypeId = "~effect/ServiceMap";
 export const makeUnsafe = mapUnsafe => {
   const self = Object.create(Proto);
   self.mapUnsafe = mapUnsafe;
+  self.mutable = false;
   return self;
 };
 const Proto = {
@@ -121,7 +123,7 @@ const Proto = {
   },
   toJSON() {
     return {
-      _id: "ServiceMap",
+      _id: "Context",
       services: Array.from(this.mapUnsafe).map(([key, value]) => ({
         key,
         value
@@ -129,7 +131,7 @@ const Proto = {
     };
   },
   [Equal.symbol](that) {
-    if (!isServiceMap(that) || this.mapUnsafe.size !== that.mapUnsafe.size) return false;
+    if (!isContext(that) || this.mapUnsafe.size !== that.mapUnsafe.size) return false;
     for (const k of this.mapUnsafe.keys()) {
       if (!that.mapUnsafe.has(k) || !Equal.equals(this.mapUnsafe.get(k), that.mapUnsafe.get(k))) {
         return false;
@@ -142,49 +144,49 @@ const Proto = {
   }
 };
 /**
- * Checks if the provided argument is a `ServiceMap`.
+ * Checks if the provided argument is a `Context`.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.strictEqual(ServiceMap.isServiceMap(ServiceMap.empty()), true)
+ * assert.strictEqual(Context.isContext(Context.empty()), true)
  * ```
  *
  * @since 4.0.0
  * @category Guards
  */
-export const isServiceMap = u => hasProperty(u, TypeId);
+export const isContext = u => hasProperty(u, TypeId);
 /**
- * Checks if the provided argument is a `Service`.
+ * Checks if the provided argument is a `Key`.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.strictEqual(ServiceMap.isService(ServiceMap.Service("Service")), true)
+ * assert.strictEqual(Context.isKey(Context.Service("Service")), true)
  * ```
  *
  * @since 4.0.0
  * @category Guards
  */
-export const isService = u => hasProperty(u, ServiceTypeId);
+export const isKey = u => hasProperty(u, ServiceTypeId);
 /**
  * Checks if the provided argument is a `Reference`.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const LoggerRef = ServiceMap.Reference("Logger", {
+ * const LoggerRef = Context.Reference("Logger", {
  *   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
  * })
  *
- * assert.strictEqual(ServiceMap.isReference(LoggerRef), true)
- * assert.strictEqual(ServiceMap.isReference(ServiceMap.Service("Key")), false)
+ * assert.strictEqual(Context.isReference(LoggerRef), true)
+ * assert.strictEqual(Context.isReference(Context.Service("Key")), false)
  * ```
  *
  * @since 4.0.0
@@ -192,34 +194,34 @@ export const isService = u => hasProperty(u, ServiceTypeId);
  */
 export const isReference = u => hasProperty(u, ReferenceTypeId);
 /**
- * Returns an empty `ServiceMap`.
+ * Returns an empty `Context`.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.strictEqual(ServiceMap.isServiceMap(ServiceMap.empty()), true)
+ * assert.strictEqual(Context.isContext(Context.empty()), true)
  * ```
  *
  * @since 4.0.0
  * @category Constructors
  */
-export const empty = () => emptyServiceMap;
-const emptyServiceMap = /*#__PURE__*/makeUnsafe(/*#__PURE__*/new Map());
+export const empty = () => emptyContext;
+const emptyContext = /*#__PURE__*/makeUnsafe(/*#__PURE__*/new Map());
 /**
- * Creates a new `ServiceMap` with a single service associated to the key.
+ * Creates a new `Context` with a single service associated to the key.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
+ * const Port = Context.Service<{ PORT: number }>("Port")
  *
- * const Services = ServiceMap.make(Port, { PORT: 8080 })
+ * const context = Context.make(Port, { PORT: 8080 })
  *
- * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
+ * assert.deepStrictEqual(Context.get(context, Port), { PORT: 8080 })
  * ```
  *
  * @since 4.0.0
@@ -227,69 +229,65 @@ const emptyServiceMap = /*#__PURE__*/makeUnsafe(/*#__PURE__*/new Map());
  */
 export const make = (key, service) => makeUnsafe(new Map([[key.key, service]]));
 /**
- * Adds a service to a given `ServiceMap`.
+ * Adds a service to a given `Context`.
  *
  * @example
  * ```ts
- * import { pipe, ServiceMap } from "effect"
+ * import { pipe, Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
+ * const Port = Context.Service<{ PORT: number }>("Port")
+ * const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
  *
- * const someServiceMap = ServiceMap.make(Port, { PORT: 8080 })
+ * const someContext = Context.make(Port, { PORT: 8080 })
  *
- * const Services = pipe(
- *   someServiceMap,
- *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
+ * const context = pipe(
+ *   someContext,
+ *   Context.add(Timeout, { TIMEOUT: 5000 })
  * )
  *
- * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
- * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
+ * assert.deepStrictEqual(Context.get(context, Port), { PORT: 8080 })
+ * assert.deepStrictEqual(Context.get(context, Timeout), { TIMEOUT: 5000 })
  * ```
  *
  * @since 4.0.0
  * @category Adders
  */
-export const add = /*#__PURE__*/dual(3, (self, key, service) => {
-  const map = new Map(self.mapUnsafe);
+export const add = /*#__PURE__*/dual(3, (self, key, service) => withMapUnsafe(self, map => {
   map.set(key.key, service);
-  return makeUnsafe(map);
-});
+}));
 /**
  * @since 4.0.0
  * @category Adders
  */
-export const addOrOmit = /*#__PURE__*/dual(3, (self, key, service) => {
-  const map = new Map(self.mapUnsafe);
+export const addOrOmit = /*#__PURE__*/dual(3, (self, key, service) => withMapUnsafe(self, map => {
   if (service._tag === "None") {
     map.delete(key.key);
   } else {
     map.set(key.key, service.value);
   }
-  return makeUnsafe(map);
-});
+}));
 /**
  * Get a service from the context that corresponds to the given key, or
  * use the fallback value.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Logger = ServiceMap.Service<{ log: (msg: string) => void }>("Logger")
- * const Database = ServiceMap.Service<{ query: (sql: string) => string }>(
+ * const Logger = Context.Service<{ log: (msg: string) => void }>("Logger")
+ * const Database = Context.Service<{ query: (sql: string) => string }>(
  *   "Database"
  * )
  *
- * const services = ServiceMap.make(Logger, {
+ * const context = Context.make(Logger, {
  *   log: (msg: string) => console.log(msg)
  * })
  *
- * const logger = ServiceMap.getOrElse(services, Logger, () => ({ log: () => {} }))
- * const database = ServiceMap.getOrElse(
- *   services,
+ * const logger = Context.getOrElse(context, Logger, () => ({ log: () => {} }))
+ * const database = Context.getOrElse(
+ *   context,
  *   Database,
  *   () => ({ query: () => "fallback" })
  * )
@@ -320,21 +318,21 @@ export const getOrUndefined = /*#__PURE__*/dual(2, (self, key) => self.mapUnsafe
  *
  * For a safer version see {@link getOption}.
  *
- * @param self - The `ServiceMap` to search for the service.
+ * @param self - The `Context` to search for the service.
  * @param service - The `Service` of the service to retrieve.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
+ * const Port = Context.Service<{ PORT: number }>("Port")
+ * const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
  *
- * const Services = ServiceMap.make(Port, { PORT: 8080 })
+ * const context = Context.make(Port, { PORT: 8080 })
  *
- * assert.deepStrictEqual(ServiceMap.getUnsafe(Services, Port), { PORT: 8080 })
- * assert.throws(() => ServiceMap.getUnsafe(Services, Timeout))
+ * assert.deepStrictEqual(Context.getUnsafe(context, Port), { PORT: 8080 })
+ * assert.throws(() => Context.getUnsafe(context, Timeout))
  * ```
  *
  * @since 4.0.0
@@ -350,23 +348,23 @@ export const getUnsafe = /*#__PURE__*/dual(2, (self, service) => {
 /**
  * Get a service from the context that corresponds to the given key.
  *
- * @param self - The `ServiceMap` to search for the service.
+ * @param self - The `Context` to search for the service.
  * @param service - The `Service` of the service to retrieve.
  *
  * @example
  * ```ts
- * import { pipe, ServiceMap } from "effect"
+ * import { pipe, Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
+ * const Port = Context.Service<{ PORT: number }>("Port")
+ * const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
  *
- * const Services = pipe(
- *   ServiceMap.make(Port, { PORT: 8080 }),
- *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
+ * const context = pipe(
+ *   Context.make(Port, { PORT: 8080 }),
+ *   Context.add(Timeout, { TIMEOUT: 5000 })
  * )
  *
- * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
+ * assert.deepStrictEqual(Context.get(context, Timeout), { TIMEOUT: 5000 })
  * ```
  *
  * @since 4.0.0
@@ -376,15 +374,15 @@ export const get = getUnsafe;
 /**
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const LoggerRef = ServiceMap.Reference("Logger", {
+ * const LoggerRef = Context.Reference("Logger", {
  *   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
  * })
  *
- * const services = ServiceMap.empty()
- * const logger = ServiceMap.getReferenceUnsafe(services, LoggerRef)
+ * const context = Context.empty()
+ * const logger = Context.getReferenceUnsafe(context, LoggerRef)
  *
  * assert.deepStrictEqual(logger, { log: (msg: string) => console.log(msg) })
  * ```
@@ -398,7 +396,7 @@ export const getReferenceUnsafe = (self, service) => {
   }
   return self.mapUnsafe.get(service.key);
 };
-const defaultValueCacheKey = "~effect/ServiceMap/defaultValue";
+const defaultValueCacheKey = "~effect/Context/defaultValue";
 const getDefaultValue = ref => {
   if (defaultValueCacheKey in ref) {
     return ref[defaultValueCacheKey];
@@ -428,24 +426,24 @@ const serviceNotFoundError = service => {
  * an `Option` object. If the key is not found, the `Option` object will be
  * `None`.
  *
- * @param self - The `ServiceMap` to search for the service.
+ * @param self - The `Context` to search for the service.
  * @param service - The `Service` of the service to retrieve.
  *
  * @example
  * ```ts
- * import { Option, ServiceMap } from "effect"
+ * import { Option, Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
+ * const Port = Context.Service<{ PORT: number }>("Port")
+ * const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
  *
- * const Services = ServiceMap.make(Port, { PORT: 8080 })
+ * const context = Context.make(Port, { PORT: 8080 })
  *
  * assert.deepStrictEqual(
- *   ServiceMap.getOption(Services, Port),
+ *   Context.getOption(context, Port),
  *   Option.some({ PORT: 8080 })
  * )
- * assert.deepStrictEqual(ServiceMap.getOption(Services, Timeout), Option.none())
+ * assert.deepStrictEqual(Context.getOption(context, Timeout), Option.none())
  * ```
  *
  * @since 4.0.0
@@ -458,26 +456,26 @@ export const getOption = /*#__PURE__*/dual(2, (self, service) => {
   return isReference(service) ? Option.some(getDefaultValue(service)) : Option.none();
 });
 /**
- * Merges two `ServiceMap`s, returning a new `ServiceMap` containing the services of both.
+ * Merges two `Context`s, returning a new `Context` containing the services of both.
  *
- * @param self - The first `ServiceMap` to merge.
- * @param that - The second `ServiceMap` to merge.
+ * @param self - The first `Context` to merge.
+ * @param that - The second `Context` to merge.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
+ * const Port = Context.Service<{ PORT: number }>("Port")
+ * const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
  *
- * const firstServiceMap = ServiceMap.make(Port, { PORT: 8080 })
- * const secondServiceMap = ServiceMap.make(Timeout, { TIMEOUT: 5000 })
+ * const firstContext = Context.make(Port, { PORT: 8080 })
+ * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 })
  *
- * const Services = ServiceMap.merge(firstServiceMap, secondServiceMap)
+ * const context = Context.merge(firstContext, secondContext)
  *
- * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
- * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
+ * assert.deepStrictEqual(Context.get(context, Port), { PORT: 8080 })
+ * assert.deepStrictEqual(Context.get(context, Timeout), { TIMEOUT: 5000 })
  * ```
  *
  * @since 4.0.0
@@ -486,35 +484,35 @@ export const getOption = /*#__PURE__*/dual(2, (self, service) => {
 export const merge = /*#__PURE__*/dual(2, (self, that) => {
   if (self.mapUnsafe.size === 0) return that;
   if (that.mapUnsafe.size === 0) return self;
-  const map = new Map(self.mapUnsafe);
-  that.mapUnsafe.forEach((value, key) => map.set(key, value));
-  return makeUnsafe(map);
+  return withMapUnsafe(self, map => {
+    that.mapUnsafe.forEach((value, key) => map.set(key, value));
+  });
 });
 /**
- * Merges any number of `ServiceMap`s, returning a new `ServiceMap` containing the services of all.
+ * Merges any number of `Context`s, returning a new `Context` containing the services of all.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- * const Host = ServiceMap.Service<{ HOST: string }>("Host")
+ * const Port = Context.Service<{ PORT: number }>("Port")
+ * const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
+ * const Host = Context.Service<{ HOST: string }>("Host")
  *
- * const firstServiceMap = ServiceMap.make(Port, { PORT: 8080 })
- * const secondServiceMap = ServiceMap.make(Timeout, { TIMEOUT: 5000 })
- * const thirdServiceMap = ServiceMap.make(Host, { HOST: "localhost" })
+ * const firstContext = Context.make(Port, { PORT: 8080 })
+ * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 })
+ * const thirdContext = Context.make(Host, { HOST: "localhost" })
  *
- * const Services = ServiceMap.mergeAll(
- *   firstServiceMap,
- *   secondServiceMap,
- *   thirdServiceMap
+ * const context = Context.mergeAll(
+ *   firstContext,
+ *   secondContext,
+ *   thirdContext
  * )
  *
- * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
- * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
- * assert.deepStrictEqual(ServiceMap.get(Services, Host), { HOST: "localhost" })
+ * assert.deepStrictEqual(Context.get(context, Port), { PORT: 8080 })
+ * assert.deepStrictEqual(Context.get(context, Timeout), { TIMEOUT: 5000 })
+ * assert.deepStrictEqual(Context.get(context, Host), { HOST: "localhost" })
  * ```
  *
  * @since 3.12.0
@@ -529,111 +527,129 @@ export const mergeAll = (...ctxs) => {
   return makeUnsafe(map);
 };
 /**
- * Returns a new `ServiceMap` that contains only the specified services.
+ * Returns a new `Context` that contains only the specified services.
  *
- * @param self - The `ServiceMap` to prune services from.
- * @param services - The list of `Service`s to be included in the new `ServiceMap`.
+ * @param self - The `Context` to prune services from.
+ * @param services - The list of `Service`s to be included in the new `Context`.
  *
  * @example
  * ```ts
- * import { Option, pipe, ServiceMap } from "effect"
+ * import { Option, pipe, Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
+ * const Port = Context.Service<{ PORT: number }>("Port")
+ * const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
  *
- * const someServiceMap = pipe(
- *   ServiceMap.make(Port, { PORT: 8080 }),
- *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
+ * const someContext = pipe(
+ *   Context.make(Port, { PORT: 8080 }),
+ *   Context.add(Timeout, { TIMEOUT: 5000 })
  * )
  *
- * const Services = pipe(someServiceMap, ServiceMap.pick(Port))
+ * const context = pipe(someContext, Context.pick(Port))
  *
  * assert.deepStrictEqual(
- *   ServiceMap.getOption(Services, Port),
+ *   Context.getOption(context, Port),
  *   Option.some({ PORT: 8080 })
  * )
- * assert.deepStrictEqual(ServiceMap.getOption(Services, Timeout), Option.none())
+ * assert.deepStrictEqual(Context.getOption(context, Timeout), Option.none())
  * ```
  *
  * @since 4.0.0
  * @category Utils
  */
-export const pick = (...services) => self => {
-  const map = new Map();
+export const pick = (...services) => self => withMapUnsafe(self, map => {
   const keySet = new Set(services.map(key => key.key));
-  self.mapUnsafe.forEach((value, key) => {
-    if (keySet.has(key)) {
-      map.set(key, value);
-    }
+  map.forEach((_, key) => {
+    if (keySet.has(key)) return;
+    map.delete(key);
   });
-  return makeUnsafe(map);
-};
+});
 /**
  * @example
  * ```ts
- * import { Option, pipe, ServiceMap } from "effect"
+ * import { Option, pipe, Context } from "effect"
  * import * as assert from "node:assert"
  *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
+ * const Port = Context.Service<{ PORT: number }>("Port")
+ * const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
  *
- * const someServiceMap = pipe(
- *   ServiceMap.make(Port, { PORT: 8080 }),
- *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
+ * const someContext = pipe(
+ *   Context.make(Port, { PORT: 8080 }),
+ *   Context.add(Timeout, { TIMEOUT: 5000 })
  * )
  *
- * const Services = pipe(someServiceMap, ServiceMap.omit(Timeout))
+ * const context = pipe(someContext, Context.omit(Timeout))
  *
  * assert.deepStrictEqual(
- *   ServiceMap.getOption(Services, Port),
+ *   Context.getOption(context, Port),
  *   Option.some({ PORT: 8080 })
  * )
- * assert.deepStrictEqual(ServiceMap.getOption(Services, Timeout), Option.none())
+ * assert.deepStrictEqual(Context.getOption(context, Timeout), Option.none())
  * ```
  *
  * @since 4.0.0
  * @category Utils
  */
-export const omit = (...keys) => self => {
-  const map = new Map(self.mapUnsafe);
+export const omit = (...keys) => self => withMapUnsafe(self, map => {
   for (let i = 0; i < keys.length; i++) {
     map.delete(keys[i].key);
   }
+});
+/**
+ * Perform a series of mutations on a `Context`. Prevents unnecessary copying
+ * of the underlying map when multiple mutations are needed.
+ *
+ * @since 4.0.0
+ * @category Utils
+ */
+export const mutate = /*#__PURE__*/dual(2, (self, f) => {
+  const next = makeUnsafe(new Map(self.mapUnsafe));
+  next.mutable = true;
+  const result = f(next);
+  result.mutable = false;
+  return result;
+});
+const withMapUnsafe = (self, f) => {
+  if (self.mutable) {
+    f(self.mapUnsafe);
+    return self;
+  }
+  const map = new Map(self.mapUnsafe);
+  f(map);
   return makeUnsafe(map);
 };
 /**
- * Creates a service map key with a default value.
+ * Creates a context key with a default value.
  *
  * **Details**
  *
- * `ServiceMap.Reference` allows you to create a key that can hold a value. You
+ * `Context.Reference` allows you to create a key that can hold a value. You
  * can provide a default value for the service, which will automatically be used
  * when the context is accessed, or override it with a custom implementation
  * when needed.
  *
  * @example
  * ```ts
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  *
  * // Create a reference with a default value
- * const LoggerRef = ServiceMap.Reference("Logger", {
+ * const LoggerRef = Context.Reference("Logger", {
  *   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
  * })
  *
  * // The reference provides the default value when accessed from an empty context
- * const services = ServiceMap.empty()
- * const logger = ServiceMap.get(services, LoggerRef)
+ * const context = Context.empty()
+ * const logger = Context.get(context, LoggerRef)
  *
  * // You can also override the default value
- * const customServices = ServiceMap.make(LoggerRef, {
+ * const customContext = Context.make(LoggerRef, {
  *   log: (msg: string) => `Custom: ${msg}`
  * })
- * const customLogger = ServiceMap.get(customServices, LoggerRef)
+ * const customLogger = Context.get(customContext, LoggerRef)
  * ```
  *
  * @since 4.0.0
  * @category References
  */
 export const Reference = Service;
-//# sourceMappingURL=ServiceMap.js.map
+//# sourceMappingURL=Context.js.map