effect 4.0.0-beta.3 → 4.0.0-beta.30

package/src/Struct.ts

@@ -1513,3 +1513,29 @@ export function makeReducer<A>(
   }
   return Reducer.make(combine, initialValue)
 }
+
+/**
+ * Creates a record with the given keys and value.
+ *
+ * **Example** (Creating a record)
+ *
+ * ```ts
+ * import { Struct } from "effect"
+ *
+ * const record = Struct.Record(["a", "b"], "value")
+ * console.log(record) // { a: "value", b: "value" }
+ * ```
+ *
+ * @category Constructors
+ * @since 4.0.0
+ */
+export function Record<const Keys extends ReadonlyArray<string | symbol>, Value>(
+  keys: Keys,
+  value: Value
+): Record<Keys[number], Value> {
+  const out: any = {}
+  for (const key of keys) {
+    out[key] = value
+  }
+  return out
+}

package/src/SubscriptionRef.ts

@@ -8,6 +8,7 @@ import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as PubSub from "./PubSub.ts"
 import * as Ref from "./Ref.ts"
+import * as Semaphore from "./Semaphore.ts"
 import * as Stream from "./Stream.ts"
 import type { Invariant } from "./Types.ts"
 
@@ -19,7 +20,7 @@ const TypeId = "~effect/SubscriptionRef"
  */
 export interface SubscriptionRef<in out A> extends SubscriptionRef.Variance<A>, Pipeable {
   readonly backing: Ref.Ref<A>
-  readonly semaphore: Effect.Semaphore
+  readonly semaphore: Semaphore.Semaphore
   readonly pubsub: PubSub.PubSub<A>
 }
 
