effect 3.1.1 → 3.1.2

package/src/Trie.ts

@@ -44,8 +44,7 @@ export interface Trie<in out Value> extends Iterable<[string, Value]>, Equal, Pi
  * Creates an empty `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<string>()
  *
@@ -61,8 +60,7 @@ export const empty: <V = never>() => Trie<V> = TR.empty
  * Creates a new `Trie` from an iterable collection of key/value pairs (e.g. `Array<[string, V]>`).
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const iterable: Array<readonly [string, number]> = [["call", 0], ["me", 1], ["mind", 2], ["mid", 3]]
  * const trie = Trie.fromIterable(iterable)
@@ -80,8 +78,7 @@ export const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Trie<
  * Constructs a new `Trie` from the specified entries (`[string, V]`).
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.make(["ca", 0], ["me", 1])
  *
@@ -99,7 +96,7 @@ export const make: <Entries extends Array<readonly [string, any]>>(
  * Insert a new entry in the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie1 = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0)
@@ -127,7 +124,7 @@ export const insert: {
  * The keys are returned in alphabetical order, regardless of insertion order.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("cab", 0),
@@ -149,7 +146,7 @@ export const keys: <V>(self: Trie<V>) => IterableIterator<string> = TR.keys
  * Values are ordered based on their key in alphabetical order, regardless of insertion order.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -171,7 +168,7 @@ export const values: <V>(self: Trie<V>) => IterableIterator<V> = TR.values
  * The entries are returned by keys in alphabetical order, regardless of insertion order.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -192,7 +189,7 @@ export const entries: <V>(self: Trie<V>) => IterableIterator<[string, V]> = TR.e
  * Equivalent to `Array.from(Trie.entries(trie))`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -212,7 +209,7 @@ export const toEntries = <V>(self: Trie<V>): Array<[string, V]> => Array.from(en
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("she", 0),
@@ -237,7 +234,7 @@ export const keysWithPrefix: {
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("she", 0),
@@ -264,7 +261,7 @@ export const valuesWithPrefix: {
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("she", 0),
@@ -289,7 +286,7 @@ export const entriesWithPrefix: {
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -314,8 +311,7 @@ export const toEntriesWithPrefix: {
  * that is a prefix of that `key` if it exists, `None` otherwise.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Option from "effect/Option"
+ * import { Trie, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -340,7 +336,7 @@ export const longestPrefixOf: {
  * Returns the size of the `Trie` (number of entries in the `Trie`).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("a", 0),
@@ -358,8 +354,7 @@ export const size: <V>(self: Trie<V>) => number = TR.size
  * Safely lookup the value for the specified key in the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Option from "effect/Option"
+ * import { Trie, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -389,7 +384,7 @@ export const get: {
  * Check if the given key exists in the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -419,7 +414,7 @@ export const has: {
  * Checks if the `Trie` contains any entries.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>()
  * const trie1 = trie.pipe(Trie.insert("ma", 0))
@@ -439,7 +434,7 @@ export const isEmpty: <V>(self: Trie<V>) => boolean = TR.isEmpty
  * get a value from the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -460,8 +455,7 @@ export const unsafeGet: {
  * Remove the entry for the specified key in the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Option from "effect/Option"
+ * import { Trie, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -489,7 +483,7 @@ export const remove: {
  * Reduce a state over the entries of the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -528,8 +522,7 @@ export const reduce: {
  * Maps over the entries of the `Trie` using the specified function.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -564,8 +557,7 @@ export const map: {
  * Filters entries out of a `Trie` using the specified predicate.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -600,9 +592,7 @@ export const filter: {
  * and filters out `None` values.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
+ * import { Trie, Equal, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -637,9 +627,7 @@ export const filterMap: {
  * Filters out `None` values from a `Trie` of `Options`s.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
+ * import { Trie, Equal, Option } from "effect"
  *
  * const trie = Trie.empty<Option.Option<number>>().pipe(
  *   Trie.insert("shells", Option.some(0)),
@@ -663,7 +651,7 @@ export const compact: <A>(self: Trie<Option<A>>) => Trie<A> = TR.compact
  * Applies the specified function to the entries of the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * let value = 0
  *
@@ -690,9 +678,7 @@ export const forEach: {
  * Updates the value of the specified key within the `Trie` if it exists.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
+ * import { Trie, Equal, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -716,8 +702,7 @@ export const modify: {
  * Removes all entries in the `Trie` which have the specified keys.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -742,8 +727,7 @@ export const removeMany: {
  * Insert multiple entries in the `Trie` at once.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),

package/src/Types.ts

@@ -7,7 +7,7 @@
 /**
  * Returns the tags in a type.
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res = Types.Tags<string | { _tag: "a" } | { _tag: "b" } > // "a" | "b"
  *
@@ -19,7 +19,7 @@ export type Tags<E> = E extends { _tag: string } ? E["_tag"] : never
 /**
  * Excludes the tagged object from the type.
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res = Types.ExcludeTag<string | { _tag: "a" } | { _tag: "b" }, "a"> // string | { _tag: "b" }
  *
@@ -32,7 +32,7 @@ export type ExcludeTag<E, K extends Tags<E>> = Exclude<E, { _tag: K }>
  * Extracts the type of the given tag.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res = Types.ExtractTag<{ _tag: "a", a: number } | { _tag: "b", b: number }, "b"> // { _tag: "b", b: number }
  *
@@ -54,7 +54,7 @@ export type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) ext
  * Simplifies the type signature of a type.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res = Types.Simplify<{ a: number } & { b: number }> // { a: number; b: number; }
  *
@@ -69,7 +69,7 @@ export type Simplify<A> = {
  * Determines if two types are equal.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res1 = Types.Equals<{ a: number }, { a: number }> // true
  * type Res2 = Types.Equals<{ a: number }, { b: number }> // false
@@ -86,7 +86,7 @@ export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
  * Determines if a record contains any of the given keys.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res1 = Types.Has<{ a: number }, "a" | "b"> // true
  * type Res2 = Types.Has<{ c: number }, "a" | "b"> // false
@@ -102,7 +102,7 @@ export type Has<A, Key extends string> = (Key extends infer K ? K extends keyof
  * Merges two object where the keys of the left object take precedence in the case of a conflict.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  * type MergeLeft = Types.MergeLeft<{ a: number, b: number; }, { a: string }> // { a: number; b: number; }
  *
  * @since 2.0.0
@@ -118,7 +118,7 @@ export type MergeLeft<K, H> = Simplify<
  * Merges two object where the keys of the right object take precedence in the case of a conflict.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  * type MergeRight = Types.MergeRight<{ a: number, b: number; }, { a: string }> // { a: string; b: number; }
  *
  * @since 2.0.0
@@ -153,7 +153,7 @@ export type Concurrency = number | "unbounded" | "inherit"
  * Make all properties in `T` mutable. Supports arrays, tuples, and records as well.
  *
  * @example
- * import type * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type MutableStruct = Types.Mutable<{ readonly a: string; readonly b: number }> // { a: string; b: number; }
  *
@@ -174,7 +174,7 @@ export type Mutable<T> = {
  * Like `Types.Mutable`, but works recursively.
  *
  * @example
- * import type * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type DeepMutableStruct = Types.DeepMutable<{
  *   readonly a: string;

package/src/Utils.ts

@@ -25,7 +25,7 @@ import type * as Types from "./Types.js"
  * @category symbols
  * @since 2.0.0
  */
-export const GenKindTypeId = Symbol.for("effect/Gen/GenKind")
+export const GenKindTypeId: unique symbol = Symbol.for("effect/Gen/GenKind")
 
 /**
  * @category symbols
@@ -717,7 +717,7 @@ function add64(
 /**
  * @since 3.0.6
  */
-export const YieldWrapTypeId = Symbol.for("effect/Utils/YieldWrap")
+export const YieldWrapTypeId: unique symbol = Symbol.for("effect/Utils/YieldWrap")
 
 /**
  * @since 3.0.6

package/src/internal/core-effect.ts

@@ -25,12 +25,13 @@ import type * as Random from "../Random.js"
 import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
-import type { MergeRecord, NoInfer } from "../Types.js"
+import type { NoInfer } from "../Types.js"
 import { yieldWrapGet } from "../Utils.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
+import * as doNotation from "./doNotation.js"
 import * as fiberRefsPatch from "./fiberRefs/patch.js"
 import type { FiberRuntime } from "./fiberRuntime.js"
 import * as metricLabel from "./metric/label.js"
@@ -369,56 +370,39 @@ export const Do: Effect.Effect<{}> = core.succeed({})
 
 /* @internal */
 export const bind: {
-  <N extends string, K, A, E2, R2>(
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<A, E2, R2>
-  ): <E, R>(self: Effect.Effect<K, E, R>) => Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
-  <K, E, R, N extends string, A, E2, R2>(
-    self: Effect.Effect<K, E, R>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<A, E2, R2>
-  ): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
-} = dual(3, <K, E, R, N extends string, A, E2, R2>(
-  self: Effect.Effect<K, E, R>,
-  tag: Exclude<N, keyof K>,
-  f: (_: K) => Effect.Effect<A, E2, R2>
-): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R> =>
-  core.flatMap(self, (k) =>
-    core.map(
-      f(k),
-      (a): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
-    )))
+  <N extends string, A extends object, B, E2, R2>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ): <E1, R1>(
+    self: Effect.Effect<A, E1, R1>
+  ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E1, R2 | R1>
+  <A extends object, N extends string, E1, R1, B, E2, R2>(
+    self: Effect.Effect<A, E1, R1>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E1 | E2, R1 | R2>
+} = doNotation.bind<Effect.EffectTypeLambda>(core.map, core.flatMap)
 
 /* @internal */
 export const bindTo: {
-  <N extends string>(tag: N): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Record<N, A>, E, R>
-  <A, E, R, N extends string>(self: Effect.Effect<A, E, R>, tag: N): Effect.Effect<Record<N, A>, E, R>
-} = dual(
-  2,
-  <A, E, R, N extends string>(self: Effect.Effect<A, E, R>, tag: N): Effect.Effect<Record<N, A>, E, R> =>
-    core.map(self, (a) => ({ [tag]: a } as Record<N, A>))
-)
+  <N extends string>(name: N): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<{ [K in N]: A }, E, R>
+  <A, E, R, N extends string>(self: Effect.Effect<A, E, R>, name: N): Effect.Effect<{ [K in N]: A }, E, R>
+} = doNotation.bindTo<Effect.EffectTypeLambda>(core.map)
 
 /* @internal */
 export const let_: {
-  <N extends string, K, A>(
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => A
-  ): <E, R>(self: Effect.Effect<K, E, R>) => Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R>
-  <K, E, R, N extends string, A>(
-    self: Effect.Effect<K, E, R>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => A
-  ): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R>
-} = dual(3, <K, E, R, N extends string, A>(
-  self: Effect.Effect<K, E, R>,
-  tag: Exclude<N, keyof K>,
-  f: (_: K) => A
-): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R> =>
-  core.map(
-    self,
-    (k): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: f(k) } as any)
-  ))
+  <N extends string, A extends object, B>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): <E, R>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
+  <A extends object, N extends string, E, R, B>(
+    self: Effect.Effect<A, E, R>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
+} = doNotation.let_<Effect.EffectTypeLambda>(core.map)
 
 /* @internal */
 export const dropUntil: {

package/src/internal/doNotation.ts

@@ -0,0 +1,77 @@
+import { dual } from "../Function.js"
+import type { Kind, TypeLambda } from "../HKT.js"
+
+type Map<F extends TypeLambda> = {
+  <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>
+  <R, O, E, A, B>(self: Kind<F, R, O, E, A>, f: (a: A) => B): Kind<F, R, O, E, B>
+}
+
+type FlatMap<F extends TypeLambda> = {
+  <A, R2, O2, E2, B>(
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O1 | O2, E1 | E2, B>
+  <R1, O1, E1, A, R2, O2, E2, B>(
+    self: Kind<F, R1, O1, E1, A>,
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): Kind<F, R1 & R2, O1 | O2, E1 | E2, B>
+}
+
+/** @internal */
+export const let_ = <F extends TypeLambda>(
+  map: Map<F>
+): {
+  <N extends string, A extends object, B>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): <R, O, E>(
+    self: Kind<F, R, O, E, A>
+  ) => Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+  <R, O, E, A extends object, N extends string, B>(
+    self: Kind<F, R, O, E, A>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+} =>
+  dual(3, <R, O, E, A extends object, N extends string, B>(
+    self: Kind<F, R, O, E, A>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }> =>
+    map(self, (a) => Object.assign({}, a, { [name]: f(a) }) as any))
+
+/** @internal */
+export const bindTo = <F extends TypeLambda>(map: Map<F>): {
+  <N extends string>(
+    name: N
+  ): <R, O, E, A>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, { [K in N]: A }>
+  <R, O, E, A, N extends string>(
+    self: Kind<F, R, O, E, A>,
+    name: N
+  ): Kind<F, R, O, E, { [K in N]: A }>
+} =>
+  dual(2, <R, O, E, A, N extends string>(
+    self: Kind<F, R, O, E, A>,
+    name: N
+  ): Kind<F, R, O, E, { [K in N]: A }> => map(self, (a) => ({ [name]: a } as { [K in N]: A })))
+
+/** @internal */
+export const bind = <F extends TypeLambda>(map: Map<F>, flatMap: FlatMap<F>): {
+  <N extends string, A extends object, R2, O2, E2, B>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): <R1, O1, E1>(
+    self: Kind<F, R1, O1, E1, A>
+  ) => Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+  <R1, O1, E1, A extends object, N extends string, R2, O2, E2, B>(
+    self: Kind<F, R1, O1, E1, A>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+} =>
+  dual(3, <R1, O1, E1, A, N extends string, R2, O2, E2, B>(
+    self: Kind<F, R1, O1, E1, A>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }> =>
+    flatMap(self, (a) =>
+      map(f(a), (b) => Object.assign({}, a, { [name]: b }) as { [K in keyof A | N]: K extends keyof A ? A[K] : B })))

package/src/internal/groupBy.ts

@@ -13,7 +13,7 @@ import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
 import type * as Stream from "../Stream.js"
 import type * as Take from "../Take.js"
-import type { MergeRecord, NoInfer } from "../Types.js"
+import type { NoInfer } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as core from "./core-stream.js"
@@ -274,35 +274,35 @@ export const mapEffectOptions = dual<
 
 /** @internal */
 export const bindEffect = dual<
-  <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
     }
-  ) => <E, R>(self: Stream.Stream<K, E, R>) => Stream.Stream<
-    MergeRecord<K, { [k in N]: A }>,
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<
+    { [K in keyof A | N]: K extends keyof A ? A[K] : B },
     E | E2,
     R | R2
   >,
-  <K, E, R, N extends string, A, E2, R2>(
-    self: Stream.Stream<K, E, R>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<A, E2, R2>,
+  <A, E, R, N extends string, B, E2, R2>(
+    self: Stream.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
     }
   ) => Stream.Stream<
-    MergeRecord<K, { [k in N]: A }>,
+    { [K in keyof A | N]: K extends keyof A ? A[K] : B },
     E | E2,
     R | R2
   >
->((args) => typeof args[0] !== "string", <K, E, R, N extends string, A, E2, R2>(
-  self: Stream.Stream<K, E, R>,
-  tag: Exclude<N, keyof K>,
-  f: (_: K) => Effect.Effect<A, E2, R2>,
+>((args) => typeof args[0] !== "string", <A, E, R, N extends string, B, E2, R2>(
+  self: Stream.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
@@ -311,7 +311,7 @@ export const bindEffect = dual<
   mapEffectOptions(self, (k) =>
     Effect.map(
       f(k),
-      (a): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
+      (a) => ({ ...k, [tag]: a } as { [K in keyof A | N]: K extends keyof A ? A[K] : B })
     ), options))
 
 const mapDequeue = <A, B>(dequeue: Queue.Dequeue<A>, f: (a: A) => B): Queue.Dequeue<B> => new MapDequeue(dequeue, f)