effect 2.0.0-next.53 → 2.0.0-next.55

package/src/GroupBy.ts

@@ -1,12 +1,12 @@
 /**
  * @since 2.0.0
  */
-import * as internal from "./internal/groupBy"
-import type { Pipeable } from "./Pipeable"
-import type { Predicate } from "./Predicate"
-import type * as Queue from "./Queue"
-import type * as Stream from "./Stream"
-import type * as Take from "./Take"
+import * as internal from "./internal/groupBy.js"
+import type { Pipeable } from "./Pipeable.js"
+import type { Predicate } from "./Predicate.js"
+import type * as Queue from "./Queue.js"
+import type * as Stream from "./Stream.js"
+import type * as Take from "./Take.js"
 
 /**
  * @since 2.0.0
@@ -60,12 +60,16 @@ export declare namespace GroupBy {
 export const evaluate: {
   <K, E, V, R2, E2, A>(
     f: (key: K, stream: Stream.Stream<never, E, V>) => Stream.Stream<R2, E2, A>,
-    options?: { readonly bufferSize?: number }
+    options?: {
+      readonly bufferSize?: number | undefined
+    }
   ): <R>(self: GroupBy<R, E, K, V>) => Stream.Stream<R2 | R, E | E2, A>
   <R, K, E, V, R2, E2, A>(
     self: GroupBy<R, E, K, V>,
     f: (key: K, stream: Stream.Stream<never, E, V>) => Stream.Stream<R2, E2, A>,
-    options?: { readonly bufferSize?: number }
+    options?: {
+      readonly bufferSize?: number | undefined
+    }
   ): Stream.Stream<R | R2, E | E2, A>
 } = internal.evaluate
 

package/src/Hash.ts

@@ -1,10 +1,10 @@
 /**
  * @since 2.0.0
  */
