effect 3.1.1 → 3.1.2

package/src/Order.ts

@@ -318,8 +318,7 @@ export const max = <A>(O: Order<A>): {
  * Clamp a value between a minimum and a maximum.
  *
  * @example
- * import * as Order from "effect/Order"
- * import * as Number from "effect/Number"
+ * import { Order, Number } from "effect"
  *
  * const clamp = Order.clamp(Number.Order)({ minimum: 1, maximum: 5 })
  *

package/src/Ordering.ts

@@ -35,10 +35,10 @@ export const reverse = (o: Ordering): Ordering => (o === -1 ? 1 : o === 1 ? -1 :
  * @param onGreaterThan - A function that will be called if the `Ordering` parameter is `1`.
  *
  * @example
- * import { match } from "effect/Ordering"
+ * import { Ordering } from "effect"
  * import { constant } from "effect/Function"
  *
- * const toMessage = match({
+ * const toMessage = Ordering.match({
  *   onLessThan: constant('less than'),
  *   onEqual: constant('equal'),
  *   onGreaterThan: constant('greater than')

package/src/Predicate.ts

@@ -35,10 +35,9 @@ export interface Refinement<in A, out B extends A> {
  * @param f - a function to transform `B` to `A`.
  *
  * @example
- * import * as P from "effect/Predicate"
- * import * as N from "effect/Number"
+ * import { Predicate, Number } from "effect"
  *
- * const minLength3 = P.mapInput(N.greaterThan(2), (s: string) => s.length)
+ * const minLength3 = Predicate.mapInput(Number.greaterThan(2), (s: string) => s.length)
  *
  * assert.deepStrictEqual(minLength3("a"), false)
  * assert.deepStrictEqual(minLength3("aa"), false)
@@ -59,7 +58,7 @@ export const mapInput: {
  * @param input - The value to test.
  *
  * @example
- * import { isTruthy } from 'effect/Predicate'
+ * import { isTruthy } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isTruthy(1), true)
  * assert.deepStrictEqual(isTruthy(0), false)
@@ -658,10 +657,9 @@ export const struct = <R extends Record<string, Predicate<any>>>(
  * @param self - A predicate.
  *
  * @example
- * import * as P from "effect/Predicate"
- * import * as N from "effect/Number"
+ * import { Predicate, Number } from "effect"
  *
- * const isPositive = P.not(N.lessThan(0))
+ * const isPositive = Predicate.not(Number.lessThan(0))
  *
  * assert.deepStrictEqual(isPositive(-1), false)
  * assert.deepStrictEqual(isPositive(0), true)
@@ -679,10 +677,9 @@ export const not = <A>(self: Predicate<A>): Predicate<A> => (a) => !self(a)
  * @param that - A predicate.
  *
  * @example
- * import * as P from "effect/Predicate"
- * import * as N from "effect/Number"
+ * import { Predicate, Number } from "effect"
  *
- * const nonZero = P.or(N.lessThan(0), N.greaterThan(0))
+ * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
  *
  * assert.deepStrictEqual(nonZero(-1), true)
  * assert.deepStrictEqual(nonZero(0), false)
@@ -703,12 +700,12 @@ export const or: {
  * @param that - A predicate.
  *
  * @example
- * import * as P from "effect/Predicate"
+ * import { Predicate } from "effect"
  *
  * const minLength = (n: number) => (s: string) => s.length >= n
  * const maxLength = (n: number) => (s: string) => s.length <= n
  *
- * const length = (n: number) => P.and(minLength(n), maxLength(n))
+ * const length = (n: number) => Predicate.and(minLength(n), maxLength(n))
  *
  * assert.deepStrictEqual(length(2)("aa"), true)
  * assert.deepStrictEqual(length(2)("a"), false)

package/src/Readable.ts

@@ -12,7 +12,7 @@ import type { NoInfer } from "./Types.js"
  * @since 2.0.0
  * @category type ids
  */
-export const TypeId = Symbol.for("effect/Readable")
+export const TypeId: unique symbol = Symbol.for("effect/Readable")
 
 /**
  * @since 2.0.0

package/src/Record.ts

@@ -292,13 +292,12 @@ export const has: {
  * @param key - Key to retrieve from record.
  *
  * @example
- * import { get } from "effect/Record"
- * import { some, none } from "effect/Option"
+ * import { Record as R, Option } from "effect"
  *
  * const person: Record<string, unknown> = { name: "John Doe", age: 35 }
  *
- * assert.deepStrictEqual(get(person, "name"), some("John Doe"))
- * assert.deepStrictEqual(get(person, "email"), none())
+ * assert.deepStrictEqual(R.get(person, "name"), Option.some("John Doe"))
+ * assert.deepStrictEqual(R.get(person, "email"), Option.none())
  *
  * @since 2.0.0
  */
@@ -320,17 +319,16 @@ export const get: {
  * @param f - The function to apply to the element.
  *
  * @example
- * import { modify } from "effect/Record"
- * import { some, none } from "effect/Option"
+ * import { Record as R } from "effect"
  *
  * const f = (x: number) => x * 2
  *
  * assert.deepStrictEqual(
- *  modify({ a: 3 }, 'a', f),
+ *  R.modify({ a: 3 }, 'a', f),
  *  { a: 6 }
  * )
  * assert.deepStrictEqual(
- *  modify({ a: 3 } as Record<string, number>, 'b', f),
+ *  R.modify({ a: 3 } as Record<string, number>, 'b', f),
  *  { a: 3 }
  * )
  *
@@ -361,18 +359,17 @@ export const modify: {
  * @param f - The function to apply to the element.
  *
  * @example
- * import { modifyOption } from "effect/Record"
- * import { some, none } from "effect/Option"
+ * import { Record as R, Option } from "effect"
  *
  * const f = (x: number) => x * 2
  *
  * assert.deepStrictEqual(
- *  modifyOption({ a: 3 }, 'a', f),
- *  some({ a: 6 })
+ *  R.modifyOption({ a: 3 }, 'a', f),
+ *  Option.some({ a: 6 })
  * )
  * assert.deepStrictEqual(
- *  modifyOption({ a: 3 } as Record<string, number>, 'b', f),
- *  none()
+ *  R.modifyOption({ a: 3 } as Record<string, number>, 'b', f),
+ *  Option.none()
  * )
  *
  * @since 2.0.0
@@ -409,14 +406,13 @@ export const modifyOption: {
  * @param b - The new value to replace the existing value with.
  *
  * @example
- * import { empty, replaceOption } from "effect/Record"
- * import { some, none } from "effect/Option"
+ * import { Record, Option } from "effect"
  *
  * assert.deepStrictEqual(
- *   replaceOption({ a: 1, b: 2, c: 3 }, 'a', 10),
- *   some({ a: 10, b: 2, c: 3 })
+ *   Record.replaceOption({ a: 1, b: 2, c: 3 }, 'a', 10),
+ *   Option.some({ a: 10, b: 2, c: 3 })
  * )
- * assert.deepStrictEqual(replaceOption(empty<string>(), 'a', 10), none())
+ * assert.deepStrictEqual(Record.replaceOption(Record.empty<string>(), 'a', 10), Option.none())
  *
  * @since 2.0.0
  */
@@ -477,11 +473,10 @@ export const remove: {
  * @param key - The key of the property to retrieve.
  *
  * @example
- * import { pop } from "effect/Record"
- * import { some, none } from 'effect/Option'
+ * import { Record as R, Option } from "effect"
  *
- * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "a"), some([1, { b: 2 }]))
- * assert.deepStrictEqual(pop({ a: 1, b: 2 } as Record<string, number>, "c"), none())
+ * assert.deepStrictEqual(R.pop({ a: 1, b: 2 }, "a"), Option.some([1, { b: 2 }]))
+ * assert.deepStrictEqual(R.pop({ a: 1, b: 2 } as Record<string, number>, "c"), Option.none())
  *
  * @category record
  * @since 2.0.0
@@ -610,12 +605,11 @@ export const mapEntries: {
  * @param f - The transformation function.
  *
  * @example
- * import { filterMap } from "effect/Record"
- * import { some, none } from 'effect/Option'
+ * import { Record, Option } from "effect"
  *
  * const x = { a: 1, b: 2, c: 3 }
- * const f = (a: number, key: string) => a > 2 ? some(a * 2) : none()
- * assert.deepStrictEqual(filterMap(x, f), { c: 6 })
+ * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+ * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
  *
  * @since 2.0.0
  */
@@ -696,11 +690,10 @@ export const filter: {
  * @param self - A record with `Option` values.
  *
  * @example
- * import { getSomes } from "effect/Record"
- * import { some, none } from "effect/Option"
+ * import { Record, Option } from "effect"
  *
  * assert.deepStrictEqual(
- *   getSomes({ a: some(1), b: none(), c: some(2) }),
+ *   Record.getSomes({ a: Option.some(1), b: Option.none(), c: Option.some(2) }),
  *   { a: 1, c: 2 }
  * )
  *
@@ -717,11 +710,10 @@ 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/Record"
- * import { right, left } from "effect/Either"
+ * import { Record, Either } from "effect"
  *
  * assert.deepStrictEqual(
- *   getLefts({ a: right(1), b: left("err"), c: right(2) }),
+ *   Record.getLefts({ a: Either.right(1), b: Either.left("err"), c: Either.right(2) }),
  *   { b: "err" }
  * )
  *
@@ -746,11 +738,10 @@ 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/Record"
- * import { right, left } from "effect/Either"
+ * import { Record, Either } from "effect"
  *
  * assert.deepStrictEqual(
- *   getRights({ a: right(1), b: left("err"), c: right(2) }),
+ *   Record.getRights({ a: Either.right(1), b: Either.left("err"), c: Either.right(2) }),
  *   { a: 1, c: 2 }
  * )
  *
@@ -778,12 +769,11 @@ export const getRights = <K extends string, R, L>(
  * @param f - The predicate function to apply to each element.
  *
  * @example
- * import { partitionMap } from "effect/Record"
- * import { left, right } from 'effect/Either'
+ * import { Record, Either } from "effect"
  *
  * const x = { a: 1, b: 2, c: 3 }
- * const f = (n: number) => (n % 2 === 0 ? right(n) : left(n))
- * assert.deepStrictEqual(partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2}])
+ * const f = (n: number) => (n % 2 === 0 ? Either.right(n) : Either.left(n))
+ * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2}])
  *
  * @category filtering
  * @since 2.0.0
@@ -825,11 +815,10 @@ export const partitionMap: {
  * @param self - the record to partition.
  *
  * @example
- * import { separate } from "effect/Record"
- * import { left, right } from 'effect/Either'
+ * import { Record, Either } from "effect"
  *
  * assert.deepStrictEqual(
- *   separate({ a: left("e"), b: right(1) }),
+ *   Record.separate({ a: Either.left("e"), b: Either.right(1) }),
  *   [{ a: "e" }, { b: 1 }]
  * )
  *
@@ -962,11 +951,10 @@ export const set: {
  * @param value - The new value to associate with the key.
  *
  * @example
- * import { replace } from "effect/Record"
- * import { some, none } from "effect/Option"
+ * import { Record } from "effect"
  *
- * assert.deepStrictEqual(replace("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 });
- * assert.deepStrictEqual(replace("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 });
+ * assert.deepStrictEqual(Record.replace("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 });
+ * assert.deepStrictEqual(Record.replace("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 });
  *
  * @since 2.0.0
  */

package/src/RegExp.ts

@@ -8,7 +8,7 @@
  * Escapes special characters in a regular expression pattern.
  *
  * @example
- * import * as RegExp from "effect/RegExp"
+ * import { RegExp } from "effect"
  *
  * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
  *

package/src/Request.ts

@@ -125,7 +125,7 @@ export const tagged: <R extends Request<any, any> & { _tag: string }>(
  * Provides a constructor for a Request Class.
  *
  * @example
- * import * as Request from "effect/Request"
+ * import { Request } from "effect"
  *
  * type Success = string
  * type Error = never
@@ -146,7 +146,7 @@ export const Class: new<Success, Error, A extends Record<string, any>>(
  * Provides a Tagged constructor for a Request Class.
  *
  * @example
- * import * as Request from "effect/Request"
+ * import { Request } from "effect"
  *
  * type Success = string
  * type Error = never
@@ -283,7 +283,7 @@ export const makeCache = (
  * @since 2.0.0
  * @category symbols
  */
-export const EntryTypeId = Symbol.for("effect/RequestBlock.Entry")
+export const EntryTypeId: unique symbol = Symbol.for("effect/RequestBlock.Entry")
 
 /**
  * @since 2.0.0

package/src/Stream.ts

@@ -29,7 +29,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
-import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -4440,86 +4440,187 @@ export const zipWithIndex: <A, E, R>(self: Stream<A, E, R>) => Stream<[A, number
 // -------------------------------------------------------------------------------------
 
 /**
- * @since 2.0.0
+ * The "do simulation" in allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * Here's how the do simulation works:
+ *
+ * 1. Start the do simulation using the `Do` value
+ * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Stream` values
+ * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
+ * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
+ *
+ * @see {@link bindTo}
+ * @see {@link bind}
+ * @see {@link bindEffect}
+ * @see {@link let_ let}
+ *
+ * @example
+ * import { Chunk, Effect, pipe, Stream } from "effect"
+ *
+ * const result = pipe(
+ *   Stream.Do,
+ *   Stream.bind("x", () => Stream.succeed(2)),
+ *   Stream.bind("y", () => Stream.succeed(3)),
+ *   Stream.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(Effect.runSync(Stream.runCollect(result)), Chunk.of({ x: 2, y: 3, sum: 5 }))
+ *
  * @category do notation
+ * @since 2.0.0
  */
 export const Do: Stream<{}> = internal.Do
 
 /**
- * Binds a value from a stream in a `do` scope
+ * The "do simulation" in allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * Here's how the do simulation works:
+ *
+ * 1. Start the do simulation using the `Do` value
+ * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Stream` values
+ * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
+ * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
+ *
+ * @see {@link Do}
+ * @see {@link bindTo}
+ * @see {@link bindEffect}
+ * @see {@link let_ let}
+ *
+ * @example
+ * import { Chunk, Effect, pipe, Stream } from "effect"
+ *
+ * const result = pipe(
+ *   Stream.Do,
+ *   Stream.bind("x", () => Stream.succeed(2)),
+ *   Stream.bind("y", () => Stream.succeed(3)),
+ *   Stream.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(Effect.runSync(Stream.runCollect(result)), Chunk.of({ x: 2, y: 3, sum: 5 }))
  *
- * @since 2.0.0
  * @category do notation
+ * @since 2.0.0
  */
 export const bind: {
-  <N extends string, K, A, E2, R2>(
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Stream<A, E2, R2>,
+  <N extends string, A, B, E2, R2>(
+    tag: Exclude<N, keyof A>,
+    f: (_: A) => Stream<B, E2, R2>,
     options?:
       | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
       | undefined
-  ): <E, R>(self: Stream<K, E, R>) => Stream<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
-  <K, E, R, N extends string, A, E2, R2>(
-    self: Stream<K, E, R>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Stream<A, E2, R2>,
+  ): <E, R>(self: Stream<A, E, R>) => Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E, R2 | R>
+  <A, E, R, N extends string, B, E2, R2>(
+    self: Stream<A, E, R>,
+    tag: Exclude<N, keyof A>,
+    f: (_: A) => Stream<B, E2, R2>,
     options?:
       | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
       | undefined
-  ): Stream<MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>
+  ): Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E | E2, R | R2>
 } = internal.bind
 
 /**
  * Binds an effectful value in a `do` scope
  *
+ * @see {@link Do}
+ * @see {@link bindTo}
+ * @see {@link bind}
+ * @see {@link let_ let}
+ *
  * @since 2.0.0
  * @category do notation
  */
 export const bindEffect: {
-  <N extends string, K, A, E2, R2>(
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<A, E2, R2>,
+  <N extends string, A, B, E2, R2>(
+    tag: Exclude<N, keyof A>,
+    f: (_: A) => Effect.Effect<B, E2, R2>,
     options?:
       | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
       | undefined
-  ): <E, R>(self: Stream<K, E, R>) => Stream<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
-  <K, E, R, N extends string, A, E2, R2>(
-    self: Stream<K, E, R>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<A, E2, R2>,
+  ): <E, R>(self: Stream<A, E, R>) => Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E, R2 | R>
+  <A, E, R, N extends string, B, E2, R2>(
+    self: Stream<A, E, R>,
+    tag: Exclude<N, keyof A>,
+    f: (_: A) => Effect.Effect<B, E2, R2>,
     options?:
       | { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
       | undefined
-  ): Stream<MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>
+  ): Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E | E2, R | R2>
 } = _groupBy.bindEffect
 
 /**
- * @since 2.0.0
+ * The "do simulation" in allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * Here's how the do simulation works:
+ *
+ * 1. Start the do simulation using the `Do` value
+ * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Stream` values
+ * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
+ * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
+ *
+ * @see {@link Do}
+ * @see {@link bind}
+ * @see {@link bindEffect}
+ * @see {@link let_ let}
+ *
+ * @example
+ * import { Chunk, Effect, pipe, Stream } from "effect"
+ *
+ * const result = pipe(
+ *   Stream.Do,
+ *   Stream.bind("x", () => Stream.succeed(2)),
+ *   Stream.bind("y", () => Stream.succeed(3)),
+ *   Stream.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(Effect.runSync(Stream.runCollect(result)), Chunk.of({ x: 2, y: 3, sum: 5 }))
+ *
  * @category do notation
+ * @since 2.0.0
  */
 export const bindTo: {
-  <N extends string>(tag: N): <A, E, R>(self: Stream<A, E, R>) => Stream<Record<N, A>, E, R>
-  <A, E, R, N extends string>(self: Stream<A, E, R>, tag: N): Stream<Record<N, A>, E, R>
+  <N extends string>(name: N): <A, E, R>(self: Stream<A, E, R>) => Stream<{ [K in N]: A }, E, R>
+  <A, E, R, N extends string>(self: Stream<A, E, R>, name: N): Stream<{ [K in N]: A }, E, R>
 } = internal.bindTo
 
 const let_: {
-  <N extends string, K, A>(
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => A
-  ): <E, R>(self: Stream<K, E, R>) => Stream<MergeRecord<K, { [k in N]: A }>, E, R>
-  <K, E, R, N extends string, A>(
-    self: Stream<K, E, R>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => A
-  ): Stream<MergeRecord<K, { [k in N]: A }>, E, R>
+  <N extends string, A extends object, B>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): <E, R>(self: Stream<A, E, R>) => Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
+  <A extends object, E, R, N extends string, B>(
+    self: Stream<A, E, R>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
 } = internal.let_
 
 export {
   /**
-   * Bind a value in a `do` scope
+   * The "do simulation" in allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+   *
+   * Here's how the do simulation works:
+   *
+   * 1. Start the do simulation using the `Do` value
+   * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Stream` values
+   * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
+   * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
+   *
+   * @see {@link Do}
+   * @see {@link bindTo}
+   * @see {@link bind}
+   * @see {@link bindEffect}
+   *
+   * @example
+   * import { Chunk, Effect, pipe, Stream } from "effect"
+   *
+   * const result = pipe(
+   *   Stream.Do,
+   *   Stream.bind("x", () => Stream.succeed(2)),
+   *   Stream.bind("y", () => Stream.succeed(3)),
+   *   Stream.let("sum", ({ x, y }) => x + y)
+   * )
+   * assert.deepStrictEqual(Effect.runSync(Stream.runCollect(result)), Chunk.of({ x: 2, y: 3, sum: 5 }))
    *
-   * @since 2.0.0
    * @category do notation
+   * @since 2.0.0
    */
   let_ as let
 }