effect 4.0.0-beta.4 → 4.0.0-beta.41

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
@@ -646,10 +647,14 @@ export const toEntriesWithPrefix: {
  *   Trie.insert("she", 2)
  * )
  *
- * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sell"), undefined)
- * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sells"), ["sells", 1])
- * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shell"), ["she", 2])
- * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shellsort"), ["shells", 0])
+ * const none = Trie.longestPrefixOf(trie, "sell")
+ * const some = Trie.longestPrefixOf(trie, "sells")
+ *
+ * assert.equal(none._tag, "None")
+ * assert.equal(some._tag, "Some")
+ * if (some._tag === "Some") {
+ *   assert.deepStrictEqual(some.value, ["sells", 1])
+ * }
  * ```
  *
  * @since 2.0.0
@@ -671,16 +676,20 @@ export const longestPrefixOf: {
    *   Trie.insert("she", 2)
    * )
    *
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sell"), undefined)
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sells"), ["sells", 1])
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shell"), ["she", 2])
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shellsort"), ["shells", 0])
+   * const none = Trie.longestPrefixOf(trie, "sell")
+   * const some = Trie.longestPrefixOf(trie, "sells")
+   *
+   * assert.equal(none._tag, "None")
+   * assert.equal(some._tag, "Some")
+   * if (some._tag === "Some") {
+   *   assert.deepStrictEqual(some.value, ["sells", 1])
+   * }
    * ```
    *
    * @since 2.0.0
    * @category getters
    */
-  (key: string): <V>(self: Trie<V>) => [string, V] | undefined
+  (key: string): <V>(self: Trie<V>) => Option<[string, V]>
   /**
    * Returns the longest key/value in the `Trie`
    * that is a prefix of that `key` if it exists, `None` otherwise.
@@ -696,16 +705,20 @@ export const longestPrefixOf: {
    *   Trie.insert("she", 2)
    * )
    *
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sell"), undefined)
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sells"), ["sells", 1])
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shell"), ["she", 2])
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shellsort"), ["shells", 0])
+   * const none = Trie.longestPrefixOf(trie, "sell")
+   * const some = Trie.longestPrefixOf(trie, "sells")
+   *
+   * assert.equal(none._tag, "None")
+   * assert.equal(some._tag, "Some")
+   * if (some._tag === "Some") {
+   *   assert.deepStrictEqual(some.value, ["sells", 1])
+   * }
    * ```
    *
    * @since 2.0.0
    * @category getters
    */
-  <V>(self: Trie<V>, key: string): [string, V] | undefined
+  <V>(self: Trie<V>, key: string): Option<[string, V]>
 } = TR.longestPrefixOf
 
 /**
@@ -1488,13 +1501,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 +1528,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 +1537,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 +1550,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 +1577,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 +1586,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 +1597,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 +1626,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 +1635,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 +1646,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)
     })
-  ))
+)