-import { pipe } from "./Function"
-import { globalValue } from "./GlobalValue"
-import { hasProperty } from "./Predicate"
-import { PCGRandom } from "./Utils"
+import { pipe } from "./Function.js"
+import { globalValue } from "./GlobalValue.js"
+import { hasProperty } from "./Predicate.js"
+import { PCGRandom } from "./Utils.js"
 
 /** @internal */
 const randomHashCache = globalValue(
@@ -28,7 +28,7 @@ export const symbol: unique symbol = Symbol.for("effect/Hash")
  * @category models
  */
 export interface Hash {
-  [symbol](): number
+  readonly [symbol]: () => number
 }
 
 /**
@@ -37,24 +37,18 @@ export interface Hash {
  */
 export const hash: <A>(self: A) => number = <A>(self: A) => {
   switch (typeof self) {
-    case "number": {
+    case "number":
       return number(self)
-    }
-    case "bigint": {
+    case "bigint":
       return string(self.toString(10))
-    }
-    case "boolean": {
+    case "boolean":
       return string(String(self))
-    }
-    case "symbol": {
+    case "symbol":
       return string(String(self))
-    }
-    case "string": {
+    case "string":
       return string(self)
-    }
-    case "undefined": {
+    case "undefined":
       return string("undefined")
-    }
     case "function":
     case "object": {
       if (self === null) {
@@ -66,9 +60,10 @@ export const hash: <A>(self: A) => number = <A>(self: A) => {
         return random(self)
       }
     }
-    default: {
-      throw new Error("Bug in Equal.hash")
-    }
+    default:
+      throw new Error(
+        `BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`
+      )
   }
 }
 

package/src/HashMap.ts

@@ -2,13 +2,13 @@
  * @since 2.0.0
  */
 
-import type { Equal } from "./Equal"
-import type { HashSet } from "./HashSet"
-import type { Inspectable } from "./Inspectable"
-import * as HM from "./internal/HashMap"
-import * as _keySet from "./internal/HashMap/keySet"
-import type { Option } from "./Option"
-import type { Pipeable } from "./Pipeable"
+import type { Equal } from "./Equal.js"
+import type { HashSet } from "./HashSet.js"
+import type { Inspectable } from "./Inspectable.js"
+import * as HM from "./internal/hashMap.js"
+import * as _keySet from "./internal/hashMap/keySet.js"
+import type { Option } from "./Option.js"
+import type { Pipeable } from "./Pipeable.js"
 
 const TypeId: unique symbol = HM.HashMapTypeId as TypeId
 
@@ -23,7 +23,7 @@ export type TypeId = typeof TypeId
  * @category models
  */
 export interface HashMap<Key, Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
-  [TypeId]: TypeId
+  readonly [TypeId]: TypeId
 }
 
 /**
@@ -206,6 +206,22 @@ export const keySet: <K, V>(self: HashMap<K, V>) => HashSet<K> = _keySet.keySet
  */
 export const values: <K, V>(self: HashMap<K, V>) => IterableIterator<V> = HM.values
 
+/**
+ * Returns an `IterableIterator` of the entries within the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const entries: <K, V>(self: HashMap<K, V>) => IterableIterator<[K, V]> = HM.entries
+
+/**
+ * Returns an `Array<[K, V]>` of the entries within the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const toEntries = <K, V>(self: HashMap<K, V>): Array<[K, V]> => Array.from(entries(self))
+
 /**
  * Returns the number of entries within the `HashMap`.
  *

package/src/HashSet.ts

@@ -2,11 +2,11 @@
  * @since 2.0.0
  */
 
-import type { Equal } from "./Equal"
-import type { Inspectable } from "./Inspectable"
-import * as HS from "./internal/HashSet"
-import type { Pipeable } from "./Pipeable"
-import type { Predicate, Refinement } from "./Predicate"
+import type { Equal } from "./Equal.js"
+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"
 
 const TypeId: unique symbol = HS.HashSetTypeId as TypeId
 

package/src/Inspectable.ts

@@ -2,7 +2,7 @@
  * @since 2.0.0
  */
 
-import { hasProperty, isFunction } from "./Predicate"
+import { hasProperty, isFunction } from "./Predicate.js"
 
 /**
  * @since 2.0.0

package/src/KeyedPool.ts

@@ -1,11 +1,11 @@
 /**
  * @since 2.0.0
  */
-import type * as Duration from "./Duration"
-import type * as Effect from "./Effect"
-import * as internal from "./internal/keyedPool"
-import type { Pipeable } from "./Pipeable"
-import type * as Scope from "./Scope"
+import type * as Duration from "./Duration.js"
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/keyedPool.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as Scope from "./Scope.js"
 
 /**
  * @since 2.0.0
@@ -33,14 +33,14 @@ export interface KeyedPool<K, E, A> extends KeyedPool.Variance<K, E, A>, Pipeabl
    * for that same reason. Retrying a failed acquisition attempt will repeat the
    * acquisition attempt.
    */
-  get(key: K): Effect.Effect<Scope.Scope, E, A>
+  readonly get: (key: K) => Effect.Effect<Scope.Scope, E, A>
 
   /**
    * Invalidates the specified item. This will cause the pool to eventually
    * reallocate the item, although this reallocation may occur lazily rather
    * than eagerly.
    */
-  invalidate(item: A): Effect.Effect<never, never, void>
+  readonly invalidate: (item: A) => Effect.Effect<never, never, void>
 }
 
 /**

package/src/Layer.ts

@@ -17,30 +17,30 @@
  *
  * @since 2.0.0
  */
