effect 2.4.19 → 3.0.0

package/src/HashSet.ts

@@ -7,7 +7,6 @@ import type { Inspectable } from "./Inspectable.js"
 import * as HS from "./internal/hashSet.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type { NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = HS.HashSetTypeId as TypeId
 

package/src/Iterable.ts

@@ -4,6 +4,7 @@
  * @since 2.0.0
  */
 
+import type { NonEmptyArray } from "./Array.js"
 import type { Either } from "./Either.js"
 import * as E from "./Either.js"
 import * as Equal from "./Equal.js"
@@ -11,10 +12,8 @@ import { dual, identity } from "./Function.js"
 import type { Option } from "./Option.js"
 import * as O from "./Option.js"
 import { isBoolean } from "./Predicate.js"
-import type { NonEmptyArray } from "./ReadonlyArray.js"
-import type * as ReadonlyRecord from "./ReadonlyRecord.js"
+import type * as Record from "./Record.js"
 import * as Tuple from "./Tuple.js"
-import type { NoInfer } from "./Types.js"
 
 /**
  * Return a `Iterable` with element `i` initialized with `f(i)`.
@@ -123,7 +122,7 @@ export const fromRecord = <K extends string, A>(self: Readonly<Record<K, A>>): I
 export const prepend: {
   <B>(head: B): <A>(self: Iterable<A>) => Iterable<A | B>
   <A, B>(self: Iterable<A>, head: B): Iterable<A | B>
-} = dual(2, <A, B>(self: Iterable<A>, head: B): Iterable<A | B> => flatten<A | B>([[head], self]))
+} = dual(2, <A, B>(self: Iterable<A>, head: B): Iterable<A | B> => prependAll(self, [head]))
 
 /**
  * Prepends the specified prefix iterable to the beginning of the specified iterable.
@@ -144,7 +143,7 @@ export const prependAll: {
   <A, B>(self: Iterable<A>, that: Iterable<B>): Iterable<A | B>
 } = dual(
   2,
-  <A, B>(self: Iterable<A>, that: Iterable<B>): Iterable<A | B> => flatten<A | B>([that, self])
+  <A, B>(self: Iterable<A>, that: Iterable<B>): Iterable<A | B> => appendAll(that, self)
 )
 
 /**
@@ -156,7 +155,7 @@ export const prependAll: {
 export const append: {
   <B>(last: B): <A>(self: Iterable<A>) => Iterable<A | B>
   <A, B>(self: Iterable<A>, last: B): Iterable<A | B>
-} = dual(2, <A, B>(self: Iterable<A>, last: B): Iterable<A | B> => flatten<A | B>([self, [last]]))
+} = dual(2, <A, B>(self: Iterable<A>, last: B): Iterable<A | B> => appendAll(self, [last]))
 
 /**
  * Concatenates two iterables, combining their elements.
@@ -169,7 +168,27 @@ export const appendAll: {
   <A, B>(self: Iterable<A>, that: Iterable<B>): Iterable<A | B>
 } = dual(
   2,
-  <A, B>(self: Iterable<A>, that: Iterable<B>): Iterable<A | B> => flatten<A | B>([self, that])
+  <A, B>(self: Iterable<A>, that: Iterable<B>): Iterable<A | B> => ({
+    [Symbol.iterator]() {
+      const iterA = self[Symbol.iterator]()
+      let doneA = false
+      let iterB: Iterator<B>
+      return {
+        next() {
+          if (!doneA) {
+            const r = iterA.next()
+            if (r.done) {
+              doneA = true
+              iterB = that[Symbol.iterator]()
+              return iterB.next()
+            }
+            return r
+          }
+          return iterB.next()
+        }
+      }
+    }
+  })
 )
 
 /**
@@ -607,15 +626,15 @@ export const group: <A>(self: Iterable<A>) => Iterable<NonEmptyArray<A>> = group
 export const groupBy: {
   <A, K extends string | symbol>(
     f: (a: A) => K
-  ): (self: Iterable<A>) => Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
+  ): (self: Iterable<A>) => Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
   <A, K extends string | symbol>(
     self: Iterable<A>,
     f: (a: A) => K
-  ): Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
+  ): Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
 } = dual(2, <A, K extends string | symbol>(
   self: Iterable<A>,
   f: (a: A) => K
-): Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>> => {
+): Record<Record.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>> => {
   const out: Record<string | symbol, NonEmptyArray<A>> = {}
   for (const a of self) {
     const k = f(a)
@@ -938,6 +957,25 @@ export const forEach: {
   }
 })
 
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+export const reduce: {
+  <B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Iterable<A>) => B
+  <A, B>(self: Iterable<A>, b: B, f: (b: B, a: A, i: number) => B): B
+} = dual(3, <A, B>(self: Iterable<A>, b: B, f: (b: B, a: A, i: number) => B): B => {
+  if (Array.isArray(self)) {
+    return self.reduce(f, b)
+  }
+  let i = 0
+  let result = b
+  for (const n of self) {
+    result = f(result, n, i++)
+  }
+  return result
+})
+
 /**
  * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function.
  *

package/src/Layer.ts

@@ -896,7 +896,7 @@ export const setConfigProvider: (configProvider: ConfigProvider) => Layer<never>
  * @since 2.0.0
  * @category tracing
  */
