chore: feat: added Effect.tapErrorTag

.changeset/tidy-carpets-act.md

@@ -0,0 +1,5 @@
+---
+"@effect/io": patch
+---
+
+added Effect.tapErrorTag

dtslint/Effect.ts

@@ -372,3 +372,20 @@ Effect.promise<string>(
       }, 2000)
     })
 )
+
+class TestError1 {
+  readonly _tag = "TestError1"
+  constructor() {}
+}
+
+// $ExpectType Effect<never, TestError1, never>
+pipe(
+  Effect.fail(new TestError1()),
+  Effect.tapErrorTag("TestError1", () => Effect.succeed(1))
+)
+
+// $ExpectType Effect<never, TestError1 | Error, never>
+pipe(
+  Effect.fail(new TestError1()),
+  Effect.tapErrorTag("TestError1", () => Effect.fail(new Error("")))
+)

src/Effect.ts

@@ -3618,6 +3618,24 @@ export const tapError: {
   <R, E, XE extends E, A, R2, E2, X>(self: Effect<R, E, A>, f: (e: XE) => Effect<R2, E2, X>): Effect<R | R2, E | E2, A>
 } = effect.tapError
 
+/**
+ * Returns an effect that effectfully "peeks" at the specific tagged failure of this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export const tapErrorTag: {
+  <K extends E["_tag"] & string, E extends { _tag: string }, R1, E1, A1>(
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Effect<R1, E1, A1>
+  ): <R, A>(self: Effect<R, E, A>) => Effect<R | R1, E | E1, A>
+  <R, E extends { _tag: string }, A, K extends E["_tag"] & string, R1, E1, A1>(
+    self: Effect<R, E, A>,
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Effect<R1, E1, A1>
+  ): Effect<R | R1, E | E1, A>
+} = effect.tapErrorTag
+
 /**
  * Returns an effect that effectually "peeks" at the cause of the failure of
  * this effect.

src/internal/effect.ts

@@ -1510,6 +1510,25 @@ export const tapError = dual<
     onSuccess: core.succeed
   }))
 
+/* @internal */
+export const tapErrorTag = dual<
+  <K extends E["_tag"] & string, E extends { _tag: string }, R1, E1, A1>(
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
+  ) => <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R1, E | E1, A>,
+  <R, E extends { _tag: string }, A, K extends E["_tag"] & string, R1, E1, A1>(
+    self: Effect.Effect<R, E, A>,
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
+  ) => Effect.Effect<R | R1, E | E1, A>
+>(3, (self, k, f) =>
+  tapError(self, (e) => {
+    if ("_tag" in e && e["_tag"] === k) {
+      return f(e as any)
+    }
+    return core.unit
+  }))
+
 /* @internal */
 export const tapErrorCause = dual<
   <E, XE extends E, R2, E2, X>(

test/Effect/tapping.ts

@@ -0,0 +1,29 @@
+import { pipe } from "@effect/data/Function"
+import * as Effect from "@effect/io/Effect"
+import { describe, expect, it } from "vitest"
+
+class TestError1 {
+  readonly _tag = "TestError1"
+  constructor() {}
+}
+
+class TestError2 {
+  readonly _tag = "TestError2"
+  constructor() {}
+}
+
+describe.concurrent("Effect", () => {
+  it("tapErrorTag", async () => {
+    let val = 0
+
+    await pipe(
+      Effect.fail<TestError1 | TestError2>(new TestError2()),
+      Effect.tapErrorTag("TestError1", () => Effect.sync(() => val += 1)), // not called
+      Effect.tapErrorTag("TestError2", () => Effect.sync(() => val += 1)), // called
+      Effect.catchAll(() => Effect.succeed("")),
+      Effect.runPromise
+    )
+
+    expect(val).toBe(1)
+  })
+})