-import type * as Cause from "./Cause"
-import type * as Clock from "./Clock"
-import type { ConfigProvider } from "./ConfigProvider"
-import * as Context from "./Context"
-import type * as Effect from "./Effect"
-import type * as Exit from "./Exit"
-import type { FiberRef } from "./FiberRef"
-import type { LazyArg } from "./Function"
-import { clockTag } from "./internal/clock"
-import * as core from "./internal/core"
-import * as defaultServices from "./internal/defaultServices"
-import * as fiberRuntime from "./internal/fiberRuntime"
-import * as internal from "./internal/layer"
-import * as circularLayer from "./internal/layer/circular"
-import * as query from "./internal/query"
-import type { LogLevel } from "./LogLevel"
-import type * as Option from "./Option"
-import type { Pipeable } from "./Pipeable"
-import type * as Request from "./Request"
-import type * as Runtime from "./Runtime"
-import type * as Schedule from "./Schedule"
-import * as Scheduler from "./Scheduler"
-import type * as Scope from "./Scope"
-import type * as Tracer from "./Tracer"
+import type * as Cause from "./Cause.js"
+import type * as Clock from "./Clock.js"
+import type { ConfigProvider } from "./ConfigProvider.js"
+import * as Context from "./Context.js"
+import type * as Effect from "./Effect.js"
+import type * as Exit from "./Exit.js"
+import type { FiberRef } from "./FiberRef.js"
+import type { LazyArg } from "./Function.js"
+import { clockTag } from "./internal/clock.js"
+import * as core from "./internal/core.js"
+import * as defaultServices from "./internal/defaultServices.js"
+import * as fiberRuntime from "./internal/fiberRuntime.js"
+import * as internal from "./internal/layer.js"
+import * as circularLayer from "./internal/layer/circular.js"
+import * as query from "./internal/query.js"
+import type { LogLevel } from "./LogLevel.js"
+import type * as Option from "./Option.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as Request from "./Request.js"
+import type * as Runtime from "./Runtime.js"
+import type * as Schedule from "./Schedule.js"
+import * as Scheduler from "./Scheduler.js"
+import type * as Scope from "./Scope.js"
+import type * as Tracer from "./Tracer.js"
 
 /**
  * @since 2.0.0
@@ -940,12 +940,14 @@ export const setScheduler: (scheduler: Scheduler.Scheduler) => Layer<never, neve
 export const span: (
   name: string,
   options?: {
-    readonly attributes?: Record<string, unknown>
-    readonly links?: ReadonlyArray<Tracer.SpanLink>
-    readonly parent?: Tracer.ParentSpan
-    readonly root?: boolean
-    readonly context?: Context.Context<never>
-    readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
+    readonly attributes?: Record<string, unknown> | undefined
+    readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+    readonly parent?: Tracer.ParentSpan | undefined
+    readonly root?: boolean | undefined
+    readonly context?: Context.Context<never> | undefined
+    readonly onEnd?:
+      | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>)
+      | undefined
   }
 ) => Layer<never, never, Tracer.ParentSpan> = circularLayer.span
 
@@ -985,24 +987,28 @@ export const withSpan: {
   (
     name: string,
     options?: {
-      readonly attributes?: Record<string, unknown>
-      readonly links?: ReadonlyArray<Tracer.SpanLink>
-      readonly parent?: Tracer.ParentSpan
-      readonly root?: boolean
-      readonly context?: Context.Context<never>
-      readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
+      readonly attributes?: Record<string, unknown> | undefined
+      readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+      readonly parent?: Tracer.ParentSpan | undefined
+      readonly root?: boolean | undefined
+      readonly context?: Context.Context<never> | undefined
+      readonly onEnd?:
+        | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>)
+        | undefined
     }
   ): <R, E, A>(self: Layer<R, E, A>) => Layer<Exclude<R, Tracer.ParentSpan>, E, A>
   <R, E, A>(
     self: Layer<R, E, A>,
     name: string,
     options?: {
-      readonly attributes?: Record<string, unknown>
-      readonly links?: ReadonlyArray<Tracer.SpanLink>
-      readonly parent?: Tracer.ParentSpan
-      readonly root?: boolean
-      readonly context?: Context.Context<never>
-      readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
+      readonly attributes?: Record<string, unknown> | undefined
+      readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+      readonly parent?: Tracer.ParentSpan | undefined
+      readonly root?: boolean | undefined
+      readonly context?: Context.Context<never> | undefined
+      readonly onEnd?:
+        | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>)
+        | undefined
     }
   ): Layer<Exclude<R, Tracer.ParentSpan>, E, A>
 } = internal.withSpan

package/src/List.ts

@@ -21,19 +21,18 @@
  * Licensed under Apache License 2.0
  * (http://www.apache.org/licenses/LICENSE-2.0).
  */
-import * as Chunk from "./Chunk"
-import * as Either from "./Either"
-import * as Equal from "./Equal"
-import * as Equivalence from "./Equivalence"
-import { dual, identity, unsafeCoerce } from "./Function"
-import * as Hash from "./Hash"
-import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable"
-import * as Option from "./Option"
-import type { Pipeable } from "./Pipeable"
-import { pipeArguments } from "./Pipeable"
-import type { Predicate, Refinement } from "./Predicate"
-import { hasProperty } from "./Predicate"
-import * as ReadonlyArray from "./ReadonlyArray"
+import * as Chunk from "./Chunk.js"
+import * as Either from "./Either.js"
+import * as Equal from "./Equal.js"
+import * as Equivalence from "./Equivalence.js"
+import { dual, identity, unsafeCoerce } from "./Function.js"
+import * as Hash from "./Hash.js"
+import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable.js"
+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"
 
 /**
  * Represents an immutable linked list of elements of type `A`.
@@ -80,19 +79,19 @@ export interface Cons<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable
 }
 
 /**
- * Converts the specified `List` to a `ReadonlyArray`.
+ * Converts the specified `List` to an `Array`.
  *
  * @category conversions
  * @since 2.0.0
  */
-export const toReadonlyArray = <A>(self: List<A>): ReadonlyArray<A> => Array.from(self)
+export const toArray = <A>(self: List<A>): Array<A> => Array.from(self)
 
 /**
  * @category equivalence
  * @since 2.0.0
  */
 export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equivalence.Equivalence<List<A>> =>