-export const parentSpan: (span: Tracer.ParentSpan) => Layer<Tracer.ParentSpan> = circularLayer.parentSpan
+export const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSpan> = circularLayer.parentSpan
 
 /**
  * @since 2.0.0
@@ -962,7 +962,7 @@ export const span: (
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
     readonly onEnd?:
@@ -1018,7 +1018,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
       readonly onEnd?:
@@ -1032,7 +1032,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
       readonly onEnd?:
@@ -1047,8 +1047,8 @@ export const withSpan: {
  * @category tracing
  */
 export const withParentSpan: {
-  (span: Tracer.ParentSpan): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
-  <A, E, R>(self: Layer<A, E, R>, span: Tracer.ParentSpan): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
+  (span: Tracer.AnySpan): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
+  <A, E, R>(self: Layer<A, E, R>, span: Tracer.AnySpan): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
 } = internal.withParentSpan
 
 // -----------------------------------------------------------------------------

package/src/List.ts

@@ -21,6 +21,7 @@
  * Licensed under Apache License 2.0
  * (http://www.apache.org/licenses/LICENSE-2.0).
  */
+import * as Array from "./Array.js"
 import * as Chunk from "./Chunk.js"
 import * as Either from "./Either.js"
 import * as Equal from "./Equal.js"
@@ -32,8 +33,6 @@ import * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 import { hasProperty, type Predicate, type Refinement } from "./Predicate.js"
-import * as ReadonlyArray from "./ReadonlyArray.js"
-import type { NoInfer } from "./Types.js"
 
 /**
  * Represents an immutable linked list of elements of type `A`.
@@ -85,14 +84,14 @@ export interface Cons<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspect
  * @category conversions
  * @since 2.0.0
  */
-export const toArray = <A>(self: List<A>): Array<A> => Array.from(self)
+export const toArray = <A>(self: List<A>): Array<A> => Array.fromIterable(self)
 
 /**
  * @category equivalence
  * @since 2.0.0
  */
 export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equivalence.Equivalence<List<A>> =>
-  Equivalence.mapInput(ReadonlyArray.getEquivalence(isEquivalent), toArray<A>)
+  Equivalence.mapInput(Array.getEquivalence(isEquivalent), toArray<A>)
 
 const _equivalence = getEquivalence(Equal.equals)
 

package/src/Logger.ts

@@ -183,12 +183,12 @@ export const map: {
 export const batched: {
   <Output, R>(
     window: DurationInput,
-    f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
+    f: (messages: Array<NoInfer<Output>>) => Effect<void, never, R>
   ): <Message>(self: Logger<Message, Output>) => Effect<Logger<Message, void>, never, R | Scope>
   <Message, Output, R>(
     self: Logger<Message, Output>,
     window: DurationInput,
-    f: (messages: Array<Types.NoInfer<Output>>) => Effect<void, never, R>
+    f: (messages: Array<NoInfer<Output>>) => Effect<void, never, R>
   ): Effect<Logger<Message, void>, never, Scope | R>
 } = fiberRuntime.batchedLogger
 

package/src/Metric.ts

@@ -208,12 +208,19 @@ export const counter: {
  * @example
  * import * as Metric from "effect/Metric"
  *
- * const errorFrequency = Metric.frequency("error_frequency", "Counts the occurrences of errors.");
+ * const errorFrequency = Metric.frequency("error_frequency", {
+ *    description: "Counts the occurrences of errors."
+ * });
  *
  * @since 2.0.0
  * @category constructors
  */
-export const frequency: (name: string, description?: string) => Metric.Frequency<string> = internal.frequency
+export const frequency: (
+  name: string,
+  options?:
+    | { readonly description?: string | undefined; readonly preregisteredWords?: ReadonlyArray<string> | undefined }
+    | undefined
+) => Metric.Frequency<string> = internal.frequency
 
 /**
  * Returns a new metric that is powered by this one, but which accepts updates

package/src/MetricKey.ts

@@ -132,7 +132,15 @@ export const counter: {
  * @since 2.0.0
  * @category constructors
  */
-export const frequency: (name: string, description?: string) => MetricKey.Frequency = internal.frequency
+export const frequency: (
+  name: string,
+  options?:
+    | {
+      readonly description?: string | undefined
+      readonly preregisteredWords?: ReadonlyArray<string> | undefined
+    }
+    | undefined
+) => MetricKey.Frequency = internal.frequency
 
 /**
  * Creates a metric key for a gauge, with the specified name.

package/src/MetricKeyType.ts

@@ -113,6 +113,7 @@ export declare namespace MetricKeyType {
    */
   export type Frequency = MetricKeyType<string, MetricState.MetricState.Frequency> & {
     readonly [FrequencyKeyTypeTypeId]: FrequencyKeyTypeTypeId
+    readonly preregisteredWords: ReadonlyArray<string>
   }
 
   /**
@@ -193,7 +194,11 @@ export const counter: <A extends number | bigint>() => MetricKeyType.Counter<A>
  * @since 2.0.0
  * @category constructors
  */
-export const frequency: MetricKeyType.Frequency = internal.frequency
+export const frequency: (
+  options?: {
+    readonly preregisteredWords?: ReadonlyArray<string> | undefined
+  } | undefined
+) => MetricKeyType.Frequency = internal.frequency
 
 /**
  * @since 2.0.0

package/src/MutableHashMap.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import type { NonEmptyArray } from "./Array.js"
 import * as Equal from "./Equal.js"
 import { dual } from "./Function.js"
 import * as Hash from "./Hash.js"
@@ -8,7 +9,6 @@ import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectab
 import * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
-import type { NonEmptyArray } from "./ReadonlyArray.js"
 
 const TypeId: unique symbol = Symbol.for("effect/MutableHashMap") as TypeId
 

package/src/Option.ts

@@ -14,7 +14,7 @@ import type { Order } from "./Order.js"
 import * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type { Covariant, NoInfer, NotFunction } from "./Types.js"
+import type { Covariant, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -629,12 +629,15 @@ export const as: {
  * @category mapping
  * @since 2.0.0
  */
-export const asUnit: <_>(self: Option<_>) => Option<void> = as(undefined)
+export const asVoid: <_>(self: Option<_>) => Option<void> = as(undefined)
 
-/**
- * @since 2.0.0
- */
-export const unit: Option<void> = some(undefined)
+const void_: Option<void> = some(undefined)
+export {
+  /**
+   * @since 2.0.0
+   */
+  void_ as void
+}
 
 /**
  * Applies a function to the value of an `Option` and flattens the result, if the input is `Some`.

package/src/{ReadonlyRecord.ts → Record.ts}

@@ -11,7 +11,6 @@ import type { Equivalence } from "./Equivalence.js"
 import { dual, identity } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as Option from "./Option.js"
-import type { NoInfer } from "./Types.js"
 
 /**
  * @category models
@@ -69,7 +68,7 @@ export const empty = <K extends string | symbol = never, V = never>(): Record<
  * @param self - record to test for emptiness.
  *
  * @example
- * import { isEmptyRecord } from "effect/ReadonlyRecord"
+ * import { isEmptyRecord } from "effect/Record"
  *
  * assert.deepStrictEqual(isEmptyRecord({}), true);
  * assert.deepStrictEqual(isEmptyRecord({ a: 3 }), false);
@@ -86,7 +85,7 @@ export const isEmptyRecord = <K extends string, A>(self: Record<K, A>): self is
  * @param self - record to test for emptiness.
  *
  * @example
- * import { isEmptyReadonlyRecord } from "effect/ReadonlyRecord"
+ * import { isEmptyReadonlyRecord } from "effect/Record"
  *
  * assert.deepStrictEqual(isEmptyReadonlyRecord({}), true);
  * assert.deepStrictEqual(isEmptyReadonlyRecord({ a: 3 }), false);
@@ -106,7 +105,7 @@ export const isEmptyReadonlyRecord: <K extends string, A>(
  * @param f - A projection function that maps values of the iterable to a tuple of a key and a value.
  *
  * @example
- * import { fromIterableWith } from "effect/ReadonlyRecord"
+ * import { fromIterableWith } from "effect/Record"
  *
  * const input = [1, 2, 3, 4]
  *
@@ -148,7 +147,7 @@ export const fromIterableWith: {
  * @param f - A function that extracts the key for each element.
  *
  * @example
- * import { fromIterableBy } from "effect/ReadonlyRecord"
+ * import { fromIterableBy } from "effect/Record"
  *
  * const users = [
  *   { id: "2", name: "name2" },
@@ -180,7 +179,7 @@ export const fromIterableBy = <A, K extends string | symbol>(
  * @param self - The iterable of key-value pairs.
  *
  * @example
- * import { fromEntries } from "effect/ReadonlyRecord"
+ * import { fromEntries } from "effect/Record"
  *
  * const input: Array<[string, number]> = [["a", 1], ["b", 2]]
  *
@@ -200,7 +199,7 @@ export const fromEntries: <Entry extends readonly [string | symbol, any]>(
  * @param f - The custom mapping function to apply to each key/value of the record.
  *
  * @example
- * import { collect } from "effect/ReadonlyRecord"
+ * import { collect } from "effect/Record"
  *
  * const x = { a: 1, b: 2, c: 3 }
  * assert.deepStrictEqual(collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]])
@@ -228,7 +227,7 @@ export const collect: {
  * @param self - The record to transform.
  *
  * @example
- * import { toEntries } from "effect/ReadonlyRecord"
+ * import { toEntries } from "effect/Record"
  *
  * const x = { a: 1, b: 2, c: 3 }
  * assert.deepStrictEqual(toEntries(x), [["a", 1], ["b", 2], ["c", 3]])
@@ -247,7 +246,7 @@ export const toEntries: <K extends string, A>(self: ReadonlyRecord<K, A>) => Arr
  * @param self - A record to calculate the number of key/value pairs in.
  *
  * @example
- * import { size } from "effect/ReadonlyRecord";
+ * import { size } from "effect/Record";
  *
  * assert.deepStrictEqual(size({ a: "a", b: 1, c: true }), 3);
  *
@@ -262,7 +261,7 @@ export const size = <K extends string, A>(self: ReadonlyRecord<K, A>): number =>
  * @param key - the key to look for in the record.
  *
  * @example
- * import { empty, has } from "effect/ReadonlyRecord"
+ * import { empty, has } from "effect/Record"
  *
  * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true);
  * assert.deepStrictEqual(has(empty<string>(), "c"), false);
@@ -292,7 +291,7 @@ export const has: {
  * @param key - Key to retrieve from record.
  *
  * @example
- * import { get } from "effect/ReadonlyRecord"
+ * import { get } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * const person: Record<string, unknown> = { name: "John Doe", age: 35 }
@@ -320,7 +319,7 @@ export const get: {
  * @param f - The function to apply to the element.
  *
  * @example
- * import { modify } from "effect/ReadonlyRecord"
+ * import { modify } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * const f = (x: number) => x * 2
@@ -361,7 +360,7 @@ export const modify: {
  * @param f - The function to apply to the element.
  *
  * @example
- * import { modifyOption } from "effect/ReadonlyRecord"
+ * import { modifyOption } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * const f = (x: number) => x * 2
@@ -409,7 +408,7 @@ export const modifyOption: {
  * @param b - The new value to replace the existing value with.
  *
  * @example
- * import { empty, replaceOption } from "effect/ReadonlyRecord"
+ * import { empty, replaceOption } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(
@@ -447,7 +446,7 @@ export const replaceOption: {
  * @param key - the key to remove from the record.
  *
  * @example
- * import { remove } from "effect/ReadonlyRecord"
+ * import { remove } from "effect/Record"
  *
  * assert.deepStrictEqual(remove({ a: 1, b: 2 }, "a"), { b: 2 })
  *
@@ -477,7 +476,7 @@ export const remove: {
  * @param key - The key of the property to retrieve.
  *
  * @example
- * import { pop } from "effect/ReadonlyRecord"
+ * import { pop } from "effect/Record"
  * import { some, none } from 'effect/Option'
  *
  * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "a"), some([1, { b: 2 }]))
@@ -507,7 +506,7 @@ export const pop: {
  * @param f - A transformation function that will be applied to each of the values in the record.
  *
  * @example
- * import { map } from "effect/ReadonlyRecord"
+ * import { map } from "effect/Record"
  *
  * const f = (n: number) => `-${n}`
  *
@@ -538,7 +537,7 @@ export const map: {
  * Maps the keys of a `ReadonlyRecord` while preserving the corresponding values.
  *
  * @example
- * import { mapKeys } from "effect/ReadonlyRecord"
+ * import { mapKeys } from "effect/Record"
  *
  * assert.deepStrictEqual(mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()), { A: 3, B: 5 })
  *
@@ -572,7 +571,7 @@ export const mapKeys: {
  * Maps entries of a `ReadonlyRecord` using the provided function, allowing modification of both keys and corresponding values.
  *
  * @example
- * import { mapEntries } from "effect/ReadonlyRecord"
+ * import { mapEntries } from "effect/Record"
  *
  * assert.deepStrictEqual(mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]), { A: 4, B: 6 })
  *
@@ -610,7 +609,7 @@ export const mapEntries: {
  * @param f - The transformation function.
  *
  * @example
- * import { filterMap } from "effect/ReadonlyRecord"
+ * import { filterMap } from "effect/Record"
  * import { some, none } from 'effect/Option'
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -651,7 +650,7 @@ export const filterMap: {
  * @param predicate - A function that returns a `boolean` value to determine if the entry should be included in the new record.
  *
  * @example
- * import { filter } from "effect/ReadonlyRecord"
+ * import { filter } from "effect/Record"
  *
  * const x = { a: 1, b: 2, c: 3, d: 4 }
  * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 })
@@ -696,7 +695,7 @@ export const filter: {
  * @param self - A record with `Option` values.
  *
  * @example
- * import { getSomes } from "effect/ReadonlyRecord"
+ * import { getSomes } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(
@@ -717,7 +716,7 @@ export const getSomes: <K extends string, A>(
  * Given a record with `Either` values, returns a new record containing only the `Left` values, preserving the original keys.
  *
  * @example
- * import { getLefts } from "effect/ReadonlyRecord"
+ * import { getLefts } from "effect/Record"
  * import { right, left } from "effect/Either"
  *
  * assert.deepStrictEqual(
@@ -746,7 +745,7 @@ export const getLefts = <K extends string, R, L>(
  * Given a record with `Either` values, returns a new record containing only the `Right` values, preserving the original keys.
  *
  * @example
- * import { getRights } from "effect/ReadonlyRecord"
+ * import { getRights } from "effect/Record"
  * import { right, left } from "effect/Either"
  *
  * assert.deepStrictEqual(
@@ -778,7 +777,7 @@ export const getRights = <K extends string, R, L>(
  * @param f - The predicate function to apply to each element.
  *
  * @example
- * import { partitionMap } from "effect/ReadonlyRecord"
+ * import { partitionMap } from "effect/Record"
  * import { left, right } from 'effect/Either'
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -825,7 +824,7 @@ export const partitionMap: {
  * @param self - the record to partition.
  *
  * @example
- * import { separate } from "effect/ReadonlyRecord"
+ * import { separate } from "effect/Record"
  * import { left, right } from 'effect/Either'
  *
  * assert.deepStrictEqual(
@@ -847,7 +846,7 @@ export const separate: <K extends string, A, B>(
  * @param predicate - The partitioning function to determine the partitioning of each value of the record.
  *
  * @example
- * import { partition } from "effect/ReadonlyRecord"
+ * import { partition } from "effect/Record"
  *
  * assert.deepStrictEqual(
  *   partition({ a: 1, b: 3 }, (n) => n > 2),
@@ -925,7 +924,7 @@ export const values = <K extends string, A>(self: ReadonlyRecord<K, A>): Array<A
  * @param values - The value you want to associate with the key.
  *
  * @example
- * import { set } from "effect/ReadonlyRecord"
+ * import { set } from "effect/Record"
  *
  * assert.deepStrictEqual(set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 });
  * assert.deepStrictEqual(set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 });
@@ -962,7 +961,7 @@ export const set: {
  * @param value - The new value to associate with the key.
  *
  * @example
- * import { replace } from "effect/ReadonlyRecord"
+ * import { replace } from "effect/Record"
  * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(replace("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 });

package/src/Request.ts

@@ -257,7 +257,7 @@ export interface Listeners {
  * @since 2.0.0
  */
 export interface Cache extends
-  _Cache.ConsumerCache<Request<any, any>, never, {
+  _Cache.ConsumerCache<Request<any, any>, {
     listeners: Listeners
     handle: Deferred<unknown, unknown>
   }>

package/src/RequestResolver.ts

@@ -187,13 +187,13 @@ export const around: {
  */
 export const aroundRequests: {
   <A, A2, R2, X, R3>(
-    before: (requests: ReadonlyArray<Types.NoInfer<A>>) => Effect.Effect<A2, never, R2>,
-    after: (requests: ReadonlyArray<Types.NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
   ): <R>(self: RequestResolver<A, R>) => RequestResolver<A, R2 | R3 | R>
   <A, R, A2, R2, X, R3>(
     self: RequestResolver<A, R>,
-    before: (requests: ReadonlyArray<Types.NoInfer<A>>) => Effect.Effect<A2, never, R2>,
-    after: (requests: ReadonlyArray<Types.NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
   ): RequestResolver<A, R | R2 | R3>
 } = internal.aroundRequests
 

package/src/STM.ts

@@ -14,7 +14,7 @@ import * as stm from "./internal/stm/stm.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
+import type { Covariant, MergeRecord } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -295,7 +295,7 @@ export const asSomeError: <A, E, R>(self: STM<A, E, R>) => STM<A, Option.Option<
  * @since 2.0.0
  * @category mapping
  */
-export const asUnit: <A, E, R>(self: STM<A, E, R>) => STM<void, E, R> = stm.asUnit
+export const asVoid: <A, E, R>(self: STM<A, E, R>) => STM<void, E, R> = stm.asVoid
 
 /**
  * Creates an `STM` value from a partial (but pure) function.
@@ -1860,13 +1860,16 @@ export const unlessSTM: {
  */
 export const unsome: <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<Option.Option<A>, E, R> = stm.unsome
 
-/**
- * Returns an `STM` effect that succeeds with `Unit`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const unit: STM<void> = stm.unit
+const void_: STM<void> = stm.void
+export {
+  /**
+   * Returns an `STM` effect that succeeds with `void`.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
+  void_ as void
+}
 
 /**
  * Feeds elements of type `A` to `f` and accumulates all errors in error

package/src/Schedule.ts

@@ -218,7 +218,7 @@ export const as: {
  * @since 2.0.0
  * @category constructors
  */
-export const asUnit: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<void, In, R> = internal.asUnit
+export const asVoid: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<void, In, R> = internal.asVoid
 
 /**
  * Returns a new schedule that has both the inputs and outputs of this and the