effect 4.0.0-beta.6 → 4.0.0-beta.60

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

@@ -5,7 +5,7 @@
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and to track changes.
  * A transaction will retry whenever a conflict is detected or whenever the transaction explicitly
- * calls `Effect.retryTransaction` and any of the accessed TxChunk values change.
+ * calls `Effect.txRetry` and any of the accessed TxChunk values change.
  *
  * @since 4.0.0
  */
@@ -28,7 +28,7 @@ const TypeId = "~effect/transactions/TxChunk"
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and to track changes.
  * A transaction will retry whenever a conflict is detected or whenever the transaction explicitly
- * calls `Effect.retryTransaction` and any of the accessed TxChunk values change.
+ * calls `Effect.txRetry` and any of the accessed TxChunk values change.
  *
  * @example
  * ```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.tx(
  *     Effect.gen(function*() {
  *       yield* TxChunk.prepend(txChunk, 0)
  *       yield* TxChunk.append(txChunk, 5)
@@ -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.tx(
  *     Effect.gen(function*() {
  *       yield* TxChunk.append(txChunk, 6)
  *       yield* TxChunk.prepend(txChunk, 0)
@@ -263,9 +263,7 @@ export const modify: {
    */
   <A, R>(
     f: (current: Chunk.Chunk<NoInfer<A>>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): (
-    self: TxChunk<A>
-  ) => Effect.Effect<R>
+  ): (self: TxChunk<A>) => Effect.Effect<R>
   /**
    * Modifies the value of the `TxChunk` using the provided function.
    *
@@ -386,8 +384,10 @@ export const update: {
   <A>(self: TxChunk<A>, f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>): Effect.Effect<void>
 } = 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> => TxRef.update(self.ref, f)
 )
 
 /**
@@ -493,7 +493,10 @@ export const set: {
    * @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))
+} = dual(
+  2,
+  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void> => TxRef.set(self.ref, chunk)
+)
 
 /**
  * Appends an element to the end of the `TxChunk`.
@@ -809,7 +812,10 @@ export const take: {
    * @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)))
+} = dual(
+  2,
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void> => update(self, (current) => Chunk.take(current, n))
+)
 
 /**
  * Drops the first `n` elements from the `TxChunk`.
@@ -886,7 +892,10 @@ export const drop: {
    * @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)))
+} = dual(
+  2,
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void> => update(self, (current) => Chunk.drop(current, n))
+)
 
 /**
  * Takes a slice of the `TxChunk` from `start` to `end` (exclusive).
@@ -1452,10 +1461,11 @@ 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(
+} = dual(
+  2,
+  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void> =>
     Effect.gen(function*() {
       const otherChunk = yield* get(other)
       yield* appendAll(self, otherChunk)
-    })
-  ))
+    }).pipe(Effect.tx)
+)

package/src/TxDeferred.ts

@@ -0,0 +1,391 @@
+/**
+ * A transactional deferred value — a write-once cell that can be read within transactions.
+ * Readers retry until a value is set; once set, the value is immutable.
+ *
+ * @since 4.0.0
+ */
+
+import * as Effect from "./Effect.ts"
+import { dual } from "./Function.ts"
+import type { Inspectable } from "./Inspectable.ts"
+import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
+import type { Option } from "./Option.ts"
+import * as O from "./Option.ts"
+import type { Pipeable } from "./Pipeable.ts"
+import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
+import type { Result } from "./Result.ts"
+import * as Res from "./Result.ts"
+import * as TxRef from "./TxRef.ts"
+
+const TypeId = "~effect/transactions/TxDeferred"
+
+/**
+ * A transactional deferred — a write-once cell readable within transactions.
+ *
+ * Readers block (retry the transaction) until a value is committed.
+ * Writers succeed only on the first call; subsequent writes return `false`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, TxDeferred } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const deferred = yield* TxDeferred.make<number>()
+ *
+ *   // Complete the deferred
+ *   const first = yield* TxDeferred.succeed(deferred, 42)
+ *   console.log(first) // true
+ *
+ *   // Second write is a no-op
+ *   const second = yield* TxDeferred.succeed(deferred, 99)
+ *   console.log(second) // false
+ *
+ *   // Read the value
+ *   const value = yield* TxDeferred.await(deferred)
+ *   console.log(value) // 42
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export interface TxDeferred<in out A, in out E = never> extends Inspectable, Pipeable {
+  readonly [TypeId]: typeof TypeId
+  readonly ref: TxRef.TxRef<Option<Result<A, E>>>
+}
+
+const TxDeferredProto: Omit<TxDeferred<unknown, unknown>, typeof TypeId | "ref"> = {
+  [NodeInspectSymbol](this: TxDeferred<unknown, unknown>) {
+    return toJson(this)
+  },
+  toJSON(this: TxDeferred<unknown, unknown>) {
+    return {
+      _id: "TxDeferred"
+    }
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const makeTxDeferred = <A, E>(ref: TxRef.TxRef<Option<Result<A, E>>>): TxDeferred<A, E> => {
+  const self = Object.create(TxDeferredProto)
+  self[TypeId] = TypeId
+  self.ref = ref
+  return self
+}
+
+/**
+ * Creates a new empty `TxDeferred`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option, TxDeferred } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const deferred = yield* TxDeferred.make<string, Error>()
+ *   const state = yield* TxDeferred.poll(deferred)
+ *   console.log(Option.isNone(state)) // true
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const make = <A, E = never>(): Effect.Effect<TxDeferred<A, E>> =>
+  Effect.map(TxRef.make<Option<Result<A, E>>>(O.none()), makeTxDeferred)
+
+/**
+ * Reads the deferred value. Retries the transaction if the deferred has not
+ * been completed yet.
+ *
+ * @example
+ * ```ts
+ * import { Effect, TxDeferred } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const deferred = yield* TxDeferred.make<number>()
+ *   yield* TxDeferred.succeed(deferred, 42)
+ *   const value = yield* TxDeferred.await(deferred)
+ *   console.log(value) // 42
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category getters
+ */
+const await_ = <A, E>(self: TxDeferred<A, E>): Effect.Effect<A, E> =>
+  Effect.gen(function*() {
+    const option = yield* TxRef.get(self.ref)
+    if (O.isNone(option)) {
+      return yield* Effect.txRetry
+    }
+    return Res.isSuccess(option.value)
+      ? option.value.success
+      : yield* Effect.fail(option.value.failure)
+  }).pipe(Effect.tx)
+
+export {
+  /**
+   * Reads the deferred value. Retries the transaction if the deferred has not
+   * been completed yet.
+   *
+   * @since 4.0.0
+   * @category getters
+   */
+  await_ as await
+}
+
+/**
+ * Reads the current state of the deferred without retrying. Returns `None` if
+ * not yet completed.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option, Result, TxDeferred } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const deferred = yield* TxDeferred.make<number>()
+ *   const before = yield* TxDeferred.poll(deferred)
+ *   console.log(Option.isNone(before)) // true
+ *
+ *   yield* TxDeferred.succeed(deferred, 42)
+ *   const after = yield* TxDeferred.poll(deferred)
+ *   console.log(after) // Some(Success(42))
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category getters
+ */
+export const poll = <A, E>(self: TxDeferred<A, E>): Effect.Effect<Option<Result<A, E>>> => TxRef.get(self.ref)
+
+/**
+ * Completes the deferred with a `Result`. Returns `true` if this was the first
+ * completion, `false` if already completed.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Result, TxDeferred } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const deferred = yield* TxDeferred.make<number, string>()
+ *   const first = yield* TxDeferred.done(deferred, Result.succeed(42))
+ *   console.log(first) // true
+ *   const second = yield* TxDeferred.done(deferred, Result.succeed(99))
+ *   console.log(second) // false
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category mutations
+ */
+export const done: {
+  /**
+   * Completes the deferred with a `Result`. Returns `true` if this was the first
+   * completion, `false` if already completed.
+   *
+   * @example
+   * ```ts
+   * import { Effect, Result, TxDeferred } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const deferred = yield* TxDeferred.make<number, string>()
+   *   const first = yield* TxDeferred.done(deferred, Result.succeed(42))
+   *   console.log(first) // true
+   *   const second = yield* TxDeferred.done(deferred, Result.succeed(99))
+   *   console.log(second) // false
+   * })
+   * ```
+   *
+   * @since 4.0.0
+   * @category mutations
+   */
+  <A, E>(result: Result<A, E>): (self: TxDeferred<A, E>) => Effect.Effect<boolean>
+  /**
+   * Completes the deferred with a `Result`. Returns `true` if this was the first
+   * completion, `false` if already completed.
+   *
+   * @example
+   * ```ts
+   * import { Effect, Result, TxDeferred } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const deferred = yield* TxDeferred.make<number, string>()
+   *   const first = yield* TxDeferred.done(deferred, Result.succeed(42))
+   *   console.log(first) // true
+   *   const second = yield* TxDeferred.done(deferred, Result.succeed(99))
+   *   console.log(second) // false
+   * })
+   * ```
+   *
+   * @since 4.0.0
+   * @category mutations
+   */
+  <A, E>(self: TxDeferred<A, E>, result: Result<A, E>): Effect.Effect<boolean>
+} = dual(
+  2,
+  <A, E>(self: TxDeferred<A, E>, result: Result<A, E>): Effect.Effect<boolean> =>
+    TxRef.modify(self.ref, (current) => {
+      if (O.isSome(current)) {
+        return [false, current]
+      }
+      return [true, O.some(result)]
+    })
+)
+
+/**
+ * Completes the deferred with a success value. Returns `true` if this was the
+ * first completion, `false` if already completed.
+ *
+ * @example
+ * ```ts
+ * import { Effect, TxDeferred } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const deferred = yield* TxDeferred.make<number>()
+ *   const first = yield* TxDeferred.succeed(deferred, 42)
+ *   console.log(first) // true
+ *   const second = yield* TxDeferred.succeed(deferred, 99)
+ *   console.log(second) // false
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category mutations
+ */
+export const succeed: {
+  /**
+   * Completes the deferred with a success value. Returns `true` if this was the
+   * first completion, `false` if already completed.
+   *
+   * @example
+   * ```ts
+   * import { Effect, TxDeferred } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const deferred = yield* TxDeferred.make<number>()
+   *   const first = yield* TxDeferred.succeed(deferred, 42)
+   *   console.log(first) // true
+   *   const second = yield* TxDeferred.succeed(deferred, 99)
+   *   console.log(second) // false
+   * })
+   * ```
+   *
+   * @since 4.0.0
+   * @category mutations
+   */
+  <A>(value: A): <E>(self: TxDeferred<A, E>) => Effect.Effect<boolean>
+  /**
+   * Completes the deferred with a success value. Returns `true` if this was the
+   * first completion, `false` if already completed.
+   *
+   * @example
+   * ```ts
+   * import { Effect, TxDeferred } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const deferred = yield* TxDeferred.make<number>()
+   *   const first = yield* TxDeferred.succeed(deferred, 42)
+   *   console.log(first) // true
+   *   const second = yield* TxDeferred.succeed(deferred, 99)
+   *   console.log(second) // false
+   * })
+   * ```
+   *
+   * @since 4.0.0
+   * @category mutations
+   */
+  <A, E>(self: TxDeferred<A, E>, value: A): Effect.Effect<boolean>
+} = dual(
+  2,
+  <A, E>(self: TxDeferred<A, E>, value: A): Effect.Effect<boolean> => done(self, Res.succeed(value))
+)
+
+/**
+ * Completes the deferred with a failure. Returns `true` if this was the first
+ * completion, `false` if already completed.
+ *
+ * @example
+ * ```ts
+ * import { Effect, TxDeferred } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const deferred = yield* TxDeferred.make<number, string>()
+ *   const first = yield* TxDeferred.fail(deferred, "boom")
+ *   console.log(first) // true
+ *   const second = yield* TxDeferred.fail(deferred, "boom2")
+ *   console.log(second) // false
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category mutations
+ */
+export const fail: {
+  /**
+   * Completes the deferred with a failure. Returns `true` if this was the first
+   * completion, `false` if already completed.
+   *
+   * @example
+   * ```ts
+   * import { Effect, TxDeferred } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const deferred = yield* TxDeferred.make<number, string>()
+   *   const first = yield* TxDeferred.fail(deferred, "boom")
+   *   console.log(first) // true
+   *   const second = yield* TxDeferred.fail(deferred, "boom2")
+   *   console.log(second) // false
+   * })
+   * ```
+   *
+   * @since 4.0.0
+   * @category mutations
+   */
+  <E>(error: E): <A>(self: TxDeferred<A, E>) => Effect.Effect<boolean>
+  /**
+   * Completes the deferred with a failure. Returns `true` if this was the first
+   * completion, `false` if already completed.
+   *
+   * @example
+   * ```ts
+   * import { Effect, TxDeferred } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const deferred = yield* TxDeferred.make<number, string>()
+   *   const first = yield* TxDeferred.fail(deferred, "boom")
+   *   console.log(first) // true
+   *   const second = yield* TxDeferred.fail(deferred, "boom2")
+   *   console.log(second) // false
+   * })
+   * ```
+   *
+   * @since 4.0.0
+   * @category mutations
+   */
+  <A, E>(self: TxDeferred<A, E>, error: E): Effect.Effect<boolean>
+} = dual(
+  2,
+  <A, E>(self: TxDeferred<A, E>, error: E): Effect.Effect<boolean> => done(self, Res.fail(error))
+)
+
+/**
+ * Determines if the provided value is a `TxDeferred`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, TxDeferred } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const deferred = yield* TxDeferred.make<number>()
+ *   console.log(TxDeferred.isTxDeferred(deferred)) // true
+ *   console.log(TxDeferred.isTxDeferred("not a deferred")) // false
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category guards
+ */
+export const isTxDeferred = (u: unknown): u is TxDeferred<unknown, unknown> => hasProperty(u, TypeId)