@@ -70,7 +71,7 @@ const Proto = {
 export const make = <A>(value: A): Effect.Effect<SubscriptionRef<A>> =>
   Effect.map(PubSub.unbounded<A>({ replay: 1 }), (pubsub) => {
     const self = Object.create(Proto)
-    self.semaphore = Effect.makeSemaphoreUnsafe(1)
+    self.semaphore = Semaphore.makeUnsafe(1)
     self.backing = Ref.makeUnsafe(value)
     self.pubsub = pubsub
     PubSub.publishUnsafe(self.pubsub, value)

package/src/SynchronizedRef.ts

@@ -6,6 +6,7 @@ import { dual } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
 import * as Ref from "./Ref.ts"
+import * as Semaphore from "./Semaphore.ts"
 
 const TypeId = "~effect/SynchronizedRef"
 
@@ -16,7 +17,7 @@ const TypeId = "~effect/SynchronizedRef"
 export interface SynchronizedRef<in out A> extends Ref.Ref<A> {
   readonly [TypeId]: typeof TypeId
   readonly backing: Ref.Ref<A>
-  readonly semaphore: Effect.Semaphore
+  readonly semaphore: Semaphore.Semaphore
 }
 
 const Proto = {
@@ -36,7 +37,7 @@ const Proto = {
  */
 export const makeUnsafe = <A>(value: A): SynchronizedRef<A> => {
   const self = Object.create(Proto)
-  self.semaphore = Effect.makeSemaphoreUnsafe(1)
+  self.semaphore = Semaphore.makeUnsafe(1)
   self.backing = Ref.makeUnsafe(value)
   return self
 }

package/src/Trie.ts

@@ -20,6 +20,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import * as TR from "./internal/trie.ts"
 import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import type { Result } from "./Result.ts"
 import type { Covariant, NoInfer } from "./Types.ts"
 
 const TypeId = TR.TrieTypeId
@@ -1488,13 +1489,13 @@ export const filter: {
 } = TR.filter
 
 /**
- * Maps over the entries of the `Trie` using the specified partial function
- * and filters out `None` values.
+ * Maps over the entries of the `Trie` using the specified filter and keeps
+ * only successful results.
  *
  * @example
  * ```ts
  * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  * import * as Trie from "effect/Trie"
  * import * as assert from "node:assert"
  *
@@ -1515,7 +1516,7 @@ export const filter: {
  *
  * assert.equal(
  *   Equal.equals(
- *     Trie.filterMap(trie, (v) => v > 1 ? Option.some(v) : Option.none()),
+ *     Trie.filterMap(trie, (v) => v > 1 ? Result.succeed(v) : Result.failVoid),
  *     trieMapV
  *   ),
  *   true
@@ -1524,7 +1525,7 @@ export const filter: {
  *   Equal.equals(
  *     Trie.filterMap(
  *       trie,
- *       (v, k) => k.length > 3 ? Option.some(v) : Option.none()
+ *       (v, k) => k.length > 3 ? Result.succeed(v) : Result.failVoid
  *     ),
  *     trieMapK
  *   ),
@@ -1537,13 +1538,13 @@ export const filter: {
  */
 export const filterMap: {
   /**
-   * Maps over the entries of the `Trie` using the specified partial function
-   * and filters out `None` values.
+   * Maps over the entries of the `Trie` using the specified filter and keeps
+   * only successful results.
    *
    * @example
    * ```ts
    * import * as Equal from "effect/Equal"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    * import * as Trie from "effect/Trie"
    * import * as assert from "node:assert"
    *
@@ -1564,7 +1565,7 @@ export const filterMap: {
    *
    * assert.equal(
    *   Equal.equals(
-   *     Trie.filterMap(trie, (v) => v > 1 ? Option.some(v) : Option.none()),
+   *     Trie.filterMap(trie, (v) => v > 1 ? Result.succeed(v) : Result.failVoid),
    *     trieMapV
    *   ),
    *   true
@@ -1573,7 +1574,7 @@ export const filterMap: {
    *   Equal.equals(
    *     Trie.filterMap(
    *       trie,
-   *       (v, k) => k.length > 3 ? Option.some(v) : Option.none()
+   *       (v, k) => k.length > 3 ? Result.succeed(v) : Result.failVoid
    *     ),
    *     trieMapK
    *   ),
@@ -1584,15 +1585,15 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B>(f: (value: A, key: string) => Option<B>): (self: Trie<A>) => Trie<B>
+  <A, B, X>(f: (input: A, key: string) => Result<B, X>): (self: Trie<A>) => Trie<B>
   /**
-   * Maps over the entries of the `Trie` using the specified partial function
-   * and filters out `None` values.
+   * Maps over the entries of the `Trie` using the specified filter and keeps
+   * only successful results.
    *
    * @example
    * ```ts
    * import * as Equal from "effect/Equal"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    * import * as Trie from "effect/Trie"
    * import * as assert from "node:assert"
    *
@@ -1613,7 +1614,7 @@ export const filterMap: {
    *
    * assert.equal(
    *   Equal.equals(
-   *     Trie.filterMap(trie, (v) => v > 1 ? Option.some(v) : Option.none()),
+   *     Trie.filterMap(trie, (v) => v > 1 ? Result.succeed(v) : Result.failVoid),
    *     trieMapV
    *   ),
    *   true
@@ -1622,7 +1623,7 @@ export const filterMap: {
    *   Equal.equals(
    *     Trie.filterMap(
    *       trie,
-   *       (v, k) => k.length > 3 ? Option.some(v) : Option.none()
+   *       (v, k) => k.length > 3 ? Result.succeed(v) : Result.failVoid
    *     ),
    *     trieMapK
    *   ),
@@ -1633,7 +1634,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B>(self: Trie<A>, f: (value: A, key: string) => Option<B>): Trie<B>
+  <A, B, X>(self: Trie<A>, f: (input: A, key: string) => Result<B, X>): Trie<B>
 } = TR.filterMap
 
 /**

package/src/TxChunk.ts

@@ -48,7 +48,7 @@ const TypeId = "~effect/transactions/TxChunk"
  *   console.log(Chunk.toReadonlyArray(result)) // [1, 2, 3, 4]
  *
  *   // Multi-step atomic operation - use explicit transaction
- *   yield* Effect.atomic(
+ *   yield* Effect.transaction(
  *     Effect.gen(function*() {
  *       yield* TxChunk.prepend(txChunk, 0)
  *       yield* TxChunk.append(txChunk, 5)
@@ -109,7 +109,7 @@ const TxChunkProto = {
  * })
  * ```
  */
-export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>> =>
+export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
   Effect.map(TxRef.make(initial), (ref) => makeUnsafe(ref))
 
 /**
@@ -140,7 +140,7 @@ export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>> =>
  * })
  * ```
  */
-export const empty = <A = never>(): Effect.Effect<TxChunk<A>> =>
+export const empty = <A = never>(): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
   Effect.map(TxRef.make(Chunk.empty<A>()), (ref) => makeUnsafe(ref))
 
 /**
@@ -164,7 +164,7 @@ export const empty = <A = never>(): Effect.Effect<TxChunk<A>> =>
  *   console.log(Chunk.toReadonlyArray(chunk)) // [1, 2, 3, 4, 5]
  *
  *   // Multi-step atomic modification - use explicit transaction
- *   yield* Effect.atomic(
+ *   yield* Effect.transaction(
  *     Effect.gen(function*() {
  *       yield* TxChunk.append(txChunk, 6)
  *       yield* TxChunk.prepend(txChunk, 0)
@@ -176,7 +176,7 @@ export const empty = <A = never>(): Effect.Effect<TxChunk<A>> =>
  * })
  * ```
  */
-export const fromIterable = <A>(iterable: Iterable<A>): Effect.Effect<TxChunk<A>> =>
+export const fromIterable = <A>(iterable: Iterable<A>): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
   Effect.map(TxRef.make(Chunk.fromIterable(iterable)), (ref) => makeUnsafe(ref))
 
 /**
@@ -265,7 +265,7 @@ export const modify: {
     f: (current: Chunk.Chunk<NoInfer<A>>) => [returnValue: R, newValue: Chunk.Chunk<A>]
   ): (
     self: TxChunk<A>
-  ) => Effect.Effect<R>
+  ) => Effect.Effect<R, never, Effect.Transaction>
   /**
    * Modifies the value of the `TxChunk` using the provided function.
    *
@@ -297,13 +297,13 @@ export const modify: {
   <A, R>(
     self: TxChunk<A>,
     f: (current: Chunk.Chunk<A>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): Effect.Effect<R>
+  ): Effect.Effect<R, never, Effect.Transaction>
 } = dual(
   2,
   <A, R>(
     self: TxChunk<A>,
     f: (current: Chunk.Chunk<A>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): Effect.Effect<R> => TxRef.modify(self.ref, f)
+  ): Effect.Effect<R, never, Effect.Transaction> => TxRef.modify(self.ref, f)
 )
 
 /**
@@ -357,7 +357,7 @@ export const update: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(f: (current: Chunk.Chunk<NoInfer<A>>) => Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(f: (current: Chunk.Chunk<NoInfer<A>>) => Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Updates the value of the `TxChunk` using the provided function.
    *
@@ -383,11 +383,13 @@ export const update: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>): Effect.Effect<void>
+  <A>(self: TxChunk<A>, f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>): Effect.Effect<void> =>
-    TxRef.update(self.ref, f)
+  <A>(
+    self: TxChunk<A>,
+    f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>
+  ): Effect.Effect<void, never, Effect.Transaction> => TxRef.update(self.ref, f)
 )
 
 /**
@@ -413,7 +415,8 @@ export const update: {
  * @since 4.0.0
  * @category combinators
  */
-export const get = <A>(self: TxChunk<A>): Effect.Effect<Chunk.Chunk<A>> => TxRef.get(self.ref)
+export const get = <A>(self: TxChunk<A>): Effect.Effect<Chunk.Chunk<A>, never, Effect.Transaction> =>
+  TxRef.get(self.ref)
 
 /**
  * Sets the value of the `TxChunk`.
@@ -466,7 +469,7 @@ export const set: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(chunk: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(chunk: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Sets the value of the `TxChunk`.
    *
@@ -492,8 +495,12 @@ export const set: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void>
-} = dual(2, <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void> => TxRef.set(self.ref, chunk))
+  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+} = dual(
+  2,
+  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
+    TxRef.set(self.ref, chunk)
+)
 
 /**
  * Appends an element to the end of the `TxChunk`.
@@ -544,7 +551,7 @@ export const append: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Appends an element to the end of the `TxChunk`.
    *
@@ -569,10 +576,11 @@ export const append: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void>
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void> => update(self, (current) => Chunk.append(current, element))
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction> =>
+    update(self, (current) => Chunk.append(current, element))
 )
 
 /**
@@ -624,7 +632,7 @@ export const prepend: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Prepends an element to the beginning of the `TxChunk`.
    *
@@ -649,10 +657,11 @@ export const prepend: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void>
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void> => update(self, (current) => Chunk.prepend(current, element))
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction> =>
+    update(self, (current) => Chunk.prepend(current, element))
 )
 
 /**
@@ -679,7 +688,7 @@ export const prepend: {
  * @since 4.0.0
  * @category combinators
  */
-export const size = <A>(self: TxChunk<A>): Effect.Effect<number> =>
+export const size = <A>(self: TxChunk<A>): Effect.Effect<number, never, Effect.Transaction> =>
   modify(self, (current) => [Chunk.size(current), current])
 
 /**
@@ -705,7 +714,7 @@ export const size = <A>(self: TxChunk<A>): Effect.Effect<number> =>
  * @since 4.0.0
  * @category combinators
  */
-export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean> =>
+export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
   modify(self, (current) => [Chunk.isEmpty(current), current])
 
 /**
@@ -731,7 +740,7 @@ export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean> =>
  * @since 4.0.0
  * @category combinators
  */
-export const isNonEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean> =>
+export const isNonEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
   modify(self, (current) => [Chunk.isNonEmpty(current), current])
 
 /**
@@ -783,7 +792,7 @@ export const take: {
    * @since 4.0.0
    * @category combinators
    */
-  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
+  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Takes the first `n` elements from the `TxChunk`.
    *
@@ -808,8 +817,12 @@ export const take: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void>
-} = dual(2, <A>(self: TxChunk<A>, n: number): Effect.Effect<void> => update(self, (current) => Chunk.take(current, n)))
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction>
+} = dual(
+  2,
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction> =>
+    update(self, (current) => Chunk.take(current, n))
+)
 
 /**
  * Drops the first `n` elements from the `TxChunk`.
@@ -860,7 +873,7 @@ export const drop: {
    * @since 4.0.0
    * @category combinators
    */
-  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
+  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Drops the first `n` elements from the `TxChunk`.
    *
@@ -885,8 +898,12 @@ export const drop: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void>
-} = dual(2, <A>(self: TxChunk<A>, n: number): Effect.Effect<void> => update(self, (current) => Chunk.drop(current, n)))
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction>
+} = dual(
+  2,
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction> =>
+    update(self, (current) => Chunk.drop(current, n))
+)
 
 /**
  * Takes a slice of the `TxChunk` from `start` to `end` (exclusive).
@@ -937,7 +954,7 @@ export const slice: {
    * @since 4.0.0
    * @category combinators
    */
-  (start: number, end: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
+  (start: number, end: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Takes a slice of the `TxChunk` from `start` to `end` (exclusive).
    *
@@ -962,10 +979,10 @@ export const slice: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void>
+  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   3,
-  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void> =>
+  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void, never, Effect.Transaction> =>
     update(self, (current) => Chunk.take(Chunk.drop(current, start), end - start))
 )
 
@@ -1022,7 +1039,7 @@ export const map: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(f: (a: NoInfer<A>) => A): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(f: (a: NoInfer<A>) => A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Maps each element of the `TxChunk` using the provided function.
    * Note: This only works when the mapped type B is assignable to A.
@@ -1049,10 +1066,11 @@ export const map: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void>
+  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void> => update(self, (current) => Chunk.map(current, f))
+  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void, never, Effect.Transaction> =>
+    update(self, (current) => Chunk.map(current, f))
 )
 
 /**
@@ -1106,7 +1124,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, B extends A>(refinement: (a: A) => a is B): (self: TxChunk<A>) => Effect.Effect<void>
+  <A, B extends A>(refinement: (a: A) => a is B): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1132,7 +1150,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(predicate: (a: A) => boolean): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(predicate: (a: A) => boolean): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1158,7 +1176,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, B extends A>(self: TxChunk<A>, refinement: (a: A) => a is B): Effect.Effect<void>
+  <A, B extends A>(self: TxChunk<A>, refinement: (a: A) => a is B): Effect.Effect<void, never, Effect.Transaction>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1184,10 +1202,10 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void>
+  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void> =>
+  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void, never, Effect.Transaction> =>
     update(self, (current) => Chunk.filter(current, predicate))
 )
 
@@ -1244,7 +1262,7 @@ export const appendAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Concatenates another chunk to the end of the `TxChunk`.
    *
@@ -1271,10 +1289,10 @@ export const appendAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void> =>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
     update(self, (current) => Chunk.appendAll(current, other))
 )
 
@@ -1331,7 +1349,7 @@ export const prependAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Concatenates another chunk to the beginning of the `TxChunk`.
    *
@@ -1358,10 +1376,10 @@ export const prependAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void> =>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
     update(self, (current) => Chunk.prependAll(current, other))
 )
 
@@ -1422,7 +1440,7 @@ export const concat: {
    * })
    * ```
    */
-  <A>(other: TxChunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
+  <A>(other: TxChunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Concatenates another `TxChunk` to the end of this `TxChunk`.
    *
@@ -1451,11 +1469,12 @@ export const concat: {
    * })
    * ```
    */
-  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void>
-} = dual(2, <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void> =>
-  Effect.atomic(
+  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void, never, Effect.Transaction>
+} = dual(
+  2,
+  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
     Effect.gen(function*() {
       const otherChunk = yield* get(other)
       yield* appendAll(self, otherChunk)
     })
-  ))
+)