-  Equivalence.mapInput(ReadonlyArray.getEquivalence(isEquivalent), toReadonlyArray<A>)
+  Equivalence.mapInput(ReadonlyArray.getEquivalence(isEquivalent), toArray<A>)
 
 const _equivalence = getEquivalence(Equal.equals)
 
@@ -106,7 +105,7 @@ const ConsProto: Omit<Cons<unknown>, "head" | "tail"> = {
     return {
       _id: "List",
       _tag: "Cons",
-      values: toReadonlyArray(this).map(toJSON)
+      values: toArray(this).map(toJSON)
     }
   },
   [NodeInspectSymbol]() {
@@ -118,7 +117,7 @@ const ConsProto: Omit<Cons<unknown>, "head" | "tail"> = {
       _equivalence(this, that)
   },
   [Hash.symbol](this: Cons<unknown>): number {
-    return Hash.array(toReadonlyArray(this))
+    return Hash.array(toArray(this))
   },
   [Symbol.iterator](this: Cons<unknown>): Iterator<unknown> {
     let done = false
@@ -178,7 +177,7 @@ const NilProto: Nil<unknown> = {
     return this.toJSON()
   },
   [Hash.symbol](): number {
-    return Hash.array(toReadonlyArray(this))
+    return Hash.array(toArray(this))
   },
   [Equal.symbol](that: unknown): boolean {
     return isList(that) && this._tag === that._tag
@@ -787,9 +786,9 @@ export const partition: {
  * @category combinators
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => readonly [List<B>, List<C>]
-  <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): readonly [List<B>, List<C>]
-} = dual(2, <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): readonly [List<B>, List<C>] => {
+  <A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => [List<B>, List<C>]
+  <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): [List<B>, List<C>]
+} = dual(2, <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): [List<B>, List<C>] => {
   const left: Array<B> = []
   const right: Array<C> = []
   for (const a of self) {
@@ -866,9 +865,9 @@ export const reverse = <A>(self: List<A>): List<A> => {
  * @category combinators
  */
 export const splitAt: {
-  (n: number): <A>(self: List<A>) => readonly [List<A>, List<A>]
-  <A>(self: List<A>, n: number): readonly [List<A>, List<A>]
-} = dual(2, <A>(self: List<A>, n: number): readonly [List<A>, List<A>] => [take(self, n), drop(self, n)])
+  (n: number): <A>(self: List<A>) => [List<A>, List<A>]
+  <A>(self: List<A>, n: number): [List<A>, List<A>]
+} = dual(2, <A>(self: List<A>, n: number): [List<A>, List<A>] => [take(self, n), drop(self, n)])
 
 /**
  * Returns the tail of the specified list, or `None` if the list is empty.

package/src/LogLevel.ts

@@ -1,12 +1,12 @@
 /**
  * @since 2.0.0
  */
-import type * as Effect from "./Effect"
-import { dual, pipe } from "./Function"
-import * as core from "./internal/core"
-import * as number from "./Number"
-import * as order from "./Order"
-import type { Pipeable } from "./Pipeable"
+import type * as Effect from "./Effect.js"
+import { dual, pipe } from "./Function.js"
+import * as core from "./internal/core.js"
+import * as number from "./Number.js"
+import * as order from "./Order.js"
+import type { Pipeable } from "./Pipeable.js"
 
 /**
  * A `LogLevel` represents the log level associated with an individual logging
@@ -234,33 +234,23 @@ export const greaterThanEqual: {
  * @since 2.0.0
  * @category conversions
  */
-export const fromLiteral = (
-  _: Literal
-): LogLevel => {
-  switch (_) {
-    case "All": {
+export const fromLiteral = (literal: Literal): LogLevel => {
+  switch (literal) {
+    case "All":
       return All
-    }
-    case "Debug": {
+    case "Debug":
       return Debug
-    }
-    case "Error": {
+    case "Error":
       return Error
-    }
-    case "Fatal": {
+    case "Fatal":
       return Fatal
-    }
-    case "Info": {
+    case "Info":
       return Info
-    }
-    case "Trace": {
+    case "Trace":
       return Trace
-    }
-    case "None": {
+    case "None":
       return None
-    }
-    case "Warning": {
+    case "Warning":
       return Warning
-    }
   }
 }

package/src/LogSpan.ts

@@ -1,7 +1,7 @@
 /**
  * @since 2.0.0
  */
-import * as internal from "./internal/logSpan"
+import * as internal from "./internal/logSpan.js"
 
 /**
  * @since 2.0.0