Deferred is subtype of Effect (#3572)

Co-authored-by: maksim.khramtsov <maksim.khramtsov@btsdigital.kz>

.changeset/gorgeous-toes-help.md

@@ -0,0 +1,16 @@
+---
+"effect": minor
+---
+
+The `Deferred<A>` is now a subtype of `Effect<A>`. This change simplifies handling of deferred values, removing the need for explicit call `Deffer.await`.
+
+```typescript
+import { Effect, Deferred } from "effect"
+
+Effect.gen(function* () {
+  const deferred = yield* Deferred.make<string>()
+
+  const before = yield* Deferred.await(deferred)
+  const after = yield* deferred
+})
+```

packages/effect/dtslint/Unify.ts

@@ -1,3 +1,4 @@
+import type * as Deferred from "effect/Deferred"
 import type * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import type * as Exit from "effect/Exit"
@@ -66,8 +67,13 @@ export type RcRefUnify = Unify.Unify<
   | RcRef.RcRef<1, 2>
   | RcRef.RcRef<"a", "b">
 >
+// $ExpectType Deferred<1, 2> | Deferred<"a", "b">
+export type DeferredUnify = Unify.Unify<
+  | Deferred.Deferred<1, 2>
+  | Deferred.Deferred<"a", "b">
+>
 
-// $ExpectType 0 | Option<string | number> | Ref<1> | SynchronizedRef<1> | SubscriptionRef<1> | Ref<"A"> | SynchronizedRef<"A"> | SubscriptionRef<"A"> | Either<1 | "A", 0 | "E"> | Effect<1 | "A", 0 | "E", "R" | "R1"> | RcRef<1 | "A", 0 | "E">
+// $ExpectType 0 | Option<string | number> | Ref<1> | SynchronizedRef<1> | SubscriptionRef<1> | Deferred<1, 2> | Deferred<"a", "b"> | Ref<"A"> | SynchronizedRef<"A"> | SubscriptionRef<"A"> | Either<1 | "A", 0 | "E"> | Effect<1 | "A", 0 | "E", "R" | "R1"> | RcRef<1 | "A", 0 | "E">
 export type AllUnify = Unify.Unify<
   | Either.Either<1, 0>
   | Either.Either<"A", "E">
@@ -83,5 +89,7 @@ export type AllUnify = Unify.Unify<
   | SubscriptionRef.SubscriptionRef<"A">
   | RcRef.RcRef<1, 0>
   | RcRef.RcRef<"A", "E">
+  | Deferred.Deferred<1, 2>
+  | Deferred.Deferred<"a", "b">
   | 0
 >

packages/effect/src/Deferred.ts

@@ -10,8 +10,8 @@ import * as core from "./internal/core.js"
 import * as internal from "./internal/deferred.js"
 import type * as MutableRef from "./MutableRef.js"
 import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -37,11 +37,30 @@ export type DeferredTypeId = typeof DeferredTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Deferred<in out A, in out E = never> extends Deferred.Variance<A, E>, Pipeable {
+export interface Deferred<in out A, in out E = never> extends Effect.Effect<A, E>, Deferred.Variance<A, E> {
   /** @internal */
   readonly state: MutableRef.MutableRef<internal.State<A, E>>
   /** @internal */
   readonly blockingOn: FiberId.FiberId
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: DeferredUnify<this>
+  readonly [Unify.ignoreSymbol]?: DeferredUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface DeferredUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  Deferred?: () => Extract<A[Unify.typeSymbol], Deferred<any>>
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface DeferredUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
 }
 
 /**

packages/effect/src/internal/core.ts

@@ -43,7 +43,7 @@ import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
 import * as internalDiffer from "./differ.js"
-import { effectVariance, StructuralCommitPrototype } from "./effectable.js"
+import { CommitPrototype, effectVariance, StructuralCommitPrototype } from "./effectable.js"
 import { getBugErrorMessage } from "./errors.js"
 import type * as FiberRuntime from "./fiberRuntime.js"
 import type * as fiberScope from "./fiberScope.js"
@@ -2787,14 +2787,18 @@ const exitCollectAllInternal = <A, E>(
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const deferredUnsafeMake = <A, E = never>(fiberId: FiberId.FiberId): Deferred.Deferred<A, E> => ({
-  [deferred.DeferredTypeId]: deferred.deferredVariance,
-  state: MutableRef.make(deferred.pending([])),
-  blockingOn: fiberId,
-  pipe() {
-    return pipeArguments(this, arguments)
+export const deferredUnsafeMake = <A, E = never>(fiberId: FiberId.FiberId): Deferred.Deferred<A, E> => {
+  const _deferred = {
+    ...CommitPrototype,
+    [deferred.DeferredTypeId]: deferred.deferredVariance,
+    state: MutableRef.make(deferred.pending<A, E>([])),
+    commit() {
+      return deferredAwait(this)
+    },
+    blockingOn: fiberId
   }
-})
+  return _deferred
+}
 
 /* @internal */
 export const deferredMake = <A, E = never>(): Effect.Effect<Deferred.Deferred<A, E>> =>

packages/effect/test/Deferred.test.ts

@@ -157,4 +157,14 @@ describe("Deferred", () => {
       )
       assert.isTrue(Exit.isInterrupted(result))
     }))
+  it.effect("is subtype of Effect", () =>
+    Effect.gen(function*() {
+      const deferred = yield* Deferred.make<number>()
+      const ref = yield* Ref.make(13)
+      yield* Deferred.complete(deferred, Ref.updateAndGet(ref, (n) => n + 1))
+      const result1 = yield* deferred
+      const result2 = yield* deferred
+      assert.strictEqual(result1, 14)
+      assert.strictEqual(result2, 14)
+    }))
 })