effect 2.4.18 → 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)
 
@@ -924,6 +923,8 @@ export const take: {
  */
 export const toChunk = <A>(self: List<A>): Chunk.Chunk<A> => Chunk.fromIterable(self)
 
+const getExpectedListToBeNonEmptyErrorMessage = "Expected List to be non-empty"
+
 /**
  * Unsafely returns the first element of the specified `List`.
  *
@@ -932,7 +933,7 @@ export const toChunk = <A>(self: List<A>): Chunk.Chunk<A> => Chunk.fromIterable(
  */
 export const unsafeHead = <A>(self: List<A>): A => {
   if (isNil(self)) {
-    throw new Error("Expected List to be non-empty")
+    throw new Error(getExpectedListToBeNonEmptyErrorMessage)
   }
   return self.head
 }
@@ -945,7 +946,7 @@ export const unsafeHead = <A>(self: List<A>): A => {
  */
 export const unsafeLast = <A>(self: List<A>): A => {
   if (isNil(self)) {
-    throw new Error("Expected List to be non-empty")
+    throw new Error(getExpectedListToBeNonEmptyErrorMessage)
   }
   let these = self
   let scout = self.tail
@@ -964,7 +965,7 @@ export const unsafeLast = <A>(self: List<A>): A => {
  */
 export const unsafeTail = <A>(self: List<A>): List<A> => {
   if (isNil(self)) {
-    throw new Error("Expected List to be non-empty")
+    throw new Error(getExpectedListToBeNonEmptyErrorMessage)
   }
   return self.tail
 }

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/Readable.ts

@@ -0,0 +1,92 @@
+/**
+ * @since 2.0.0
+ */
+import type { Effect } from "./Effect.js"
+import { dual } from "./Function.js"
+import * as core from "./internal/core.js"
+import { type Pipeable, pipeArguments } from "./Pipeable.js"
+import { hasProperty } from "./Predicate.js"
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId = Symbol.for("effect/Readable")
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Readable<A, E = never, R = never> extends Pipeable {
+  readonly [TypeId]: TypeId
+  readonly get: Effect<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isReadable = (u: unknown): u is Readable<unknown, unknown, unknown> => hasProperty(u, TypeId)
+
+const Proto: Omit<Readable<any>, "get"> = {
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = <A, E, R>(get: Effect<A, E, R>): Readable<A, E, R> => {
+  const self = Object.create(Proto)
+  self.get = get
+  return self
+}
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const map: {
+  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Readable<A, E, R>) => Readable<B, E, R>
+  <A, E, R, B>(self: Readable<A, E, R>, f: (a: NoInfer<A>) => B): Readable<B, E, R>
+} = dual(
+  2,
+  <A, E, R, B>(self: Readable<A, E, R>, f: (a: NoInfer<A>) => B): Readable<B, E, R> => make(core.map(self.get, f))
+)
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  <A, B, E2, R2>(
+    f: (a: NoInfer<A>) => Effect<B, E2, R2>
+  ): <E, R>(fa: Readable<A, E, R>) => Readable<B, E | E2, R | R2>
+  <A, E, R, B, E2, R2>(
+    self: Readable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect<B, E2, R2>
+  ): Readable<B, E | E2, R | R2>
+} = dual(2, <A, E, R, B, E2, R2>(
+  self: Readable<A, E, R>,
+  f: (a: NoInfer<A>) => Effect<B, E2, R2>
+): Readable<B, E | E2, R | R2> => make(core.flatMap(self.get, f)))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+  effect: Effect<Readable<A, E, R>, E1, R1>
+): Readable<A, E | E1, R | R1> =>
+  make(
+    core.flatMap(effect, (s) => s.get)
+  )