effect 3.1.6 → 3.2.0

package/dist/esm/internal/tracer.js

@@ -82,4 +82,33 @@ export const externalSpan = options => ({
   sampled: options.sampled ?? true,
   context: options.context ?? Context.empty()
 });
+/** @internal */
+export const addSpanStackTrace = options => {
+  if (options?.captureStackTrace === false) {
+    return options;
+  } else if (options?.captureStackTrace !== undefined && typeof options.captureStackTrace !== "boolean") {
+    return options;
+  }
+  const limit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 3;
+  const traceError = new Error();
+  Error.stackTraceLimit = limit;
+  if (traceError.stack === undefined) {
+    return {
+      ...options,
+      captureStackTrace: false
+    };
+  }
+  const stack = traceError.stack.split("\n");
+  if (!stack[3]) {
+    return {
+      ...options,
+      captureStackTrace: false
+    };
+  }
+  return {
+    ...options,
+    captureStackTrace: stack[3].trim()
+  };
+};
 //# sourceMappingURL=tracer.js.map

package/dist/esm/internal/tracer.js.map

@@ -1 +1 @@
-{"version":3,"file":"tracer.js","names":["Context","TracerTypeId","Symbol","for","make","options","tracerTag","GenericTag","spanTag","randomHexString","characters","charactersLength","length","result","i","charAt","Math","floor","random","NativeSpan","name","parent","context","links","startTime","kind","_tag","spanId","traceId","sampled","status","attributes","events","constructor","Map","value","end","endTime","exit","attribute","key","set","event","push","nativeTracer","span","f","externalSpan","empty"],"sources":["../../../src/internal/tracer.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"tracer.js","names":["Context","TracerTypeId","Symbol","for","make","options","tracerTag","GenericTag","spanTag","randomHexString","characters","charactersLength","length","result","i","charAt","Math","floor","random","NativeSpan","name","parent","context","links","startTime","kind","_tag","spanId","traceId","sampled","status","attributes","events","constructor","Map","value","end","endTime","exit","attribute","key","set","event","push","nativeTracer","span","f","externalSpan","empty","addSpanStackTrace","captureStackTrace","undefined","limit","Error","stackTraceLimit","traceError","stack","split","trim"],"sources":["../../../src/internal/tracer.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.1.6";
+let moduleVersion = "3.2.0";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.1.6",
+  "version": "3.2.0",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Array.ts

@@ -12,6 +12,7 @@ import type { LazyArg } from "./Function.js"
 import { dual, identity } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as readonlyArray from "./internal/array.js"
+import * as doNotation from "./internal/doNotation.js"
 import * as EffectIterable from "./Iterable.js"
 import type { Option } from "./Option.js"
 import * as O from "./Option.js"
@@ -2111,3 +2112,216 @@ export const cartesian: {
   2,
   <A, B>(self: ReadonlyArray<A>, that: ReadonlyArray<B>): Array<[A, B]> => cartesianWith(self, that, (a, b) => [a, b])
 )
+
+// -------------------------------------------------------------------------------------
+// do notation
+// -------------------------------------------------------------------------------------
+
+/**
+ * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
+ *
+ * It can be used to simulate "array comprehension".
+ * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules.
+ *
+ * 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 `Array` 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
+ * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
+ *
+ * @see {@link bindTo}
+ * @see {@link bind}
+ * @see {@link let_ let}
+ *
+ * @example
+ * import { Array as Arr, pipe } from "effect"
+ * const doResult = pipe(
+ *   Arr.Do,
+ *   Arr.bind("x", () => [1, 3, 5]),
+ *   Arr.bind("y", () => [2, 4, 6]),
+ *   Arr.filter(({ x, y }) => x < y), // condition
+ *   Arr.map(({ x, y }) => [x, y] as const) // transformation
+ * )
+ * assert.deepStrictEqual(doResult, [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]])
+ *
+ * // equivalent
+ * const x = [1, 3, 5],
+ *       y = [2, 4, 6],
+ *       result = [];
+ * for(let i = 0; i < x.length; i++) {
+ *   for(let j = 0; j < y.length; j++) {
+ *     const _x = x[i], _y = y[j];
+ *     if(_x < _y) result.push([_x, _y] as const)
+ *   }
+ * }
+ *
+ * @category do notation
+ * @since 3.2.0
+ */
+export const Do: ReadonlyArray<{}> = of({})
+
+/**
+ * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
+ *
+ * It can be used to simulate "array comprehension".
+ * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules.
+ *
+ * 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 `Array` 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
+ * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
+ *
+ * @see {@link bindTo}
+ * @see {@link Do}
+ * @see {@link let_ let}
+ *
+ * @example
+ * import { Array as Arr, pipe } from "effect"
+ * const doResult = pipe(
+ *   Arr.Do,
+ *   Arr.bind("x", () => [1, 3, 5]),
+ *   Arr.bind("y", () => [2, 4, 6]),
+ *   Arr.filter(({ x, y }) => x < y), // condition
+ *   Arr.map(({ x, y }) => [x, y] as const) // transformation
+ * )
+ * assert.deepStrictEqual(doResult, [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]])
+ *
+ * // equivalent
+ * const x = [1, 3, 5],
+ *       y = [2, 4, 6],
+ *       result = [];
+ * for(let i = 0; i < x.length; i++) {
+ *   for(let j = 0; j < y.length; j++) {
+ *     const _x = x[i], _y = y[j];
+ *     if(_x < _y) result.push([_x, _y] as const)
+ *   }
+ * }
+ *
+ * @category do notation
+ * @since 3.2.0
+ */
+export const bind: {
+  <A extends object, N extends string, B>(
+    tag: Exclude<N, keyof A>,
+    f: (a: A) => ReadonlyArray<B>
+  ): (
+    self: ReadonlyArray<A>
+  ) => Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
+  <A extends object, N extends string, B>(
+    self: ReadonlyArray<A>,
+    tag: Exclude<N, keyof A>,
+    f: (a: A) => ReadonlyArray<B>
+  ): Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
+} = doNotation.bind<ReadonlyArrayTypeLambda>(map, flatMap) as any
+
+/**
+ * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
+ *
+ * It can be used to simulate "array comprehension".
+ * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules.
+ *
+ * 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 `Array` 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
+ * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
+ *
+ * @see {@link bindTo}
+ * @see {@link Do}
+ * @see {@link let_ let}
+ *
+ * @example
+ * import { Array as Arr, pipe } from "effect"
+ * const doResult = pipe(
+ *   Arr.Do,
+ *   Arr.bind("x", () => [1, 3, 5]),
+ *   Arr.bind("y", () => [2, 4, 6]),
+ *   Arr.filter(({ x, y }) => x < y), // condition
+ *   Arr.map(({ x, y }) => [x, y] as const) // transformation
+ * )
+ * assert.deepStrictEqual(doResult, [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]])
+ *
+ * // equivalent
+ * const x = [1, 3, 5],
+ *       y = [2, 4, 6],
+ *       result = [];
+ * for(let i = 0; i < x.length; i++) {
+ *   for(let j = 0; j < y.length; j++) {
+ *     const _x = x[i], _y = y[j];
+ *     if(_x < _y) result.push([_x, _y] as const)
+ *   }
+ * }
+ *
+ * @category do notation
+ * @since 3.2.0
+ */
+export const bindTo: {
+  <N extends string>(tag: N): <A>(self: ReadonlyArray<A>) => Array<{ [K in N]: A }>
+  <A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{ [K in N]: A }>
+} = doNotation.bindTo<ReadonlyArrayTypeLambda>(map) as any
+
+const let_: {
+  <N extends string, B, A extends object>(
+    tag: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): (self: ReadonlyArray<A>) => Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
+  <N extends string, A extends object, B>(
+    self: ReadonlyArray<A>,
+    tag: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
+} = doNotation.let_<ReadonlyArrayTypeLambda>(map) as any
+
+export {
+  /**
+   * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
+   *
+   * It can be used to simulate "array comprehension".
+   * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules.
+   *
+   * 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 `Array` 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
+   * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
+   *
+   * @see {@link bindTo}
+   * @see {@link bind}
+   * @see {@link Do}
+   *
+   * @example
+   * import { Array as Arr, pipe } from "effect"
+   * const doResult = pipe(
+   *   Arr.Do,
+   *   Arr.bind("x", () => [1, 3, 5]),
+   *   Arr.bind("y", () => [2, 4, 6]),
+   *   Arr.filter(({ x, y }) => x < y), // condition
+   *   Arr.map(({ x, y }) => [x, y] as const) // transformation
+   * )
+   * assert.deepStrictEqual(doResult, [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]])
+   *
+   * // equivalent
+   * const x = [1, 3, 5],
+   *       y = [2, 4, 6],
+   *       result = [];
+   * for(let i = 0; i < x.length; i++) {
+   *   for(let j = 0; j < y.length; j++) {
+   *     const _x = x[i], _y = y[j];
+   *     if(_x < _y) result.push([_x, _y] as const)
+   *   }
+   * }
+   *
+   * @category do notation
+   * @since 3.2.0
+   */
+  let_ as let
+}

package/src/Cause.ts

@@ -36,6 +36,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import type * as Sink from "./Sink.js"
 import type * as Stream from "./Stream.js"
+import type { Span } from "./Tracer.js"
 import type { Covariant, NoInfer } from "./Types.js"
 
 /**
@@ -914,6 +915,22 @@ export const isUnknownException: (u: unknown) => u is UnknownException = core.is
  */
 export const pretty: <E>(cause: Cause<E>) => string = internal.pretty
 
+/**
+ * @since 3.2.0
+ * @category models
+ */
+export interface PrettyError extends Error {
+  readonly span: Span | undefined
+}
+
+/**
+ * Returns the specified `Cause` as a pretty-printed string.
+ *
+ * @since 3.2.0
+ * @category rendering
+ */
+export const prettyErrors: <E>(cause: Cause<E>) => Array<PrettyError> = internal.prettyErrors
+
 /**
  * Returns the original, unproxied, instance of a thrown error
  *

package/src/Chunk.ts

@@ -1387,3 +1387,33 @@ export const reduceRight: {
   <B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B
   <A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B
 } = RA.reduceRight
+
+/**
+ * Creates a `Chunk` of values not included in the other given `Chunk` using the provided `isEquivalent` function.
+ * The order and references of result values are determined by the first `Chunk`.
+ *
+ * @since 3.2.0
+ */
+export const differenceWith = <A>(isEquivalent: (self: A, that: A) => boolean): {
+  (that: Chunk<A>): (self: Chunk<A>) => Chunk<A>
+  (self: Chunk<A>, that: Chunk<A>): Chunk<A>
+} => {
+  return dual(
+    2,
+    (self: Chunk<A>, that: Chunk<A>): Chunk<A> => unsafeFromArray(RA.differenceWith(isEquivalent)(that, self))
+  )
+}
+
+/**
+ * Creates a `Chunk` of values not included in the other given `Chunk`.
+ * The order and references of result values are determined by the first `Chunk`.
+ *
+ * @since 3.2.0
+ */
+export const difference: {
+  <A>(that: Chunk<A>): (self: Chunk<A>) => Chunk<A>
+  <A>(self: Chunk<A>, that: Chunk<A>): Chunk<A>
+} = dual(
+  2,
+  <A>(self: Chunk<A>, that: Chunk<A>): Chunk<A> => unsafeFromArray(RA.difference(that, self))
+)

package/src/Data.ts

@@ -7,6 +7,7 @@ import * as internal from "./internal/data.js"
 import { StructuralPrototype } from "./internal/effectable.js"
 import * as Predicate from "./Predicate.js"
 import type * as Types from "./Types.js"
+import type { Unify } from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -336,13 +337,63 @@ export declare namespace TaggedEnum {
     }
     & {
       readonly $is: <Tag extends A["_tag"]>(tag: Tag) => (u: unknown) => u is Extract<A, { readonly _tag: Tag }>
-      readonly $match: <
+      readonly $match: {
+        <
+          Cases extends {
+            readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
+          }
+        >(cases: Cases): (value: A) => Unify<ReturnType<Cases[A["_tag"]]>>
+        <
+          Cases extends {
+            readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
+          }
+        >(value: A, cases: Cases): Unify<ReturnType<Cases[A["_tag"]]>>
+      }
+    }
+  >
+
+  /**
+   * @since 3.2.0
+   */
+  export interface GenericMatchers<Z extends WithGenerics<number>> {
+    readonly $is: <Tag extends Z["taggedEnum"]["_tag"]>(
+      tag: Tag
+    ) => {
+      <T extends TaggedEnum.Kind<Z, any, any, any, any>>(
+        u: T
+      ): u is T & { readonly _tag: Tag }
+      (u: unknown): u is Extract<TaggedEnum.Kind<Z>, { readonly _tag: Tag }>
+    }
+    readonly $match: {
+      <
+        A,
+        B,
+        C,
+        D,
+        Cases extends {
+          readonly [Tag in Z["taggedEnum"]["_tag"]]: (
+            args: Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
+          ) => any
+        }
+      >(
+        cases: Cases
+      ): (self: TaggedEnum.Kind<Z, A, B, C, D>) => Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
+      <
+        A,
+        B,
+        C,
+        D,
         Cases extends {
-          readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
+          readonly [Tag in Z["taggedEnum"]["_tag"]]: (
+            args: Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
+          ) => any
         }
-      >(cases: Cases) => (value: A) => ReturnType<Cases[A["_tag"]]>
+      >(
+        self: TaggedEnum.Kind<Z, A, B, C, D>,
+        cases: Cases
+      ): Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
     }
-  >
+  }
 }
 
 /**
@@ -379,52 +430,60 @@ export declare namespace TaggedEnum {
  * @since 2.0.0
  */
 export const taggedEnum: {
-  <Z extends TaggedEnum.WithGenerics<1>>(): {
-    readonly [Tag in Z["taggedEnum"]["_tag"]]: <A>(
-      args: TaggedEnum.Args<
-        TaggedEnum.Kind<Z, A>,
-        Tag,
-        Extract<TaggedEnum.Kind<Z, A>, { readonly _tag: Tag }>
-      >
-    ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A>, Tag>
-  }
+  <Z extends TaggedEnum.WithGenerics<1>>(): Types.Simplify<
+    {
+      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A>(
+        args: TaggedEnum.Args<
+          TaggedEnum.Kind<Z, A>,
+          Tag,
+          Extract<TaggedEnum.Kind<Z, A>, { readonly _tag: Tag }>
+        >
+      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A>, Tag>
+    } & TaggedEnum.GenericMatchers<Z>
+  >
 
-  <Z extends TaggedEnum.WithGenerics<2>>(): {
-    readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B>(
-      args: TaggedEnum.Args<
-        TaggedEnum.Kind<Z, A, B>,
-        Tag,
-        Extract<TaggedEnum.Kind<Z, A, B>, { readonly _tag: Tag }>
-      >
-    ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B>, Tag>
-  }
+  <Z extends TaggedEnum.WithGenerics<2>>(): Types.Simplify<
+    {
+      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B>(
+        args: TaggedEnum.Args<
+          TaggedEnum.Kind<Z, A, B>,
+          Tag,
+          Extract<TaggedEnum.Kind<Z, A, B>, { readonly _tag: Tag }>
+        >
+      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B>, Tag>
+    } & TaggedEnum.GenericMatchers<Z>
+  >
 
-  <Z extends TaggedEnum.WithGenerics<3>>(): {
-    readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C>(
-      args: TaggedEnum.Args<
-        TaggedEnum.Kind<Z, A, B, C>,
-        Tag,
-        Extract<TaggedEnum.Kind<Z, A, B, C>, { readonly _tag: Tag }>
-      >
-    ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C>, Tag>
-  }
+  <Z extends TaggedEnum.WithGenerics<3>>(): Types.Simplify<
+    {
+      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C>(
+        args: TaggedEnum.Args<
+          TaggedEnum.Kind<Z, A, B, C>,
+          Tag,
+          Extract<TaggedEnum.Kind<Z, A, B, C>, { readonly _tag: Tag }>
+        >
+      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C>, Tag>
+    } & TaggedEnum.GenericMatchers<Z>
+  >
 
-  <Z extends TaggedEnum.WithGenerics<4>>(): {
-    readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C, D>(
-      args: TaggedEnum.Args<
-        TaggedEnum.Kind<Z, A, B, C, D>,
-        Tag,
-        Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
-      >
-    ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C, D>, Tag>
-  }
+  <Z extends TaggedEnum.WithGenerics<4>>(): Types.Simplify<
+    {
+      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C, D>(
+        args: TaggedEnum.Args<
+          TaggedEnum.Kind<Z, A, B, C, D>,
+          Tag,
+          Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
+        >
+      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C, D>, Tag>
+    } & TaggedEnum.GenericMatchers<Z>
+  >
 
   <A extends { readonly _tag: string }>(): TaggedEnum.Constructor<A>
 } = () =>
   new Proxy({}, {
     get(_target, tag, _receiver) {
       if (tag === "$is") {
-        return taggedIs
+        return Predicate.isTagged
       } else if (tag === "$match") {
         return taggedMatch
       }
@@ -432,19 +491,33 @@ export const taggedEnum: {
     }
   }) as any
 
-function taggedIs<A extends { readonly _tag: string }, Tag extends A["_tag"]>(tag: Tag) {
-  return Predicate.isTagged(tag)
-}
-
 function taggedMatch<
   A extends { readonly _tag: string },
   Cases extends {
     readonly [K in A["_tag"]]: (args: Extract<A, { readonly _tag: K }>) => any
   }
->(cases: Cases) {
-  return function(value: A): ReturnType<Cases[A["_tag"]]> {
-    return cases[value._tag as A["_tag"]](value as any)
+>(self: A, cases: Cases): ReturnType<Cases[A["_tag"]]>
+function taggedMatch<
+  A extends { readonly _tag: string },
+  Cases extends {
+    readonly [K in A["_tag"]]: (args: Extract<A, { readonly _tag: K }>) => any
+  }
+>(cases: Cases): (value: A) => ReturnType<Cases[A["_tag"]]>
+function taggedMatch<
+  A extends { readonly _tag: string },
+  Cases extends {
+    readonly [K in A["_tag"]]: (args: Extract<A, { readonly _tag: K }>) => any
+  }
+>(): any {
+  if (arguments.length === 1) {
+    const cases = arguments[0] as Cases
+    return function(value: A): ReturnType<Cases[A["_tag"]]> {
+      return cases[value._tag as A["_tag"]](value as any)
+    }
   }
+  const value = arguments[0] as A
+  const cases = arguments[1] as Cases
+  return cases[value._tag as A["_tag"]](value as any)
 }
 
 /**

package/src/Effect.ts

@@ -5435,6 +5435,46 @@ export const withSpan: {
   ): Effect<A, E, Exclude<R, Tracer.ParentSpan>>
 } = effect.withSpan
 
+/**
+ * Wraps a function that returns an effect with a new span for tracing.
+ *
+ * @since 3.2.0
+ * @category models
+ */
+export interface FunctionWithSpanOptions {
+  readonly name: string
+  readonly attributes?: Record<string, unknown> | undefined
+  readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+  readonly parent?: Tracer.AnySpan | undefined
+  readonly root?: boolean | undefined
+  readonly context?: Context.Context<never> | undefined
+  readonly kind?: Tracer.SpanKind | undefined
+}
+
+/**
+ * Wraps a function that returns an effect with a new span for tracing.
+ *
+ * @since 3.2.0
+ * @category tracing
+ * @example
+ * import { Effect } from "effect"
+ *
+ * const getTodo = Effect.functionWithSpan({
+ *   body: (id: number) => Effect.succeed(`Got todo ${id}!`),
+ *   options: (id) => ({
+ *     name: `getTodo-${id}`,
+ *     attributes: { id }
+ *   })
+ * })
+ */
+export const functionWithSpan: <Args extends Array<any>, Ret extends Effect<any, any, any>>(
+  options: {
+    readonly body: (...args: Args) => Ret
+    readonly options: FunctionWithSpanOptions | ((...args: Args) => FunctionWithSpanOptions)
+    readonly captureStackTrace?: boolean | undefined
+  }
+) => (...args: Args) => Unify.Unify<Ret> = effect.functionWithSpan
+
 /**
  * Wraps the effect with a new span for tracing.
  *

package/src/Stream.ts

@@ -22,6 +22,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import type * as PubSub from "./PubSub.js"
 import type * as Queue from "./Queue.js"
+import type { Runtime } from "./Runtime.js"
 import type * as Schedule from "./Schedule.js"
 import type * as Scope from "./Scope.js"
 import type * as Sink from "./Sink.js"
@@ -3859,7 +3860,36 @@ export const toQueueOfElements: {
  * @since 2.0.0
  * @category destructors
  */
-export const toReadableStream: <A, E>(source: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
+export const toReadableStream: <A, E>(self: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
+
+/**
+ * Converts the stream to a `Effect<ReadableStream>`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadableStreamEffect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<ReadableStream<A>, never, R> =
+  internal.toReadableStreamEffect
+
+/**
+ * Converts the stream to a `ReadableStream` using the provided runtime.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadableStreamRuntime: {
+  <XR>(
+    runtime: Runtime<XR>
+  ): <A, E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>
+  <A, E, XR, R extends XR>(
+    self: Stream<A, E, R>,
+    runtime: Runtime<XR>
+  ): ReadableStream<A>
+} = internal.toReadableStreamRuntime
 
 /**
  * Applies the transducer to the stream and emits its outputs.